def initierpartie(self,rep): # initalisation locale de la simulation, creation du modele, generation des assets et suppression du layout de lobby if rep[1][0][0]=="lancerpartie": self.modele=Modele(self,rep[1][0][1],rep[1][0][2]) # on cree le modele self.vue.afficherinitpartie(self.modele) self.vue.nomjoueur=self.modele.joueurscles self.vue.updatelistejoueur() self.prochaintour()
def initierpartie( self, rep ): # initalisation locale de la simulation, creation du modele, generation des assets et suppression du layout de lobby if rep[1][0][0] == "lancerpartie": self.modele = Modele(self, rep[1][0][1]) # on cree le modele self.vue.creeraffichercadrepartie(self.modele) print(self.monnom, "LANCE PROCHAINTOUR") self.prochaintour()
def initierpartie( self, rep ): # initalisation locale de la simulation, creation du modele, generation des assets et suppression du layout de lobby global modeauto if rep[1][0][0] == "lancerpartie": #print("REP",rep) self.modele = Modele(self, rep[1][0][1], rep[1][0][2]) # on cree le modele modeauto = int(rep[1][0][3]) self.vue.afficherinitpartie(self.modele) #print(self.monnom,"LANCE PROCHAINTOUR") self.prochaintour()
def setUp(self): self.marque = Marque('1', 'renault') self.marque2 = Marque('2', 'toyota') self.modele = Modele('1', 'Languna', self.marque, 'test', 'test2') self.modele2 = Modele('2', 'prius', self.marque2, 'test', 'test3') self.tva = TVA('1', '15', '15/06/2014') self.tva2 = TVA('2', '05', '15/04/2014') self.voitureATester = Voiture('SRVSR54801RG1', '15000', '30000', '50000', self.modele, self.tva)
def SetUp(self): self.listOption = ['25', '1', '3'] self.listOption2 = ['5', '11', '13'] self.marque = Marque('1', 'renault') self.marque2 = Marque('2', 'toyota') self.modele = Modele('1', 'Languna', self.marque) self.modele2 = Modele('2', 'prius', self.marque2) self.cpVille = CP_Ville('33', 'Bordeaux') self.cpVille2 = CP_Ville('75', 'Paris') self.tva = TVA('1', '15', '15/06/2014') self.tva2 = TVA('2', '05', '15/04/2014') self.facture = Facture('1', '20/04/2014', '20/03/2015', self.commande, self.tva) self.facture2 = Facture('2', '21/10/2014', '30/07/2014', self.commande2, self.tva2) self.voiture = Voiture('SRVSR54801RG', '1500', '3000', '5000', self.modele, self.fournisseur, self.commande) self.voiture2 = Voiture('SRVSR54801RG1', '15000', '30000', '50000', self.modele2, self.fournisseur2, self.commande2) self.peinture = Peinture('41', 'peinturama', '120') self.peinture2 = Peinture('1', 'belpeinture', '165') self.commande2 = Commande_Client('2', '15/06/18', self.voiture, self.client2, self.facture2, self.peinture2, self.listOption2) self.client1 = Client.Client('1', 'Yohan', 'Cabaye', '32 rue epsi', '0000', '*****@*****.**', self.cpVille) self.client2 = Client.Client('', 'Paul', 'Pogba', '36 rue epsi', '0011', '*****@*****.**', self.cpVille2) self.fournisseur = Fournisseur('1', 'Aquifourni', '0605054821', 'Andre', self.cpVille) self.fournisseur2 = Fournisseur('2', 'Livrapid', '0621589636', 'Gerald', self.cpVille2) self.commandeATester = Commande_Client('1', '02/06/18', self.voiture, self.client1, self.facture, self.peinture, self.listOption)
def __init__(self): super(Controleur, self).__init__() self.compteurDeLoop = 0 self.isRunning = 0 self.modele = None self.vue = fichierVue.Vue(self) self.modele = fichierModele.Modele() self.vue.menu() self.vue.root.mainloop()
def __init__(self, largeur, hauteur, modele): # X,Y,Liste_Coeff self.X = largeur self.Y = hauteur self.MAXVALUE = 256 self.tab = Tableau(self.X, self.Y) self.modele = Modele("patron.xml") self.seed = [(key, Seed(self.X, self.Y, elt["seed"])) for key, elt in self.modele.racine["couche"].items()] for x, y in self.tab.iterC(): self.tab[x, y] = Case(x, y) for key, s in self.seed: self.tab[x, y].biome.set(key, s.tab[x, y].value)
def __init__(self, position, vitesse): assert position >= 0 assert vitesse >= 0 self.donnees = [ ] # Tableau contenant les données enregistrées lors de la simulation # = [temps_total, [self.position,self.vitesse,G], indice] self.position = position # position en mètre self.vitesse = vitesse # vitesse en m/s self.indice_section = 0 self.masse = 1300 # masse en kg self.longueur = 4 # longueur en mètre self.F_max = 10000 # Force d'accélération maximum en newton self.F_min = 10000 # Force de freinage maximum en newton self.valide = True # Booléen pour savoir si la voiture doit être prise en compte dans la simulation self.coefficient_vitesse = uniform( 0.95, 1.05) #Pourcentage de la vitesse limité adopté. self.temps_reaction = 2 # Temps de réaction du conducteur en secondes # Création du modèle pour la gestion de l'accélération self.modele = Modele(2)
class Controleur(): def __init__(self): self.actif = 1 self.modele = Modele(self) self.vue = Vue(self) self.jouer() self.vue.root.mainloop() def bougerCarre(self, x, y): self.modele.bougerCarre(x, y) def jouer(self): if self.actif: self.modele.miseajour() self.vue.miseajour(self.modele) self.vue.root.after(50, self.jouer) def demarrer(self): self.vue.menuPrincipal() def highScores(self): self.modele.highScores() def quitter(self): self.vue.root.destroy()
class Controleur: def __init__(self): self.actif = 1 self.modele = Modele(self) self.vue = Vue(self) self.jouer() self.vue.root.mainloop() def bougerCarre(self, x, y): self.modele.bougerCarre(x, y) def jouer(self): if self.actif: self.modele.miseajour() self.vue.miseajour(self.modele) self.vue.root.after(50, self.jouer) def demarrer(self): self.vue.menuPrincipal() def highScores(self): self.modele.highScores() def quitter(self): self.vue.root.destroy()
def __init__(self, position, vitesse): assert position >= 0 assert vitesse >= 0 self.donnees = [] # Tableau contenant les données enregistrées lors de la simulation # = [temps_total, [self.position,self.vitesse,G], indice] self.position = position # position en mètre self.vitesse = vitesse # vitesse en m/s self.indice_section=0 self.masse = 1300 # masse en kg self.longueur = 4 # longueur en mètre self.F_max = 10000 # Force d'accélération maximum en newton self.F_min = 10000 # Force de freinage maximum en newton self.valide = True # Booléen pour savoir si la voiture doit être prise en compte dans la simulation self.coefficient_vitesse = uniform(0.95, 1.05) #Pourcentage de la vitesse limité adopté. self.temps_reaction = 2 # Temps de réaction du conducteur en secondes # Création du modèle pour la gestion de l'accélération self.modele = Modele(2)
class Voiture(object): def __init__(self, position, vitesse): assert position >= 0 assert vitesse >= 0 self.donnees = [ ] # Tableau contenant les données enregistrées lors de la simulation # = [temps_total, [self.position,self.vitesse,G], indice] self.position = position # position en mètre self.vitesse = vitesse # vitesse en m/s self.indice_section = 0 self.masse = 1300 # masse en kg self.longueur = 4 # longueur en mètre self.F_max = 10000 # Force d'accélération maximum en newton self.F_min = 10000 # Force de freinage maximum en newton self.valide = True # Booléen pour savoir si la voiture doit être prise en compte dans la simulation self.coefficient_vitesse = uniform( 0.95, 1.05) #Pourcentage de la vitesse limité adopté. self.temps_reaction = 2 # Temps de réaction du conducteur en secondes # Création du modèle pour la gestion de l'accélération self.modele = Modele(2) def update(self, temps_total, delta, indice, voiture_devant, longueur, temps_securite, vitesse_limite, boucle=True): vitesse_limite *= self.coefficient_vitesse if self.position >= longueur: if boucle: # Si on boucle on soustrait la longueur de la route à la position de la voiture self.position -= longueur else: # Sinon on retire la voiture de la simulation self.valide = False # Influence de la voiture de devant if voiture_devant is not None: """ Intégration du temps de réaction """ indice_decalage = indice - round(self.temps_reaction / delta) v = voiture_devant.obtenir_vitesse(indice_decalage) p = voiture_devant.obtenir_position(indice_decalage) if v is None: v = voiture_devant.vitesse if p is None: p = voiture_devant.position distance_securite = temps_securite * (2 * self.vitesse - v) delta_v = v - self.vitesse # Vitesse relative # Distance relative if self.position <= p: delta_x = p - self.position else: delta_x = longueur - abs(p - self.position) else: delta_x = 1000000 delta_v = -1000000 self.modele.temps_securite = temps_securite # Mise à jour du temps de sécurité # Calcul de la force appliquée par le conducteur F = self.modele.calcul_force(self.vitesse, delta_x, vitesse_limite) # On limite la force appliquée par le conducteur F = min(F, self.F_max) F = max(F, -self.F_min) # Calcul de l'accélération via le PFD a = F / self.masse # Intégration d'Euler self.vitesse += a * delta if self.vitesse < 0: # Impossible de reculer self.vitesse = 0 self.position += self.vitesse * delta # Enregistrement des données self.donnees.append( [temps_total, [self.position, self.vitesse, F], indice]) def tours_max(self): tours = 0 for i in range(len(self.donnees)): pass def obtenir_positions(self, temps=True): if temps: t = [] r = [] for d in self.donnees: t.append(d[0]) r.append(d[1][0]) return t, r else: i = [] r = [] for d in self.donnees: i.append(d[2]) r.append(d[1][0]) return i, r def obtenir_vitesse(self, i): for d in self.donnees: if d[2] == i: return d[1][1] return None def obtenir_position(self, i): for d in self.donnees: if d[2] == i: return d[1][0] return None def obtenir_vitesses(self): t = [] r = [] for d in self.donnees: t.append(d[0]) r.append(d[1][1]) return t, r def obtenir_forces(self): t = [] r = [] for d in self.donnees: t.append(d[0]) r.append(d[1][2]) return t, r
class Voiture(object): def __init__(self, position, vitesse): assert position >= 0 assert vitesse >= 0 self.donnees = [] # Tableau contenant les données enregistrées lors de la simulation # = [temps_total, [self.position,self.vitesse,G], indice] self.position = position # position en mètre self.vitesse = vitesse # vitesse en m/s self.indice_section=0 self.masse = 1300 # masse en kg self.longueur = 4 # longueur en mètre self.F_max = 10000 # Force d'accélération maximum en newton self.F_min = 10000 # Force de freinage maximum en newton self.valide = True # Booléen pour savoir si la voiture doit être prise en compte dans la simulation self.coefficient_vitesse = uniform(0.95, 1.05) #Pourcentage de la vitesse limité adopté. self.temps_reaction = 2 # Temps de réaction du conducteur en secondes # Création du modèle pour la gestion de l'accélération self.modele = Modele(2) def update(self, temps_total, delta, indice, voiture_devant, longueur, temps_securite, vitesse_limite, boucle=True): vitesse_limite *= self.coefficient_vitesse if self.position >= longueur: if boucle: # Si on boucle on soustrait la longueur de la route à la position de la voiture self.position -= longueur else: # Sinon on retire la voiture de la simulation self.valide = False # Influence de la voiture de devant if voiture_devant is not None: """ Intégration du temps de réaction """ indice_decalage = indice - round(self.temps_reaction / delta) v = voiture_devant.obtenir_vitesse(indice_decalage) p = voiture_devant.obtenir_position(indice_decalage) if v is None: v = voiture_devant.vitesse if p is None: p = voiture_devant.position distance_securite = temps_securite * (2*self.vitesse - v) delta_v = v - self.vitesse # Vitesse relative # Distance relative if self.position <= p: delta_x = p - self.position else: delta_x = longueur - abs(p - self.position) else: delta_x = 1000000 delta_v = -1000000 self.modele.temps_securite = temps_securite # Mise à jour du temps de sécurité # Calcul de la force appliquée par le conducteur F = self.modele.calcul_force(self.vitesse, delta_x, vitesse_limite) # On limite la force appliquée par le conducteur F = min(F, self.F_max) F = max(F, -self.F_min) # Calcul de l'accélération via le PFD a = F / self.masse # Intégration d'Euler self.vitesse += a * delta if self.vitesse < 0: # Impossible de reculer self.vitesse = 0 self.position += self.vitesse * delta # Enregistrement des données self.donnees.append([ temps_total, [ self.position, self.vitesse, F ], indice ]) def tours_max(self): tours=0 for i in range(len(self.donnees)): pass def obtenir_positions(self, temps=True): if temps: t = [] r = [] for d in self.donnees: t.append(d[0]) r.append(d[1][0]) return t, r else: i = [] r = [] for d in self.donnees: i.append(d[2]) r.append(d[1][0]) return i, r def obtenir_vitesse(self, i): for d in self.donnees: if d[2] == i: return d[1][1] return None def obtenir_position(self, i): for d in self.donnees: if d[2] == i: return d[1][0] return None def obtenir_vitesses(self): t = [] r = [] for d in self.donnees: t.append(d[0]) r.append(d[1][1]) return t, r def obtenir_forces(self): t = [] r = [] for d in self.donnees: t.append(d[0]) r.append(d[1][2]) return t, r
class Controleur(): def __init__(self): print("IN CONTROLEUR") self.attente = 0 self.cadre = 0 # le no de cadre pour assurer la syncronisation avec les autres participants self.egoserveur = 0 self.actions = [ ] # la liste de mes actions a envoyer au serveur pour qu'il les redistribue a tous les participants self.monip = self.trouverIP() # la fonction pour retourner mon ip self.monnom = self.generernom( ) # un generateur de nom pour faciliter le deboggage (comme il genere un nom quasi aleatoire et on peut demarrer plusieurs 'participants' sur une meme machine pour tester) self.modele = None self.serveur = None self.vue = Vue(self, self.monip, self.monnom) self.vue.root.mainloop() def trouverIP(self): # fonction pour trouver le IP en 'pignant' gmail s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # on cree un socket s.connect(("gmail.com", 80)) # on envoie le ping monip = s.getsockname()[ 0] # on analyse la reponse qui contient l'IP en position 0 s.close() # ferme le socket return monip def generernom( self ): # generateur de nouveau nom - accelere l'entree de nom pour les tests - parfois a peut generer le meme nom mais c'est rare monnom = "jmd_" + str(random.randrange(1000)) return monnom def creerpartie(self): if self.egoserveur == 0: pid = Popen(["C:\\Python34\\Python.exe", "./Serveur.py"], shell=1).pid # on lance l'application serveur self.egoserveur = 1 # on note que c'est soi qui, ayant demarre le serveur, aura le privilege de lancer la simulation ## ----------- FONCTION POUR CELUI QUI A CREE LA PARTIE SEULEMENT def lancerpartie( self, diametre, densitestellaire, mode ): # reponse du bouton de lancement de simulation (pour celui qui a parti le serveur seulement) rep = self.serveur.lancerpartie(diametre, densitestellaire, mode) ## ----------- FIN -- def inscrirejoueur(self): ipserveur = self.vue.ipsplash.get( ) # lire le IP dans le champ du layout nom = self.vue.nomsplash.get() # noter notre nom if ipserveur and nom: ad = "PYRO:controleurServeur@" + ipserveur + ":9999" # construire la chaine de connection self.serveur = Pyro4.core.Proxy(ad) # se connecter au serveur self.monnom = nom rep = self.serveur.inscrireclient( self.monnom) # on averti le serveur de nous inscrire #tester retour pour erreur de nom random.seed(rep[2]) def boucleattente(self): rep = self.serveur.faireaction([self.monnom, 0, 0]) if rep[0]: print("Recu ORDRE de DEMARRER") self.initierpartie(rep[2]) elif rep[0] == 0: self.vue.affichelisteparticipants(rep[2]) self.vue.root.after(50, self.boucleattente) def initierpartie( self, rep ): # initalisation locale de la simulation, creation du modele, generation des assets et suppression du layout de lobby global modeauto if rep[1][0][0] == "lancerpartie": #print("REP",rep) self.modele = Modele(self, rep[1][0][1], rep[1][0][2]) # on cree le modele modeauto = int(rep[1][0][3]) self.vue.afficherinitpartie(self.modele) #print(self.monnom,"LANCE PROCHAINTOUR") self.prochaintour() def prochaintour( self ): # la boucle de jeu principale, qui sera appelle par la fonction bouclejeu du timer if self.serveur: # s'il existe un serveur self.cadre = self.cadre + 1 # increment du compteur de cadre if self.actions: # si on a des actions a partager rep = self.serveur.faireaction( [self.monnom, self.cadre, self.actions]) # on les envoie else: rep = self.serveur.faireaction([ self.monnom, self.cadre, 0 ]) # sinon on envoie rien au serveur on ne fait que le pigner # (HTTP requiert une requete du client pour envoyer une reponse) self.actions = [ ] # on s'assure que les actions a envoyer sont maintenant supprimer (on ne veut pas les envoyer 2 fois) if rep[1] == "attend": self.cadre = self.cadre - 1 # increment du compteur de cadre print("J'attends") else: self.modele.prochaineaction( self.cadre) # mise a jour du modele self.vue.modecourant.afficherpartie( self.modele) # mise a jour de la vue if rep[0]: # si le premier element de reponse n'est pas vide for i in rep[ 2]: # pour chaque action a faire (rep[2] est dictionnaire d'actions en provenance des participants # dont les cles sont les cadres durant lesquels ses actions devront etre effectuees if i not in self.modele.actionsafaire.keys( ): # si la cle i n'existe pas self.modele.actionsafaire[i] = [ ] #faire une entree dans le dictonnaire for k in rep[2][ i]: # pour toutes les actions lies a une cle du dictionnaire d'actions recu self.modele.actionsafaire[i].append( k ) # ajouter cet action au dictionnaire sous l'entree dont la cle correspond a i self.vue.root.after(50, self.prochaintour) else: print("Aucun serveur connu") def prochaintour1( self ): # la boucle de jeu principale, qui sera appelle par la fonction bouclejeu du timer if self.serveur: # s'il existe un serveur if self.attente == 0: self.cadre = self.cadre + 1 # increment du compteur de cadre self.modele.prochaineaction( self.cadre) # mise a jour du modele self.vue.afficherpartie(self.modele) # mise a jour de la vue if self.actions: # si on a des actions a partager rep = self.serveur.faireaction( [self.monnom, self.cadre, self.actions]) # on les envoie else: rep = self.serveur.faireaction([ self.monnom, self.cadre, 0 ]) # sinon on envoie rien au serveur on ne fait que le pigner # (HTTP requiert une requete du client pour envoyer une reponse) self.actions = [ ] # on s'assure que les actions a envoyer sont maintenant supprimer (on ne veut pas les envoyer 2 fois) if rep[0]: # si le premier element de reponse n'est pas vide for i in rep[ 2]: # pour chaque action a faire (rep[2] est dictionnaire d'actions en provenance des participants # dont les cles sont les cadres durant lesquels ses actions devront etre effectuees if i not in self.modele.actionsafaire.keys( ): # si la cle i n'existe pas self.modele.actionsafaire[i] = [ ] #faire une entree dans le dictonnaire for k in rep[2][ i]: # pour toutes les actions lies a une cle du dictionnaire d'actions recu self.modele.actionsafaire[i].append( k ) # ajouter cet action au dictionnaire sous l'entree dont la cle correspond a i if rep[1] == "attend": # si jamais rep[0] est vide MAIS que rep[1] == 'attend', on veut alors patienter if self.attente == 0: #self.cadre=self.cadre-1 # donc on revient au cadre initial self.attente = 1 print("ALERTE EN ATTENTE", self.monnom, self.cadre) else: self.attente = 0 #print(self.cadre) self.vue.root.after(50, self.prochaintour) else: print("Aucun serveur connu") def fermefenetre(self): if self.serveur: self.serveur.jequitte(self.monnom) self.vue.root.destroy() # FONCTIONS DE COUP DU JOUEUR A ENVOYER AU SERVEUR def creervaisseau(self, systeme): self.modele.creervaisseau(systeme) #self.actions.append([self.monnom,"creervaisseau",""]) def ciblerdestination(self, idorigine, iddestination): self.actions.append( [self.monnom, "ciblerdestination", [idorigine, iddestination]]) def visitersysteme(self, systeme_id): self.actions.append([self.monnom, "visitersysteme", [systeme_id]]) def atterrirdestination(self, joueur, systeme, planete): self.actions.append( [self.monnom, "atterrirplanete", [self.monnom, systeme, planete]]) def creermine(self, joueur, systeme, planete, x, y): self.actions.append( [self.monnom, "creermine", [self.monnom, systeme, planete, x, y]]) def affichermine(self, joueur, systemeid, planeteid, x, y): self.vue.affichermine(joueur, systemeid, planeteid, x, y) def voirplanete(self, idsysteme, idplanete): pass def changerproprietaire(self, nom, couleur, systeme): self.vue.modes["galaxie"].changerproprietaire(nom, couleur, systeme)
def __init__(self): self.vue = Vue.Vue(self) self.modele = Modele.AireDeJeu(self) self.commencerPartie() self.frame = 0 self.apparitionCaisse = 99
def __init__(self): self.actif = 1 self.modele = Modele(self) self.vue = Vue(self) self.jouer() self.vue.root.mainloop()
class Controleur(): def __init__(self): print("IN CONTROLEUR") self.attente = 0 self.cadre = 0 # le no de cadre pour assurer la syncronisation avec les autres participants self.tempo = 0 # insert a reconnaitre qu'on a lance le serveur et qu'on peut s'inscrire automatiquement sans cliquer sur inscription dans l'interface # ne peut pas etre remplace par egoserveur car si cette variable test a vrai (1), l'inscription est effectuee et tempo remis a 0 pour ne pas reinscrire deux fois... # NOTE le nom de variable est ici epouvantable, j'en conviens - devrait quelquechose comme 'autoInscription' self.egoserveur = 0 # est-ce que je suis celui qui a demarre le serveur, a priori, non (0) self.actions = [ ] # la liste de mes actions a envoyer au serveur pour qu'il les redistribue a tous les participants self.statut = 0 # etat dans le quel je me trouve : 0 -> rien, 1 -> inscrit, 2 -> demarre, 3-> joue self.monip = self.trouverIP() # la fonction pour retourner mon ip self.monnom = self.generernom( ) # un generateur de nom pour faciliter le deboggage (comme il genere un nom quasi aleatoire et on peut demarrer plusieurs 'participants' sur une même machine pour tester) self.modele = None self.serveur = None self.vue = Vue(self, self.monip, self.monnom) self.vue.root.mainloop() def trouverIP(self): # fonction pour trouver le IP en 'pignant' gmail s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # on cree un socket s.connect(("gmail.com", 80)) # on envoie le ping monip = s.getsockname()[ 0] # on analyse la reponse qui contient l'IP en position 0 s.close() # ferme le socket return monip def generernom( self ): # generateur de nouveau nom - accelere l'entree de nom pour les tests - parfois � peut generer le meme nom mais c'est rare monnom = "jmd_" + str(random.randrange(1000)) return monnom def creerpartie(self): if self.egoserveur == 0: pid = Popen( ["C:\\Python 36\\Python.exe", "./2018_orion_mini_serveur.py"], shell=1).pid # on lance l'application serveur self.egoserveur = 1 # on note que c'est soi qui, ayant demarre le serveur, aura le privilege de lancer la simulation self.tempo = 1 # on change d'etat pour s'inscrire automatiquement # (parce que dans ce type de programme on prend pour acquis que celui qui prepare la simulation veut aussi y participer) # NOTE si on demarre le serveur, cette fonction est appellee pour nous (voir timer et variable tempo) # ou par un clique sur le bouton 'Creerunclient' du layout def inscrirejoueur(self): ipserveur = self.vue.ipsplash.get( ) # lire le IP dans le champ du layout nom = self.vue.nomsplash.get() # noter notre nom if ipserveur and nom: ad = "http://" + ipserveur + ":9999" self.serveur = xmlrpc.client.ServerProxy(ad) self.monnom = nom rep = self.serveur.inscrireclient( self.monnom) # on averti le serveur de nous inscrire #tester retour pour erreur de nom self.statut = 1 # statut 1 == attente de lancement de partie random.seed(rep[2]) ## ----------- FONCTION POUR CELUI QUI A CREE LA PARTIE SEULEMENT def lancerpartie( self ): # reponse du bouton de lancement de simulation (pour celui qui a parti le serveur seulement) rep = self.serveur.lancerpartie() print("REP DU LANCER", rep) if rep == 1: self.statut = 3 # il change son statut pour lui permettre d'initer la simulation, les autres sont en 1 (attente) - voir timer.py ## ----------- FIN -- def initierpartie( self, rep ): # initalisation locale de la simulation, creation du modele, generation des assets et suppression du layout de lobby if rep[1][0][0] == "lancerpartie": self.modele = Modele(self, rep[1][0][1]) # on cree le modele self.vue.creeraffichercadrepartie(self.modele) print(self.monnom, "LANCE PROCHAINTOUR") self.prochaintour() def boucleattente(self): print("IN BOUCLEATTENTE") rep = self.serveur.faireaction([self.monnom, 0, 0]) print("RETOUR DU faire action SERVEUR", rep) if rep[0]: print("Recu ORDRE de DEMARRER") # PATCH pour dico in xmlrpc qui requiert des chaines comme cles # On a recu un cle str qu'on retransforme en int (pour compter les cadres de jeu, servant a distribuer les taches) cle = list(rep[2].keys())[0] rep[2] = { int(cle): rep[2][cle] } # on transforme la cle de str à int avant le transfert - voir aussi prochaintour (plus bas) # fin de patch self.initierpartie(rep[2]) elif rep[0] == 0: self.vue.affichelisteparticipants(rep[2]) self.vue.root.after(1000, self.boucleattente) def prochaintour( self ): # la boucle de jeu principale, qui sera appelle par la fonction bouclejeu du timer if self.serveur: # s'il existe un serveur self.cadre = self.cadre + 1 # increment du compteur de cadre if self.attente == 0: self.modele.prochaineaction( self.cadre) # mise a jour du modele self.vue.afficherpartie(self.modele) # mise a jour de la vue if self.actions: # si on a des actions a partager rep = self.serveur.faireaction( [self.monnom, self.cadre, self.actions]) # on les envoie else: rep = self.serveur.faireaction([ self.monnom, self.cadre, 0 ]) # sinon on envoie rien au serveur on ne fait que le pigner # (HTTP requiert une requete du client pour envoyer une reponse) self.actions = [ ] # on s'assure que les actions a`envoyer sont maintenant supprimer (on ne veut pas les envoyer 2 fois) if rep[0]: # si le premier element de reponse n'est pas vide # PATCH de dico in xmlrpc (vs Pyro utilise avant) cle = list(rep[2].keys())[0] #print("AVANT",rep[2]) rep[2] = {int(cle): rep[2][cle]} #print("APRES",rep[2]) # FIN DE PATCH for i in rep[ 2]: # pour chaque action a faire (rep[2] est dictionnaire d'actions en provenance des participants # dont les cles sont les cadres durant lesquels ses actions devront etre effectuees if i not in self.modele.actionsafaire.keys( ): # si la cle i n'existe pas self.modele.actionsafaire[i] = [ ] #faire une entree dans le dictonnaire for k in rep[2][ i]: # pour toutes les actions lies a une cle du dictionnaire d'actions recu self.modele.actionsafaire[i].append( k ) # ajouter cet action au dictionnaire sous l'entree dont la cle correspond a i if rep[1] == "attend": # si jamais rep[0] est vide MAIS que rep[1] == 'attend', on veut alors patienter self.cadre = self.cadre - 1 # donc on revient au cadre initial self.attente = 1 #print("ALERTE EN ATTENTE",self.monnom) else: self.attente = 0 self.vue.root.after(20, self.prochaintour) else: print("Aucun serveur connu") def fermefenetre(self): if self.serveur: self.serveur.jequitte(self.monnom) self.vue.root.destroy() def creervaisseau(self): self.actions.append([self.monnom, "creervaisseau", ""]) def ciblerflotte(self, idorigine, iddestination): self.actions.append( [self.monnom, "ciblerflotte", [idorigine, iddestination]])
class MapGen: def __init__(self, largeur, hauteur, modele): # X,Y,Liste_Coeff self.X = largeur self.Y = hauteur self.MAXVALUE = 256 self.tab = Tableau(self.X, self.Y) self.modele = Modele("patron.xml") self.seed = [(key, Seed(self.X, self.Y, elt["seed"])) for key, elt in self.modele.racine["couche"].items()] for x, y in self.tab.iterC(): self.tab[x, y] = Case(x, y) for key, s in self.seed: self.tab[x, y].biome.set(key, s.tab[x, y].value) def cycle(self, duree): for i in range(duree): self.Division() self.Egalisation() self.Finalisation() def Division(self, mod=2): aux = Tableau(self.tab.X * 2, self.tab.Y * 2) for y in range(self.Y): init = self.tab.ligne(y) offset = 0 if init * 2 > y: offset = 1 for x in range(init, self.X + init): for y2 in range(mod): init2 = self.tab.ligne(y2) for x2 in range(init2, mod + init2): aux[(x) * mod + x2 - offset, y * mod + y2] = Case((x) * mod + x2 - offset, y * mod + y2) aux[(x) * mod + x2 - offset, y * mod + y2].biome.copy(self.tab[x, y].biome) self.tab = aux self.Y *= 2 self.X *= 2 def Egalisation(self): self.aux = Tableau(self.tab.X, self.tab.Y) self.tab.iter(self._egalisation) self.tab = self.aux def _egalisation(self, x, y): biome = self.Moyenne(x, y) self.aux[x, y] = Case(x, y) self.aux[x, y].biome = biome def Moyenne(self, x, y): aux = [] biome = Biome() compteur = 0 for elt in self.modele.hierarchie: biome.set(elt, 0) for elt in self.tab[x, y].Voisins(): if elt in self.tab: for elt1 in self.modele.hierarchie: biome.add(elt1, self.tab[elt].biome.dict[elt1]) aux.append(elt) compteur = compteur + 1 x1, y1 = aux[randrange(len(aux))] for elt in biome.dict.keys(): div = 0 biome.div(elt, compteur) biome.mult(elt, self.modele.argsRand[elt]["moyenne"]) div += self.modele.argsRand[elt]["moyenne"] biome.add(elt, self.tab[x, y].biome.dict[elt] * self.modele.argsRand[elt]["centre"]) div += self.modele.argsRand[elt]["centre"] biome.add(elt, self.tab[x1, y1].biome.dict[elt] * self.modele.argsRand[elt]["rand"]) div += self.modele.argsRand[elt]["rand"] biome.div(elt, div) return biome def Finalisation(self): aux = {} self.niveaux = {} for i in range(self.MAXVALUE): for elt in self.modele.hierarchie: aux[elt, i] = 0 for case in self.tab.values(): for elt in self.modele.hierarchie: aux[elt, case.biome.dict[elt]] += 1 for elt in self.modele.hierarchie: self.niveaux[elt] = [] i = 0 buffer_ = 1 for valeur in self.modele.pourcents[elt]: valeur = float(valeur) while i < self.MAXVALUE and buffer_ * 100 / (self.X * self.Y) <= valeur: buffer_ += aux[elt, i] i += 1 self.niveaux[elt].append(i) for case in self.tab.values(): for elt in self.modele.hierarchie: i = 0 while i < len(self.niveaux[elt]) and case.biome.dict[elt] > self.niveaux[elt][i]: i += 1 case.biome.dict[elt] = i self.modele.determine(case.biome) def getSurface(self): w = sf.RenderTexture(hexagone.l * self.X + hexagone.l // 2, (hexagone.L * 1.5) * (self.Y // 2 + 1)) w.clear() return w def getTexture(self, w): for elt in self.tab.values(): w.draw(elt.sprite()) w.display() return w def save(self, name): w = self.getTexture() image = w.texture.to_image() image.to_file(name)