157 lines
4.5 KiB
Markdown
157 lines
4.5 KiB
Markdown
# 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)
|
|
```
|