Merge pull request #11 from MaelkMaelk/APS

Aps

Python/client.py

@@ -517,12 +517,11 @@ def main(server_ip: str):
         # Gestion des avions
         if survol_etiquette:  # on regarde si on doit dés étendre une étiquette ici
             for avion in dictAvionsAff.values():
-
-                if avion.etiquetteExtended and not avion.drag:
+                if avion.etiquetteExtended:
                     if avion.checkStillHovered():
                         avion.extendEtiquette()
                         survol_etiquette = False
-                    break
+                        break
 
         for avion in dictAvionsAff.values():
             avion.change_color()
@@ -591,7 +590,7 @@ def main(server_ip: str):
                 elif color[2] <= 255 - 40:
                     color[1] = 255
                     color[2] += 70
-                avion.drawEstimatedRoute(carte['points'], conflitGen.temps, color, win, zoom, scroll)
+                avion.drawEstimatedRoute(carte, conflitGen.temps, color, win, zoom, scroll)
 
         avionSurvol = None
         for avion in dictAvionsAff.values():
@@ -636,6 +635,16 @@ def main(server_ip: str):
             img = font.render("Sauvegardé", True, (70, 140, 240))
             win.blit(img, ((width - img.get_width())/2, (height - img.get_height())/2))
 
+        img = font.render("UpperWinds       ", True, (255, 255, 255))
+        x = (width - img.get_width())
+        y = 30
+        win.blit(img, (x, y))
+
+        for niveau, vent in carte['vent'].items():
+            y += img.get_height() + 3
+            img = font.render("FL" + str(round(niveau)) + "    " + str(round(vent[0])) + "/" + str(round(vent[1])) + "KT", True, (255, 255, 255))
+            win.blit(img, ((width - img.get_width()), y))
+
         # prise des screenshots
         if pygame.time.get_ticks() >= dernierScreen + delaiScreen and replayMode and not pilote:
             capture.saveScreenshot(win, dossierScreen / (horloge.heureXML(game.heure) + '.png'))

Python/geometry.py

@@ -8,7 +8,12 @@
 
 
 def calculateHeading(x: int, y: int, xPoint: int, yPoint: int):
-    if y > yPoint:
+    if x == xPoint:
+        if y > yPoint:
+            heading = 360
+        else:
+            heading = 180
+    elif y > yPoint:
         if x > xPoint:
             heading = (math.atan(abs(y - yPoint) / (abs(x - xPoint)))) * 180 / math.pi
             heading += 270

Python/interface.py

@@ -786,20 +786,19 @@ def checkEvent(self, event):
 
         elif self.valeur in ['C_HDG', 'HDG']:
             if event.ui_element in self.listeGauche:
-                self.kill()
-                if self.avion.papa.clearedHeading:
-                    heading = round(self.avion.papa.clearedHeading - int(event.ui_element.text[1:]))
-                else:
-                    heading = round(self.avion.papa.selectedHeading - int(event.ui_element.text[1:]))
-                return self.avion.Id, self.valeur, heading
-
+                valeurTourne = - int(event.ui_element.text[1:])
             elif event.ui_element in self.listeDroite:
-                self.kill()
-                if self.avion.papa.clearedHeading:
-                    heading = round(self.avion.papa.clearedHeading + int(event.ui_element.text[1:]))
-                else:
-                    heading = round(self.avion.papa.selectedHeading + int(event.ui_element.text[1:]))
-                return self.avion.Id, self.valeur, heading
+                valeurTourne = + int(event.ui_element.text[1:])
+            else:
+                return None
+
+            self.kill()
+            if self.avion.papa.clearedHeading and self.valeur == 'C_HDG':
+                heading = round(self.avion.papa.clearedHeading + valeurTourne) % 360
+            else:
+                heading = round(self.avion.papa.selectedHeading + valeurTourne) % 360
+
+            return self.avion.Id, self.valeur, heading
 
     def checkScrolled(self, event):
         """

Python/loadXML.py

@@ -74,7 +74,7 @@ def loadSegmentsXML(listeXML) -> dict:
 def loadAvionXML(avionXML, carte: dict, perfos: dict, heure: float, planeId: int) -> tuple[float, object]:
 
     """
-    Prends une balise XML en entrée et retourne une liste d'avion à faire spawn
+    Prends une balise XML en entrée et retourne un objet avion à faire spawn
     :param planeId: l'Id de l'avion
     :param heure: l'heure de début de simu
     :param perfos: la liste des perfos avions
