def initialiser_menu_heberger(self):
""" Crée les widgets du menu de réglage du serveur (héberger).
Réutilise le niveau de fond déjà crée. """
utile.debogguer("Initialisation du menu heberger")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_heberger(self)
def lancer_echange(self):
""" Lance un fil d'execution (thread) dédié aux échanges. """
if not self.activite_echange:
utile.debogguer("Lancement d'une boucle d'échange (client)")
self.activite_echange = True
self.fil_echange.start()
def initialiser_menu_rejoindre(self):
""" Crée les widgets du menu de réglage du client (rejoindre).
Réutilise le niveau de fond déjà crée. """
utile.debogguer("Initialisation du menu rejoindre")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_rejoindre(self)
def arreter_echange(self):
""" Stoppe la boucle d'échange et le fil d'execution dédié. """
if self.activite_echange:
utile.debogguer("Arrêt d'une boucle d'échange (client)")
self.activite_echange = False
self.fil_echange.join()
def initialiser_partie_serveur(self, port):
""" Crée puis lance un serveur écoutant sur un port donné. Si le
serveur arrive à se lier au port donné, crée un niveau ainsi
que les widgets de partie (comme en mode solo).
<port> (int): Le port d'écoute du serveur. """
self.serveur = Serveur(self, port)
if not self.serveur.accrocher():
self.affichage.afficher_message("Impossible de créer un serveur")
self.arreter_boucle()
else:
utile.debogguer("Initialisation d'une partie (serveur)")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_partie()
self.creer_niveau("serveur")
joueur = self.niveau.creer_joueur()
self.niveau.ajouter_entite(joueur)
self.niveau.joueur_id = joueur.identifiant
self.serveur.lancer_ecoute()
self.serveur.lancer_echange()
self.en_partie = True
def initialiser_menu_multijoueur(self):
""" Crée les widgets du menu multijoueur principal. Réutilise le
niveau de fond déjà crée. """
utile.debogguer("Initialisation du menu multijoueur")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_multijoueur(self)
def finir_partie(self):
""" Affiche le menu de fin de partie. """
utile.debogguer("Fin de la partie")
self.niveau.en_pause = True
self.en_partie = False
self.affichage.creer_widgets_fin(self)
def lancer_ecoute(self):
""" Lance un fil d'execution (thread) dédié aux écoutes (accepte les
connexions entrantes). """
if not self.activite_ecoute:
utile.debogguer("Lancement d'une boucle d'écoute (serveur)")
self.activite_ecoute = True
self.fil_ecoute.start()
def arreter_echange(self):
""" Stoppe la boucle d'échange et le fil d'execution dédié. """
if self.activite_echange:
utile.debogguer("Arrêt d'une boucle d'échange (serveur)")
self.activite_echange = False
self.fil_echange.join()
for adresse in list(self.tampons):
self.deconnecter(adresse)
def arreter_ecoute(self):
""" Stoppe la boucle d'écoute et le fil d'execution dédié. """
if self.activite_ecoute:
utile.debogguer("Arrêt d'une boucle d'écoute (serveur)")
self.activite_ecoute = False
sckt.socket().connect(("localhost", self.port))
self.socket.close()
self.fil_ecoute.join()
def accrocher(self):
""" Lie le serveur à un port. Si le port est inaccessible renvoie
False, sinon True. """
try:
self.socket.bind(("localhost", self.port))
except sckt.error:
utile.debogguer(
"Impossible d'écouter sur le port " + str(self.port), 1)
return False
else:
self.connecte = True
return True
def initialiser_partie(self):
""" Crée un niveau et les widgets de partie. """
utile.debogguer("Initialisation d'une partie")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_partie()
self.creer_niveau()
joueur = self.niveau.creer_joueur()
self.niveau.ajouter_entite(joueur)
self.niveau.joueur_id = joueur.identifiant
self.en_partie = True
def geler_partie(self, pause=True):
""" Met la partie en pause en créant le menu de pause ou continue la
partie en supprimant les widgets de pause.
[pause] (bool): Si True, met le jeu en pause, sinon continue la
partie. (True par défaut). """
self.niveau.en_pause = pause
if pause:
utile.debogguer("Gêle de la partie")
self.affichage.creer_widgets_pause(self)
else:
utile.debogguer("Dégèle de la partie")
self.affichage.supprimer_widgets_pause()
def initialiser_menu_principal(self):
""" Crée un niveau de fond et les widgets du menu principal. """
utile.debogguer("Initialisation du menu principal")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_menu(self)
self.creer_niveau()
joueur = self.niveau.creer_joueur()
joueur.droite()
joueur.vie = float("inf")
self.niveau.ajouter_entite(joueur)
self.niveau.joueur_id = joueur.identifiant
self.en_partie = False
def creer_niveau(self, mode="solo"):
""" Crée et initialise un nouveau niveau ainsi qu'un joueur.
[mode] (str): Le mode de gestion du niveau (solo, client ou
serveur). (solo par défaut). """
utile.debogguer("Création d'un nouveau niveau")
if mode == "solo":
self.niveau = Niveau(self)
elif mode == "client":
self.niveau = NiveauClient(self, self.client)
elif mode == "serveur":
self.niveau = NiveauServeur(self, self.serveur)
self.niveau.initialiser_image()
def ecouter(self):
""" Ecoute en continu sur le port du serveur pour accepter les
connexions entrantes. """
self.socket.listen()
while self.activite_ecoute:
try:
socket, (adresse, port) = self.socket.accept()
except OSError:
utile.debogguer("Impossible d'accepter une nouvelle " \
+ "connexion: socket fermé", 1)
if self.activite_ecoute:
self.connecter(adresse, socket)
def demarrer():
""" Crée une instance de Jeu lance une première boucle de jeu. Si une
erreur se produit, affiche un rapport d'erreur et arrête le jeu
proprement. """
jeu = Jeu()
jeu.charger()
jeu.initialiser_menu_principal()
try:
jeu.lancer_boucle()
except Exception as e:
utile.debogguer(
"Une erreur non gérée est survenue pendant l'exécution", 2)
traceback.print_exc()
finally:
jeu.arreter()
def lancer_boucle(self):
""" Lance une nouvelle boucle de jeu en mettant en pause la boucle
de jeu actuellement active. Une nouvelle boucle est généralement
lancée à la création d'un nouveau menu. """
utile.debogguer("Lancement d'une nouvelle boucle de jeu")
temps_precedent = time.time()
self.en_boucle = True
while self.en_boucle:
temps_ecoule = time.time() - temps_precedent
temps_precedent = time.time()
self.affichage.actualiser_evenements(self)
self.niveau.actualiser(temps_ecoule)
self.affichage.actualiser(self.niveau, self)
self.en_boucle = True
utile.debogguer("Fin d'une boucle de jeu")
def connecter(self, adresse, port):
""" Connecte le client à un serveur à une adresse et sur un port
donné.
<adresse> (str): L'adresse du serveur.
<port> (int): Le port sur lequel se connecter. """
try:
self.socket.settimeout(10)
self.socket.connect((adresse, port))
except sckt.timeout:
utile.debogguer("Temps de connexion à '" + adresse \
+ "' avec le port " + str(port) + " dépassé", 1)
except sckt.error:
utile.debogguer("Impossible de se connecter à '" + adresse \
+ "' avec le port " + str(port), 1)
else:
self.connecte = True
self.socket.settimeout(1)
return True
return False
def initialiser_partie_client(self, adresse, port):
""" Crée un client et lance une tentative de connexion à l'adresse et
le port donnés. Si la tentative réussi, crée un niveauClient et
lance la boucle d'échange du client.
<adresse> (str): L'adresse du serveur à joindre.
<port> (int): Le port d'écoute du serveur. """
self.client = Client(self)
if not self.client.connecter(adresse, port):
self.affichage.afficher_message("Impossible de se connecter")
self.arreter_boucle()
else:
utile.debogguer("Initialisation d'une partie (client)")
self.affichage.supprimer_widgets()
self.affichage.creer_widgets_partie()
self.affichage.afficher_message("Connecté au serveur !")
self.creer_niveau("client")
self.client.lancer_echange()
self.en_partie = True
def charger_images(self):
""" Charge les images du disque dur en mémoire vive. Il est
préférable de n'appeler cette méthode qu'une seule fois
pour éviter de ralentir le jeu. """
utile.debogguer("Chargement des images...")
# Pour chaque image dans constantes.IMAGES
for chemin_image in constantes.Ressources.IMAGES:
chemin_image = os.path.join(constantes.Chemin.IMAGES,
*chemin_image)
try:
self.images[chemin_image] = pygame.image.load(chemin_image)
utile.debogguer("L'image '" + chemin_image \
+ "' a été chargé !")
except pygame.error:
utile.debogguer("L'image '" + chemin_image \
+ "' n'existe pas !", 1)
utile.debogguer("Fin du chargement des images !")
def finir_partie_client(self):
""" Affiche le menu de fin de partie en tant que client. """
utile.debogguer("Fin de partie en tant que client")
self.niveau.enlever_entite(self.niveau.obtenir_joueur_local())
__author__ = "Gabriel Neny; Colin Noiret; Julien Dubois"
__repo__ = "https://github.com/Ptijuju22/metawars.git"
import time
def demarrer():
""" Crée une instance de Jeu lance une première boucle de jeu. Si une
erreur se produit, affiche un rapport d'erreur et arrête le jeu
proprement. """
jeu = Jeu()
jeu.charger()
jeu.initialiser_menu_principal()
try:
jeu.lancer_boucle()
except Exception as e:
utile.debogguer(
"Une erreur non gérée est survenue pendant l'exécution", 2)
traceback.print_exc()
finally:
jeu.arreter()
if __name__ == "__main__":
# le programme démarre ici
utile.debogguer("Démarrage de " + constantes.General.NOM)
demarrer()
