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