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]])
def __init__(self):
self.actif = 1
self.modele = Modele(self)
self.vue = Vue(self)
self.jouer()
self.vue.root.mainloop()
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)