@@ -154,3 +154,18 @@ def loadAvionXML(avionXML, carte: dict, perfos: dict, heure: float, planeId: int
 
     return heureSpawn, avionPack
 
+
+def loadWindXML(WindXML):
+
+    windDict = {}
+
+    for baliseNiveau in WindXML:
+
+        niveau = float(baliseNiveau.tag[2:])
+        direction = float(baliseNiveau.text)
+        force = float(baliseNiveau.attrib['kt'])
+
+        windDict.update({niveau: (direction, force)})
+
+    return windDict
+

Python/outils_radar.py

@@ -149,27 +149,39 @@ def computeSpawn(self, pos: list[float, float] | tuple[float, float], carte):
 
         points = carte['points']
         route = self.avion.route['points']
-        distance = self.temps * self.avion.speedPx / radarRefresh  # quelle distance va parcourir l'avion en ce temps
-        distance_calcule = 0
+        temps_calcule = 0
 
-        point2 = points[route[0]['name']]
+        segment = geometry.findClosestSegment(self.avion.route['points'], pos, carte['points'])
+        pos = geometry.calculateShortestPoint(points[segment[0]['name']], points[segment[1]['name']], pos)
+        p = segment[0]
 
-        p = geometry.findClosestSegment(self.avion.route['points'], pos, carte['points'])[0]
+        point2 = points[route[0]['name']]
 
         for index in range(len(route[:route.index(p)])):
             point1 = points[route[index]['name']]
             point2 = points[route[index + 1]['name']]
-            distance_calcule += geometry.calculateDistance(point1[0], point1[1], point2[0], point2[1])
-
-        offroadDistance = geometry.calculateDistance(pos[0], pos[1], point2[0], point2[1])
-        distance_calcule += offroadDistance
+            legDistance = geometry.calculateDistance(point1[0], point1[1], point2[0], point2[1])
+            legHeading = geometry.calculateHeading(point1[0], point1[1], point2[0], point2[1])
+            legSpeed = self.avion.speedTAS + self.avion.forceVent * math.cos(
+                (legHeading - self.avion.directionVent + 180) * math.pi / 180)
+            legSpeed = legSpeed * carte['mapScale'] / 60
+            legTemps = legDistance / legSpeed
+            temps_calcule += legTemps
+
+        legDistance = geometry.calculateDistance(pos[0], pos[1], point2[0], point2[1])
+        legHeading = geometry.calculateHeading(point2[0], point2[1], pos[0], pos[1])
+        legSpeed = self.avion.speedTAS + self.avion.forceVent * math.cos(
+            (legHeading - self.avion.directionVent + 180) * math.pi / 180)
+        legSpeed = legSpeed * carte['mapScale'] / 60
+        legTemps = legDistance / legSpeed
+        temps_calcule += legTemps
 
         a = list(range(len(route[:route.index(p) + 1])))
         self.drawListe = []
 
-        if distance_calcule <= distance:  # si on doit parcourir plus que ce qu'on a calculé au spawn
+        if temps_calcule <= self.temps:  # si on doit parcourir plus que ce qu'on a calculé au spawn
             #  alors on delay le spawn, temps ici en sec
-            self.spawnDelay = int((distance - distance_calcule) / self.avion.speedPx * radarRefresh)
+            self.spawnDelay = int(self.temps - temps_calcule)
             self.x = points[route[0]['name']][0]
             self.y = points[route[0]['name']][1]
 
@@ -178,19 +190,24 @@ def computeSpawn(self, pos: list[float, float] | tuple[float, float], carte):
 
         else:  # si on doit parcourir moins, alors on fait apparaître l'avion plus proche du secteur
             self.spawnDelay = None
-            distanceAparcourir = distance_calcule - distance
+            tempsAparcourir = temps_calcule - self.temps
             index = 0
             found = False
             for index in a:
                 point1 = points[route[index]['name']]
                 point2 = points[route[index + 1]['name']]
                 legDistance = geometry.calculateDistance(point1[0], point1[1], point2[0], point2[1])
+                legHeading = geometry.calculateHeading(point1[0], point1[1], point2[0], point2[1])
+                legSpeed = self.avion.speedTAS + self.avion.forceVent * math.cos(
+                    (legHeading - self.avion.directionVent + 180) * math.pi / 180)
+                legSpeed = legSpeed * carte['mapScale'] / 60
+                legTemps = legDistance / legSpeed
 
                 if found:
                     self.drawListe.append(point1)
 
-                elif legDistance >= distanceAparcourir:  # si on doit faire apparaître sur cette branche
-                    ratio = distanceAparcourir / legDistance
+                elif legTemps >= tempsAparcourir:  # si on doit faire apparaître sur cette branche
+                    ratio = tempsAparcourir / legTemps
                     self.x = ratio * (point2[0] - point1[0]) + point1[0]
                     self.y = ratio * (point2[1] - point1[1]) + point1[1]
                     self.drawListe.append((self.x, self.y))
@@ -199,7 +216,7 @@ def computeSpawn(self, pos: list[float, float] | tuple[float, float], carte):
                     found = True
 
                 else:
-                    distanceAparcourir -= legDistance
+                    tempsAparcourir -= legTemps
 
         self.drawListe.append(pos)
 
@@ -232,7 +249,7 @@ def increaseTime(self, temps, carte):
         delay = 0
         if self.spawnDelay:
             delay = self.spawnDelay
-        distance = (self.temps - delay) * self.avion.speedPx / radarRefresh  # quelle distance va parcourir l'avion en ce temps
+        temps = self.temps - delay
 
         startPlot = geometry.findClosestSegment(self.avion.route['points'], (self.x, self.y), points)[1]
         liste = self.avion.route['points'][self.avion.route['points'].index(startPlot):]
@@ -244,16 +261,21 @@ def increaseTime(self, temps, carte):
             point2 = points[liste[index]['name']]
 
             legDistance = geometry.calculateDistance(point1[0], point1[1], point2[0], point2[1])
-            if distance - legDistance <= 0:
-                ratio = distance / legDistance
+            legHeading = geometry.calculateHeading(point1[0], point1[1], point2[0], point2[1])
+            legSpeed = self.avion.speedTAS + self.avion.forceVent * math.cos(
+                (legHeading - self.avion.directionVent + 180) * math.pi / 180)
+            legSpeed = legSpeed * carte['mapScale'] / 60
+            legTemps = legDistance / legSpeed
+            if temps - legTemps <= 0:
+                ratio = temps / legTemps
                 x = ratio * (point2[0] - point1[0]) + point1[0]
                 y = ratio * (point2[1] - point1[1]) + point1[1]
                 self.drawListe.append(point1)
                 self.drawListe.append((x, y))
                 break
 
             else:
-                distance -= legDistance
+                temps -= legTemps
                 self.drawListe.append(point2)
             point1 = point2
 

Python/paquets_avion.py

@@ -243,6 +243,10 @@ def __init__(self, gameMap, Id, indicatif, aircraft, perfos, route, arrival, heu
 
         self.speedPx = self.speedGS / gameMap['mapScale'] * heureEnRefresh
 
+        self.directionVent = 0
+        self.forceVent = 0
+        self.findWind(gameMap['vent'])
+
     def findNextPoint(self, carte):
 
         self.nextPoint = findClosestSegment(self.route['points'], (self.x, self.y), carte['points'])[1]
@@ -350,8 +354,34 @@ def changeEvolution(self) -> None:
             else:
                 self.evolution = self.perfos['initialClimbROC']
 
+    def findWind(self, listeVent):
+
+        liste_lvl = list(listeVent.keys())
+        liste_lvl.sort()
+        lowLvL = liste_lvl[0]
+        hiLvL = liste_lvl[-1]
+        for lvl in liste_lvl:
+            if lowLvL <= lvl < self.altitude/100:
+                lowLvL = lvl
+            elif self.altitude/100 < lvl <= hiLvL:
+                hiLvL = lvl
+
+        if self.altitude >= hiLvL:
+            self.directionVent = listeVent[hiLvL][0]
+            self.forceVent = listeVent[hiLvL][1]
+
+        elif self.altitude <= lowLvL:
+            self.directionVent = listeVent[lowLvL][0]
+            self.forceVent = listeVent[lowLvL][1]
+
+        else:
+            self.directionVent = listeVent[lowLvL][0] + listeVent[hiLvL][0] * (hiLvL - self.altitude/100) / (hiLvL - lowLvL)
+            self.forceVent = listeVent[lowLvL][1] + listeVent[hiLvL][1] * (hiLvL - self.altitude/100) / (hiLvL - lowLvL)
+
     def move(self, gameMap):
 
+        self.findWind(gameMap['vent'])
+
         # frequence update
         if self.etatFrequence == 'inFreq':
 
@@ -438,7 +468,7 @@ def computeSpeed(self):
             self.speedIAS = vitesses.TAS_to_IAS(self.speedTAS, self.altitude)
 
         self.speedTAS = vitesses.mach_to_TAS(self.mach, self.altitude)
-        self.speedGS = self.speedTAS
+        self.speedGS = self.speedTAS + self.forceVent * math.cos((self.heading - self.directionVent + 180) * math.pi / 180)
 
     def changeSpeed(self) -> None:
         """

Python/player.py

@@ -282,7 +282,9 @@ def etiquette_update(self):
         if (self.startPressTime != 0 and self.startPressTime + dragDelay <= pygame.time.get_ticks()
                 and pygame.mouse.get_pressed()[0]):
             self.etiquetteDrag()
-            self.drag = True
+            if not self.drag:
+                self.etiquetteExtended = True
+                self.drag = True
         elif not pygame.mouse.get_pressed()[0]:  # si le bouton n'est plus pressé entre temps alors on drag pas
             self.startPressTime = 0
 
@@ -341,11 +343,11 @@ def drawDirect(self, points, point, win, zoom: float, scroll: list[float, float]
         coord = [points[point][0] * zoom + scroll[0], points[point][1] * zoom + scroll[1]]
         pygame.draw.line(win, (0, 206, 209), (self.affX + plotSize, self.affY + plotSize), coord)
 
-    def drawEstimatedRoute(self, points, temps, color, win, zoom, scroll):
+    def drawEstimatedRoute(self, carte, temps, color, win, zoom, scroll):
         """
         Dessine la route future de l'avion jusuq'à un certain point défini par une valeur de temps
         C'est une bonne approximation de la future position de l'avion, à vitesse constante
-        :param points: la liste des points récupérer les coords
+        :param carte: la carte du jeu
         :param temps: combien de temps doit faire la route dessinée en sec
         :param color: La couleur du tracé
         :param win: l'écran pygame
@@ -354,6 +356,8 @@ def drawEstimatedRoute(self, points, temps, color, win, zoom, scroll):
         :return:
         """
 
+        points = carte['points']
+
         if not self.conflitSelected:
             return None
 
@@ -363,16 +367,19 @@ def drawEstimatedRoute(self, points, temps, color, win, zoom, scroll):
 
         route = route[route.index(nextPoint):]  # on ne considère que la route devant l'avion
         pointUn = [self.papa.x, self.papa.y]  # on commence à dessiner à partir de l'avion
-        distance = temps * self.papa.speedPx / radarRefresh  # on établit la distance de la route avec notre vitesse
 
         for point in route:
             pointDeux = [points[point['name']][0], points[point['name']][1]]
 
             # on calcule la distance de la branche
             legDistance = geometry.calculateDistance(pointUn[0], pointUn[1], pointDeux[0], pointDeux[1])
+            legHeading = geometry.calculateHeading(pointUn[0], pointUn[1], pointDeux[0], pointDeux[1])
+            legSpeed = self.papa.speedTAS + self.papa.forceVent * math.cos((legHeading - self.papa.directionVent + 180) * math.pi / 180)
+            legSpeed = legSpeed * carte['mapScale'] / 60
+            legTemps = legDistance / legSpeed
 
-            if legDistance > distance:  # si le trajet restant est plus petit que la prochaine branche
-                ratio = distance/legDistance  # on regarde le pourcentage de recouvrement
+            if legTemps > temps:  # si le trajet restant est plus petit que la prochaine branche
+                ratio = temps/legTemps  # on regarde le pourcentage de recouvrement
 
                 # on détermine le point final du dessin avec ce ratio
                 pointDeux = [pointUn[0] + (pointDeux[0] - pointUn[0]) * ratio,
@@ -392,7 +399,7 @@ def drawEstimatedRoute(self, points, temps, color, win, zoom, scroll):
                                  (pointUn[0] * zoom + scroll[0], pointUn[1] * zoom + scroll[1]),
                                  (pointDeux[0] * zoom + scroll[0], pointDeux[1] * zoom + scroll[1]), 2)
 
-            distance -= legDistance  # on enlève la distance de la branche parcourue à la distance à parcourir
+            temps -= legTemps  # on enlève le temps de la branche parcourue à la distance à parcourir
             pointUn = pointDeux  # on passe au prochain point
 
     def drawRoute(self, points: dict, win, zoom: float, scroll: tuple[float, float] | list[float, float], temps: float):
@@ -579,7 +586,7 @@ def checkEtiquetteOnHover(self) -> bool:
     def checkStillHovered(self) -> bool:
 
         """
-        Vérifie si on doit ou non désétendre l'étiquette
+        Vérifie si on doit ou non désétendre l'étiquette, si on doit désétendre, renvoie True
         """
 
         mouse = pygame.mouse.get_pos()

Python/server.py

@@ -273,6 +273,10 @@
 
     avionsXML = simuTree.find('avions')
 
+    if simuTree.find("vent") is not None:
+        gameMap.update({"vent": loadXML.loadWindXML(simuTree.find("vent"))})
+        print(gameMap['vent'])
+
     if simuTree.find('zones') is not None:
         for zone in simuTree.find('zones'):
             heureDebut = zone.find('debut').text