/// <summary> /// Avance de la distance spécifiée suivant l'angle actuel /// </summary> /// <param name="distance">Distance à avancer (mm)</param> public void Avancer(double distance) { double depX = distance * Math.Cos(Angle.AngleRadians); double depY = distance * Math.Sin(Angle.AngleRadians); Coordonnees = Coordonnees.Translation(depX, depY); }
public void AjouterPoint(PointReel point) { PointsPassage.Add(point); if (PointsPassage.Count > 1) Segments.Add(new Segment(PointsPassage[PointsPassage.Count - 2], PointsPassage[PointsPassage.Count - 1])); }
public ZoneInteret(PointReel position, Color couleur, int rayon) : base(position, rayon) { Interet = true; Hover = false; Couleur = couleur; }
/// <summary> /// Retourneles coordonnées d'un point en fonction d'une position de départ et d'une direction /// </summary> /// <param name="depart">Point de départ</param> /// <param name="direction">Direction</param> /// <returns>Coordonnées du point</returns> public static PointReel GetCoordonnees(Position depart, Direction direction) { Angle angleAdverse = direction.angle + depart.Angle; double x = depart.Coordonnees.X + Math.Cos(angleAdverse.AngleRadians) * direction.distance; double y = depart.Coordonnees.Y + Math.Sin(angleAdverse.AngleRadians) * direction.distance; PointReel positionAdv = new PointReel(x, y); return positionAdv; }
public List<IActionDuree> ToActions() { List<IActionDuree> actions = new List<IActionDuree>(); Angle angle = new Angle(AngleDepart); for (int i = 0; i < PointsPassage.Count - 1; i++) { PointReel c1 = new PointReel(PointsPassage[i].X, PointsPassage[i].Y); PointReel c2 = new PointReel(PointsPassage[i + 1].X, PointsPassage[i + 1].Y); Position p = new Position(angle, c1); Direction traj = Maths.GetDirection(p, c2); // Teste si il est plus rapide (moins d'angle à tourner) de se déplacer en marche arrière bool inverse = false; if (Math.Abs(traj.angle.AngleDegres) > 90) { inverse = true; traj.angle = new Angle(traj.angle.AngleDegres - 180); } if (traj.angle.AngleDegres < 0) { actions.Add(new ActionPivot(Robots.GrosRobot, -traj.angle, SensGD.Droite)); angle -= traj.angle; } else if (traj.angle.AngleDegres > 0) { actions.Add(new ActionPivot(Robots.GrosRobot, traj.angle, SensGD.Gauche)); angle -= traj.angle; } if (inverse) actions.Add(new ActionRecule(Robots.GrosRobot, (int)(traj.distance))); else actions.Add(new ActionAvance(Robots.GrosRobot, (int)(traj.distance))); } Angle diff = angle - AngleFinal; if (Math.Abs(diff.AngleDegres) > 0.2) { if (diff.AngleDegres < 0) actions.Add(new ActionPivot(Robots.GrosRobot, -diff, SensGD.Droite)); else actions.Add(new ActionPivot(Robots.GrosRobot, diff, SensGD.Gauche)); } return actions; }
protected override void ThreadGros() { Thread.Sleep(200); while (true) { int next = rand.Next(Robots.GrosRobot.Graph.Nodes.Count); if (!((Node)Robots.GrosRobot.Graph.Nodes[next]).Passable) continue; PointReel destination = new PointReel(((Node)Robots.GrosRobot.Graph.Nodes[next]).X, ((Node)Robots.GrosRobot.Graph.Nodes[next]).Y); Robots.GrosRobot.Historique.Log("Nouvelle destination " + destination.X + ":" + destination.Y); Robots.GrosRobot.PathFinding(destination.X, destination.Y, rand.Next(360), 0, true); } }
/// <summary> /// Retourne la direction (angle et distance) à suivre pour arriver à un point donné en partant d'une position précise (coordonnées et angle) /// </summary> /// <param name="depart">Position de départ</param> /// <param name="arrivee">Coordonnées d'arrivée</param> /// <returns>Direction à prendre</returns> public static Direction GetDirection(Position depart, PointReel arrivee) { Direction result = new Direction(); double distance = depart.Coordonnees.Distance(arrivee); result.distance = distance; PointReel devantRobot = new PointReel(depart.Coordonnees.X + Math.Cos(depart.Angle.AngleRadians) * 100, depart.Coordonnees.Y + Math.Sin(depart.Angle.AngleRadians) * 100); Angle angle; double angleCalc = 0; // Deux points sur le même axe vertical : 90° ou -90° selon le point le plus haut if (arrivee.X == depart.Coordonnees.X) { angleCalc = Math.PI / 2; if (arrivee.Y > depart.Coordonnees.Y) angleCalc = -angleCalc; } // Deux points sur le même axe horizontal : 0° ou 180° selon le point le plus à gauche else if (arrivee.Y == depart.Coordonnees.Y) { angleCalc = Math.PI; if (arrivee.X > depart.Coordonnees.X) angleCalc = 0; } // Cas général : Calcul de l'angle else { angleCalc = Math.Acos((arrivee.X - depart.Coordonnees.X) / distance); if (arrivee.Y > depart.Coordonnees.Y) angleCalc = -angleCalc; } // Prendre en compte l'angle initial du robot angle = new Angle(angleCalc, AnglyeType.Radian); angle = angle + depart.Angle; result.angle = angle; return result; }
/// <summary> /// Constructeur /// </summary> /// <param name="balise">Balise ayant émis cette mesure</param> /// <param name="angleDebut">Début de l'angle mesuré</param> /// <param name="angleFin">Fin de l'angle mesuré</param> public DetectionBalise(Balise balise, double angleDebut, double angleFin) { AngleDebut = angleDebut; AngleFin = angleFin; AngleCentral = (angleDebut + angleFin ) / 2; Distance = AngleVisibleToDistance(Math.Abs(AngleFin - AngleDebut)); // Bornes if (Distance > Plateau.LongueurPlateau) Distance = Plateau.LongueurPlateau; if (Distance < 1) Distance = 1; // Un peu de trigo pas bien compliquée double xPoint = balise.Position.Coordonnees.X + Math.Cos(Maths.DegreeToRadian(AngleCentral)) * Distance; double yPoint = balise.Position.Coordonnees.Y + Math.Sin(Maths.DegreeToRadian(AngleCentral)) * Distance; Position = new PointReel(xPoint, yPoint); Balise = balise; }
public RectanglePolygone(PointReel pointHautGauche, double largeur, double hauteur) { cotes = new List<Segment>(); List<Segment> cotesPoly = new List<Segment>(); if (largeur < 0 || hauteur < 0 || pointHautGauche == null) throw new ArgumentOutOfRangeException(); List<PointReel> points = new List<PointReel>(); points.Add(new PointReel(pointHautGauche.X, pointHautGauche.Y)); points.Add(new PointReel(pointHautGauche.X + largeur, pointHautGauche.Y)); points.Add(new PointReel(pointHautGauche.X + largeur, pointHautGauche.Y + hauteur)); points.Add(new PointReel(pointHautGauche.X, pointHautGauche.Y + hauteur)); for (int i = 1; i < points.Count; i++) cotesPoly.Add(new Segment(points[i - 1], points[i])); cotesPoly.Add(new Segment(points[points.Count - 1], points[0])); construirePolygone(cotesPoly); }
/// <summary> /// Construit une position selon les paramètres /// </summary> /// <param name="a">Angle de départ</param> /// <param name="c">Coordonnées de départ</param> public Position(Angle a, PointReel c) { Angle = a; Coordonnees = c; }
/// <summary> /// Transforme une détection de balise en triangle /// </summary> /// <returns>Triangle correspondant à la détection</returns> public Polygone ToPolygone() { List<PointReel> listePoints = new List<PointReel>(); // Point de la balise double xPoint1 = Balise.Position.Coordonnees.X; double yPoint1 = Balise.Position.Coordonnees.Y; PointReel point = new PointReel(xPoint1, yPoint1); listePoints.Add(point); // Point du côté du début de l'angle // 5000 valeur arbitraire, assez grande pour dépasser de la table xPoint1 = Balise.Position.Coordonnees.X + Math.Cos(Maths.DegreeToRadian(AngleDebut)) * 5000; yPoint1 = Balise.Position.Coordonnees.Y + Math.Sin(Maths.DegreeToRadian(AngleDebut)) * 5000; point = new PointReel(xPoint1, yPoint1); listePoints.Add(point); // Point du côté du début de l'angle xPoint1 = Balise.Position.Coordonnees.X + Math.Cos(Maths.DegreeToRadian(AngleFin)) * 5000; yPoint1 = Balise.Position.Coordonnees.Y + Math.Sin(Maths.DegreeToRadian(AngleFin)) * 5000; point = new PointReel(xPoint1, yPoint1); listePoints.Add(point); Polygone polygone = new Polygone(listePoints); return polygone; }
private void PathFindingClick() { PointReel positionReelle = Dessinateur.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition)); if (Dessinateur.modeCourant == Dessinateur.Mode.FinTrajectoire) { Robots.GrosRobot.PathFinding(positionReelle.X, positionReelle.Y); Dessinateur.modeCourant = Dessinateur.Mode.Visualisation; } else { PointReel point = new PointReel(positionReelle.X, positionReelle.Y); /* Todo Tester ici si le clic a été fait sur un élément de jeu dans le but de lancer un mouvement. Si c'est le cas, lancer un thread pour effectuer le mouvement exemple : if (Plateau.ZoneDepartVert.Hover) move = new MouvementDeposeDepart(Plateau.ZoneDepartVert);*/ if (move != null) { thAction = new Thread(ThreadAction); thAction.Start(); } } }
private void pictureBoxTable_MouseMove(object sender, MouseEventArgs e) { semMove.WaitOne(); Dessinateur.PositionCurseur = pictureBoxTable.PointToClient(MousePosition); if (pSelected != -1) { pointsPolaires[pSelected] = Dessinateur.ScreenToRealPosition(e.Location); trajectoirePolaire = BezierCurve.GetPoints(pointsPolaires, (int)(numNbPoints.Value));//((int)pointsPolaires[0].Distance(pointsPolaires[pointsPolaires.Count - 1])) / 50); Dessinateur.TrajectoirePolaire = trajectoirePolaire; Dessinateur.PointsPolaire = pointsPolaires; } if (boxSourisObstacle.Checked) { if ((DateTime.Now - dateCapture).TotalMilliseconds > 50) { dateCapture = DateTime.Now; Point p = Dessinateur.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition)); List<PointReel> positions = new List<PointReel>(); positions.Add(Dessinateur.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition))); Plateau.Balise.Actualisation(false, Dessinateur.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition))); //SuiviBalise.MajPositions(positions, Plateau.Enchainement == null || Plateau.Enchainement.DebutMatch == null); } } else { Point positionSurTable = Dessinateur.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition)); lblPos.Text = positionSurTable.X + " : " + positionSurTable.Y; bool hoverElement = false; PointReel positionRelle = new PointReel(positionSurTable.X, positionSurTable.Y); for (int i = 0; i < Plateau.ElementsJeu.Count; i++) { if (positionRelle.Distance(Plateau.ElementsJeu[i].Position) < Plateau.ElementsJeu[i].RayonHover) { Plateau.ElementsJeu[i].Hover = true; hoverElement = true; } else Plateau.ElementsJeu[i].Hover = false; } if (hoverElement) this.Cursor = Cursors.Hand; else this.Cursor = Cursors.Arrow; System.Threading.Tasks.Task.Factory.StartNew(() => ChercheTraj(new Position(Robots.GrosRobot.Position))); } semMove.Release(); }
private static void CalculVecteurs() { for(int i = 0; i < PositionsEnnemies.Count; i++) { List<PointReel> deplacements = new List<PointReel>(); for (int j = 1; j < PositionsTemporelles[i].Count; j++) { double dx = PositionsTemporelles[i][j].Position.X - PositionsTemporelles[i][j - 1].Position.X; double dy = PositionsTemporelles[i][j].Position.Y - PositionsTemporelles[i][j - 1].Position.Y; TimeSpan t = PositionsTemporelles[i][j].Date - PositionsTemporelles[i][j - 1].Date; if(t.TotalMilliseconds > 0) deplacements.Add(new PointReel(dx * 1000.0 / t.TotalMilliseconds, dy * 1000.0 / t.TotalMilliseconds)); } double x = 0, y = 0; foreach (PointReel p in deplacements) { x += p.X; y += p.Y; } if (deplacements.Count > 0) { x /= deplacements.Count; y /= deplacements.Count; } VecteursPositionsEnnemies[i] = new PointReel(x, y); } }
/// <summary> /// Constructeur /// </summary> /// <param name="date">Date d'acquisition de la position</param> /// <param name="position">Position mesurée</param> public PositionTemporelle(DateTime date, PointReel position) { Date = date; Position = position; }
public static Direction GetDirection(PointReel depart, PointReel arrivee) { Position positionDepart = new Position(0, depart); return GetDirection(positionDepart, arrivee); }
public static void Dessine() { DateTime prec = DateTime.Now; PositionCurseur = new PointReel(); while (Thread.CurrentThread.IsAlive && !Config.Shutdown) { // Limitation à 30FPS int sleep = 33 - (DateTime.Now - prec).Milliseconds - 1; if (sleep > 0) Thread.Sleep(sleep); prec = DateTime.Now; try { Bitmap bmp = new Bitmap(Properties.Resources.TablePlan.Width, Properties.Resources.TablePlan.Height); { Graphics g = Graphics.FromImage(bmp); g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; if (AfficheTable) DessinePlateau(g); DessineGraph(Robots.GrosRobot, g); //DessineTrajectoire(g); if (Robots.GrosRobot != null) DessineRobot(Robots.GrosRobot, g); if (AfficheHistoriqueCoordonneesGros && Robots.GrosRobot.HistoriqueCoordonnees != null) DessineHistoriqueTrajectoire(Robots.GrosRobot, g); if (AfficheObstacles) DessineObstacles(g); //if (Robots.PetitRobot != null) // DessineRobot(Robots.PetitRobot, g); if (AfficheElementsJeu) DessineElementsJeu(g); DessinePathFinding(g); DessinePositionEnnemis(g); if (AfficheLigneDetections) DessineLignesDetection(g); if (Robots.GrosRobot.PositionCible != null) { Point p = RealToScreenPosition(Robots.GrosRobot.PositionCible); g.DrawEllipse(penRougeEpais, p.X - 5, p.Y - 5, 10, 10); } // Dessin des coûts des mouvements if (Plateau.Enchainement != null) { if (AfficheCoutsMouvementsGros) DessineCoutMouvements(Robots.GrosRobot, g); } if ((modeCourant == Mode.PositionRPCentre || modeCourant == Mode.TeleportRPCentre) && positionDepart != null) { Point positionFin = positionCurseur; Bitmap bmpGrosRobot = new Bitmap(RealToScreenDistance(Robots.GrosRobot.Taille * 3), RealToScreenDistance(Robots.GrosRobot.Taille * 3)); Graphics gGros = Graphics.FromImage(bmpGrosRobot); gGros.FillRectangle(brushTransparent, 0, 0, RealToScreenDistance(Robots.GrosRobot.Taille * 2), RealToScreenDistance(Robots.GrosRobot.Taille * 2)); Direction traj = Maths.GetDirection(positionDepart, PositionCurseurTable); gGros.FillRectangle(brushNoirTresTransparent, bmpGrosRobot.Width / 2 - RealToScreenDistance(Robots.GrosRobot.Largeur / 2), bmpGrosRobot.Height / 2 - RealToScreenDistance(Robots.GrosRobot.Longueur / 2), RealToScreenDistance(Robots.GrosRobot.Largeur), RealToScreenDistance(Robots.GrosRobot.Longueur)); gGros.DrawRectangle(Plateau.NotreCouleur == Plateau.CouleurGaucheViolet ? penCouleurJ1 : penCouleurJ2, bmpGrosRobot.Width / 2 - RealToScreenDistance(Robots.GrosRobot.Largeur / 2), bmpGrosRobot.Height / 2 - RealToScreenDistance(Robots.GrosRobot.Longueur / 2), RealToScreenDistance(Robots.GrosRobot.Largeur), RealToScreenDistance(Robots.GrosRobot.Longueur)); gGros.DrawLine(Plateau.NotreCouleur == Plateau.CouleurGaucheViolet ? penCouleurJ1 : penCouleurJ2, bmpGrosRobot.Width / 2, bmpGrosRobot.Height / 2, bmpGrosRobot.Width / 2, bmpGrosRobot.Height / 2 - RealToScreenDistance(Robots.GrosRobot.Longueur / 2)); Point pointOrigine = RealToScreenPosition(positionDepart); g.DrawImage(RotateImage(bmpGrosRobot, 360 - traj.angle.AngleDegres + 90), pointOrigine.X - bmpGrosRobot.Width / 2, pointOrigine.Y - bmpGrosRobot.Height / 2); g.DrawLine(penBlancFleche, (Point)RealToScreenPosition(positionDepart), positionFin); } else if ((modeCourant == Mode.PositionRPFace || modeCourant == Mode.TeleportRPFace) && positionDepart != null) { Point positionFin = positionCurseur; Bitmap bmpGrosRobot = new Bitmap(RealToScreenDistance(Robots.GrosRobot.Taille * 3), RealToScreenDistance(Robots.GrosRobot.Taille * 3)); Graphics gGros = Graphics.FromImage(bmpGrosRobot); gGros.FillRectangle(brushTransparent, 0, 0, RealToScreenDistance(Robots.GrosRobot.Taille * 2), RealToScreenDistance(Robots.GrosRobot.Taille * 2)); Direction traj = Maths.GetDirection(positionDepart, PositionCurseurTable); Point pointOrigine = RealToScreenPosition(positionDepart); Position departRecule = new Position(360 - traj.angle, pointOrigine); departRecule.Avancer(RealToScreenDistance(-Robots.GrosRobot.Longueur / 2)); gGros.FillRectangle(brushNoirTresTransparent, bmpGrosRobot.Width / 2 - RealToScreenDistance(Robots.GrosRobot.Largeur / 2), bmpGrosRobot.Height / 2 - RealToScreenDistance(Robots.GrosRobot.Longueur / 2), RealToScreenDistance(Robots.GrosRobot.Largeur), RealToScreenDistance(Robots.GrosRobot.Longueur)); gGros.DrawRectangle(Plateau.NotreCouleur == Plateau.CouleurGaucheViolet ? penCouleurJ1 : penCouleurJ2, bmpGrosRobot.Width / 2 - RealToScreenDistance(Robots.GrosRobot.Largeur / 2), bmpGrosRobot.Height / 2 - RealToScreenDistance(Robots.GrosRobot.Longueur / 2), RealToScreenDistance(Robots.GrosRobot.Largeur), RealToScreenDistance(Robots.GrosRobot.Longueur)); gGros.DrawLine(Plateau.NotreCouleur == Plateau.CouleurGaucheViolet ? penCouleurJ1 : penCouleurJ2, bmpGrosRobot.Width / 2, bmpGrosRobot.Height / 2, bmpGrosRobot.Width / 2, bmpGrosRobot.Height / 2 - RealToScreenDistance(Robots.GrosRobot.Longueur / 2)); g.DrawImage(RotateImage(bmpGrosRobot, 360 - traj.angle.AngleDegres + 90), (int)(departRecule.Coordonnees.X) - bmpGrosRobot.Width / 2, (int)(departRecule.Coordonnees.Y) - bmpGrosRobot.Height / 2); g.DrawLine(penBlancFleche, (Point)RealToScreenPosition(positionDepart), positionFin); } // Trajectoires foreach (Trajectoire traj in Trajectoires) { DessineTrajectoire(traj, g); } if (Robots.GrosRobot.TrajectoireEnCours != null) { Trajectoire traj = new Trajectoire(); traj.AjouterPoint(Robots.GrosRobot.Position.Coordonnees); for (int iPoint = 1; iPoint < Robots.GrosRobot.TrajectoireEnCours.PointsPassage.Count; iPoint++) traj.AjouterPoint(Robots.GrosRobot.TrajectoireEnCours.PointsPassage[iPoint]); DessineTrajectoire(traj, g); } // Trajectoire polaire //if (modeCourant == Mode.TrajectoirePolaire) { if (trajectoirePolaireScreen !=null) foreach (Point p in trajectoirePolaireScreen) g.FillEllipse(Brushes.Red, p.X - 1, p.Y - 1, 2, 2); if (pointsPolaireScreen != null) foreach (Point p in pointsPolaireScreen) g.DrawEllipse(Pens.Black, p.X - 3, p.Y - 3, 6, 6); } TableDessinee(bmp); } } catch (Exception ex) { Console.WriteLine("Erreur pendant le dessin de la table " + ex.Message); } } }
public static Point RealToScreenPosition(PointReel valeur) { return new Point(RealToScreenDistance(valeur.X) + OFFSET_IMAGE_X, RealToScreenDistance(valeur.Y) + OFFSET_IMAGE_Y); }
public Triangle(PointReel p1, PointReel p2, PointReel p3) : base(new List<PointReel>() { p1, p2, p3 }) { }
public void ObstacleTest(int x, int y) { // Obstacle de simulation ObstaclesBalise.Clear(); PointReel coordonnees = new PointReel(x, y); Console.Write(" Ajout obstacle"); AjouterObstacle(new Cercle(coordonnees, 200)); if (Plateau.Enchainement == null) { // Tester ici ce qu'il y a à tester en fonction de la position de l'ennemi AVANT de lancer le match } else { // Tester ici ce qu'il y a à tester en fonction de la position de l'ennemi PENDANT le match } SemaphoreCollisions.Release(); }
/// <summary> /// Déplace les coordonnées par rapport aux anciennes coordonnées /// </summary> /// <param name="x">Déplacement (mm) sur l'axe des abscisses</param> /// <param name="y">Déplacement (mm) sur l'axe des ordonnées</param> public void Deplacer(double x, double y) { Coordonnees = Coordonnees.Translation(x, y); }
public override void ReglerOffsetAsserv(int offsetX, int offsetY, double offsetTeta) { Position = new Position(new Angle(-offsetTeta, AnglyeType.Degre), new PointReel(offsetX, offsetY)); PositionCible = new PointReel(offsetX, offsetY); ChangerPosition(Position); }
public ElementJeu(PointReel position, int rayonHover) { RayonHover = rayonHover; Position = position; Ramasse = false; }
/// <summary> /// Actualisation des positions détectées par les balises par interpolation selon la méthode choisie /// </summary> public void Actualisation(bool balise = true, PointReel point = null) { try { List<PointReel> ennemis = new List<PointReel>(); List<PointReel> ennemisReduits = new List<PointReel>(); if (balise) ennemis.AddRange(Detections.Select(f => f.Position)); else ennemis.Add(point); while (ennemis.Count > 0) { List<int> detectionsSimilaires = new List<int>(); for (int j = ennemis.Count - 1; j > 0; j--) { if (ennemis[0].Distance(ennemis[j]) < 150) detectionsSimilaires.Add(j); } detectionsSimilaires.Add(0); int coeff = 0; double x = 0, y = 0; for (int i = 0; i < detectionsSimilaires.Count; i++) { x += (ennemis[detectionsSimilaires[i]].X * (i + 1) * (i + 1)); y += (ennemis[detectionsSimilaires[i]].Y * (i + 1) * (i + 1)); ennemis.RemoveAt(detectionsSimilaires[i]); coeff += (i + 1) * (i + 1); } x /= coeff; y /= coeff; ennemisReduits.Add(new PointReel(x, y)); } PositionsAdverses = new List<PointReel>(ennemisReduits); if (PositionEnnemisActualisee != null) PositionEnnemisActualisee(PositionsAdverses); } catch (Exception) { } }
/// <summary> /// Teste si on point est contenu dans la table /// </summary> /// <param name="croisement">Point à tester</param> /// <returns></returns> public static bool Contient(PointReel point) { if (point.X < 0 || point.Y < 0 || point.X > LongueurPlateau || point.Y > LargeurPlateau) return false; return true; }
/// <summary> /// Constructeur par copie /// </summary> public Position(Position other) { Angle = new Angle(other.Angle.AngleDegres); Coordonnees = new PointReel(other.Coordonnees); }
void Balise_PositionEnnemisActualisee(List<PointReel> positions) { // Positions ennemies signalées par la balise Synchronizer.Lock(ObstaclesBalise); ObstaclesBalise.Clear(); int vitesseMax = Config.CurrentConfig.GRVitesseLigneRapide; for (int i = 0; i < positions.Count; i++) { PointReel coordonnees = new PointReel(positions[i].X, positions[i].Y); AjouterObstacle(new Cercle(coordonnees, RayonAdversaire)); if (Plateau.Enchainement == null) { // Tester ici ce qu'il y a à tester en fonction de la position de l'ennemi AVANT de lancer le match } else { // Tester ici ce qu'il y a à tester en fonction de la position de l'ennemi PENDANT le match if (Robots.GrosRobot.VitesseAdaptableEnnemi) { double distanceAdv = Robots.GrosRobot.Position.Coordonnees.Distance(coordonnees); if (distanceAdv < 1500) { vitesseMax = (int)(Math.Min(vitesseMax, (distanceAdv - 300) / 1000.0 * Config.CurrentConfig.GRVitesseLigneRapide)); } } } } Synchronizer.Unlock(ObstaclesBalise); Robots.GrosRobot.MajGraphFranchissable(); SemaphoreCollisions.Release(); }
protected List<PointReel> ValeursToPositions(List<int> mesures, bool limiteTable = true) { List<PointReel> positions = new List<PointReel>(); double stepAngular = angleMesurable.AngleRadiansPositif / (double)mesures.Count; for (int i = 0; i < mesures.Count; i++) { if (mesures[i] > 100) // SUpprime tous les points à moins de 10cm { double angle = stepAngular * i; double sin = Math.Sin(angle - position.Angle.AngleRadiansPositif - angleMesurable.AngleRadiansPositif / 2 - Math.PI / 2) * mesures[i]; double cos = Math.Cos(angle - position.Angle.AngleRadiansPositif - angleMesurable.AngleRadiansPositif / 2 - Math.PI / 2) * mesures[i]; PointReel pos = new PointReel(position.Coordonnees.X - sin, position.Coordonnees.Y - cos); int marge = 20; // Marge en mm de distance de detection à l'exterieur de la table (pour ne pas jeter les mesures de la bordure qui ne collent pas parfaitement) if (!limiteTable || (pos.X > -marge && pos.X < Plateau.LongueurPlateau + marge && pos.Y > -marge && pos.Y < Plateau.LargeurPlateau + marge)) positions.Add(pos); } } return positions; }
public void MajGraphFranchissable() { Synchronizer.Lock(Graph); List<IForme> obstacles = new List<IForme>(Plateau.ObstaclesBalise); foreach (Arc arc in Graph.Arcs) arc.Passable = true; foreach (Node node in Graph.Nodes) node.Passable = true; foreach (IForme obstacle in obstacles) { // Teste les arcs non franchissables for (int i = 0; i < Graph.Arcs.Count; i++) { Arc arc = (Arc)Graph.Arcs[i]; if (arc.Passable) { Segment segment = new Segment(new PointReel(arc.StartNode.X, arc.StartNode.Y), new PointReel(arc.EndNode.X, arc.EndNode.Y)); // Marge de 20mm pour prévoir une trajectoire plus éloignée de l'adversaire if (TropProche(obstacle, segment, 20)) { arc.Passable = false; } } } // Teste les noeuds non franchissables for (int i = 0; i < Graph.Nodes.Count; i++) { Node n = (Node)Graph.Nodes[i]; if (n.Passable) { PointReel noeud = new PointReel(n.X, n.Y); if (TropProche(obstacle, noeud)) { n.Passable = false; } } } } Synchronizer.Unlock(Graph); }
/// <summary> /// Constructeur par défaut /// Angle de 0° et Coordonnées (0, 0) /// </summary> public Position() { Angle = new Angle(); Coordonnees = new PointReel(); }