# mainLoop.py
Le fichier contenant notre boucle de maj principale, appelé par un QTimer défini dans [main.py](#Classe-MainWindow)

## imports
Nos deux classes définies dans [Map.py](#Map.py) et [CarController.py](#CarController.py) chargées de gérer respectivement le reseau (chargement, affichage,...) et les voitures (chargement, calcul de trajet, affichage, deplacements, ...)

```python
from Map import Map
from CarController import CarController
```

Comme d'hab les modules de Qt necessaires

```python
from PySide6.QtWidgets import QFileDialog, QToolBox
from PySide6.QtCore import QElapsedTimer, QTimer, QElapsedTimer, QObject, Signal, Slot
```

## classe mainLoop
Notre classe (On remarquera qu'elle ne suit pas la même convention pour le nom que MainWindow)

```python
class mainLoop():
```

On crée un signal pour la maj de l'affichage des fps.
Il y as une bonne raison pour laquelle il ne se trouve pas dans le `__init__` mais je m'en souvient plus

```python
    updateFPS = Signal(int)
```

### \_\_init\_\_
La fonction d'initialisation

Ici parent fait reference à notre MainWindow.
painter est la surface d'affichage principale, définie dans le fichier [mainPainter.py](mainPainter.py), on s'en sert pour dessiner.

On crée nos objet pour le réseau (Map) et pour les voitures (CarController), pour l'instant ils sont vides, on les remplis après quand l'utilisateur nous donne l'emplacement des fichiers ([openNetwork](#openNetwork) et [openVehicles](openVehicles))

```python
def __init__(self, parent):
       self.parent = parent
       self.painter = parent.ui.mainSurf

       self.map = Map()
       
       self.controller = CarController(self.map)
       
       self.painter.addMap(self.map)
       self.painter.addCarController(self.controller)
```

On crée le timer qui va s'occuper de maj les deplacements (mais ce coup ci on le demarre pas tout de suite, on va attendre que le thread ai demarré ([start](#start)))
On instancie aussi le timer qui va nous servir à mesurer le fps

```python
        self.timer = QTimer()
        self.timer.timeout.connect(self.update)
        self.timer.timeout.connect(self.updateFps)
        self.timer.setInterval(1000/60)

        self.fpsTimer = QElapsedTimer()
        self.updateFPS.connect(self.parent.updatePhysicsFps)
```

### start
Fonction appelée quand le thread est demarré (on l'a connecté dans [main.py](main.py#__init__))

```python
    def start(self):
        self.fpsTimer.start()
```

### update
La fonction dans laquelle on fait les maj, elle est appelée periodiquement par le Timer defini dans precedemment [\_\_init\_\_](#\_\_init\_\_)

On fait la maj des voitures (deplacement + conduite).

```python
    def update(self):
        self.controller.update()
```

##### openNetwork
Fonction appelé quand l'utilisateur click sur le bouton open-\>network file par le code dans [MainWindow](main.md#openNetwork)

```python
    def openNetwork(self):
```

Si le resultat est vide (i.e l'utilisateur à annulé) on abandonne

```python
        if(fileName[0] == ''):
            return
```

Sinon on crée le reseau à partir u chemin récupéré

```python
        self.map.fromPath(fileName[0])
```

On génére la matrice de transformation entre coordonnées du réseau-\>coordonées de l'écran

```python
        self.painter.generateTransform()
```

Maintenant qu'on as le réseau on peut generer les itineraires pour les voitures
(si on as pas encore chargé les voitures cette fonction n'a pas d'effet)

```python
        self.controller.prepareRoute()
```

### openVehicles
Très similaire à la fonction [openNetwork](#openNetwork) mais ce coup ci pour charger les vehicules

```python
    def openVehicles(self):
        if(fileName[0] == ''):
            return
        self.controller.fromPath(fileName[0])
```

Si le reseau est déjà chargé on peut directement calculer les trajet ici

```python
        if(self.map.isLoaded()):
            self.controller.prepareRoute()
```

### quickLoad

Fonction pour charger rapidement les reseaux, j'avais la flemme d'aller chercher dans le menu à chque fois

```python
    def quickLoad(self):
        self.map.fromPath("test2.net.xml")
        self.painter.generateTransform()
        self.controller.fromPath("test5.rou.xml")
        self.controller.prepareRoute()
```

### updateFps

Fonction pour mesurer/maj le fps.
On recupere le temps depuis la dernier maj puis on la passe au Slot dans [main.py](main.md#updatePhysicsFps)

```python
    def updateFps(self):
        newFps = self.fpsTimer.restart()
        self.updateFPS.emit(newFps)
```
