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()