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 Controller: def _init_(self): self.visuel = Vue(self) self.modele = MainBoard(self) def CommencerJeu(self): self.visuel.afficherMenu()
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):
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 main():
print(sys.path)
try:
tailleFenetre = int(sys.argv[1])
encodage = sys.argv[2]
chemins = sys.argv[3:]
vue = Vue(tailleFenetre, encodage, chemins)
vue.lancer()
except Exception as e:
print()
print("Veuillez contacter Alexis Duval immédiatement s'il-vous-plaît")
return 0
class Controleur():
def __init__(self):
#c.execute("INSERT INTO Projets (projet, id) VALUES('Sennin', 2)")
#conn.commit()
self.modele=Modele(self)
self.vue=Vue(self,self.modele.largeur,
self.modele.hauteur)
self.menu()
def menu(self):
self.vue.menu()
def __init__(self):
#variables
self.nbrParties = 0 #nombre de parties jouees
self.aPlacer = None #objet a placer sur la map
self.aPlacerVue = None #objet visuel a placer
self.tourSelect = None
self.leJoueur = Joueur()
self.lesTours = [] #liste des tours existantes
self.lesToursVue = [] #liste des representations graphiques des tours
self.lesCreeps = [] #liste des creeps existants
self.lesCreepsVue = [] #liste des affichages de creeps existants
#les ids
self.idCreep = 0 #id a donner a chaque creep, incremente
self.idTour = 0 #meme chose pour les tours
self.nbrCreepsTues = 0
#map
self.nomMap = "" #fichier contenant la map
self.laMap = None #objet Map
self.generateurCreep = None #entite qui controle d'ou les creeps arrivent et a quel rythme
#interface
self.interface = Vue(leController=self)
#scores
self.lesScores = Score(leController=self)
#actions a faire en ouvrant le jeu
self.interface.chargerMenu()
self.interface.root.mainloop() #derniere fonction du constructeur
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 __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):
self.vue = Vue.Vue(self)
self.modele = Modele.AireDeJeu(self)
self.commencerPartie()
self.frame = 0
self.apparitionCaisse = 99
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]])
from tkinter import *
from Vue import *
racine = Tk()
racine.title("T9 PRDV")
programme = Vue(racine)
programme.mainloop()
def __init__(self):
self.actif = 1
self.modele = Modele(self)
self.vue = Vue(self)
self.jouer()
self.vue.root.mainloop()
def __init__(self):
self.actif = 1
self.modele = Modele(self)
self.vue = Vue(self)
self.jouer()
self.vue.root.mainloop()
class Controller:
def __init__(self):
#variables
self.nbrParties = 0 #nombre de parties jouees
self.aPlacer = None #objet a placer sur la map
self.aPlacerVue = None #objet visuel a placer
self.tourSelect = None
self.leJoueur = Joueur()
self.lesTours = [] #liste des tours existantes
self.lesToursVue = [] #liste des representations graphiques des tours
self.lesCreeps = [] #liste des creeps existants
self.lesCreepsVue = [] #liste des affichages de creeps existants
#les ids
self.idCreep = 0 #id a donner a chaque creep, incremente
self.idTour = 0 #meme chose pour les tours
self.nbrCreepsTues = 0
#map
self.nomMap = "" #fichier contenant la map
self.laMap = None #objet Map
self.generateurCreep = None #entite qui controle d'ou les creeps arrivent et a quel rythme
#interface
self.interface = Vue(leController=self)
#scores
self.lesScores = Score(leController=self)
#actions a faire en ouvrant le jeu
self.interface.chargerMenu()
self.interface.root.mainloop() #derniere fonction du constructeur
def chargerMap(self): #init la map
self.laMap = Map(nomMap="Maps/"+self.nomMap)
xGen, yGen = self.laMap.getPosGenerateur()
self.generateurCreep = Generateur(x=xGen, y=yGen, leController=self)
def jeuDebut(self): #actions a faire en debut de jeu
self.leJoueur = Joueur()
self.leJoueur.vivant = True
self.nbrCreepsTues = 0
self.interface.actualiserVieArgent()
def reset(self): #a chaque fois qu'on clique sur "nouvelle partie"
#variables
self.aPlacer = None #objet a placer sur la map
self.aPlacerVue = None #objet visuel a placer
self.tourSelect = None
self.lesTours = [] #liste des tours existantes
self.lesToursVue = [] #liste des representations graphiques des tours
self.lesCreeps = [] #liste des creeps existants
self.lesCreepsVue = [] #liste des affichages de creeps existants
#les ids
self.idCreep = 0 #id a donner a chaque creep, incremente
self.idTour = 0 #meme chose pour les tours
self.nbrCreepsTues = 0
#map
self.nomMap = ""
self.laMap = None
self.generateurCreep = None
self.jeuDebut()
def getMap(self): #retourne l'objet Map pour avoir acces a ses donnees
return self.laMap
def getInfoJoueur(self): #retourne l'objet Joueur pour avoir acces a ses donnees
return self.leJoueur
def getInfoTour(self, id): #retourne la tour associee a cet id
for i in self.lesTours:
if i.idTour == id:
return i
def getInfoTourVue(self, id): #retourne la vue de la tour associee a cet id
for i in self.lesToursVue:
if i.idTour == id:
return i
def getInfoRange(self, id): #retourne la tour associee a cet id
for i in self.lesRangesVue:
if i.idTour == id:
return i
def getInfoCreep(self, id): #retourne le creep associe a cet id
for i in self.lesCreeps:
if i.idCreep == id:
return i
def getInfoCreepVue(self, id): #retourne le creep associe a cet id
for i in self.lesCreepsVue:
if i.idCreep == id:#
#print i.idCreep
return i
def boucleJeu(self):
if self.leJoueur.vivant == True:
for i in self.lesCreeps:
#print i.idCreep #debug
self.getInfoCreepVue(i.idCreep).affichage()
i.deplacement()
for i in self.lesToursVue:
i.leRange.detection() #on cherche des cibles
self.interface.root.after(200, self.boucleJeu) #"boucle"
else: #si le joueur est mort
self.generateurCreep.jouer=False #arretter de generer des creeps pour une periode indefinie
self.interface.dechargerJeu()
self.leJoueur.points = self.nbrCreepsTues*2 + self.leJoueur.argent #on calcule le score
self.interface.unPopup = PopupEntreNom(leController=self) #on veut enregistrer le score
def creerCreep(self): #ajouter un nouveau creep a la liste des creeps, lui associer une vue et un id
self.lesCreeps.append(Creep(x=self.generateurCreep.x, y=self.generateurCreep.y, idCreep=self.idCreep, leController=self, pv=100+100*self.generateurCreep.nbrVagues/2))
self.lesCreepsVue.append(VueCreep(leCanvas=self.interface.zoneJeu, leController=self, idCreep=self.idCreep))
self.idCreep = self.idCreep + 1 #incremente l'id du prochain creep
def detruireCreep(self, id, auChateau=True):
if auChateau == False: #un creep a ete tue, on donne des points
self.nbrCreepsTues = self.nbrCreepsTues +1
self.leJoueur.argent = self.leJoueur.argent + 10
self.interface.actualiserVieArgent()
for i in self.lesCreeps: #enlever le creep de la liste
if i.idCreep == id:
self.lesCreeps.remove(i)
#print "creep removed"
for j in self.lesCreepsVue: #enlever la vue associee a ce creep
if j.idCreep == id:
j.cacher()
self.lesCreepsVue.remove(j)
#print "creepVue removed"
def choisirLevelTour(self, type): #on a clique sur un bouton de tour
if self.aPlacer == None: #aucune tour selectionnee, on choisis ce qu'on veut
self.interface.unPopup = PopupChoixTour(leCanvas=self.interface.zoneJeu, x=350, y=100, leController=self, typeTour=type) #popup pour choisir le level de la tour et le prix
else:
self.annulerTour() #on a deja selectionne une tour, on la deselectionne
def creerTour(self, type=None, level=1):
#creer un objet tour, tourVue..., les associer, retourner l'objet vue a afficher
self.aPlacer = type(lvl=level, idTour=self.idTour, leController=self)
rangeTemp = VueRange(leCanvas=self.interface.zoneJeu, leController=self, idTour=self.idTour)
self.aPlacerVue = VueTour(leCanvas=self.interface.zoneJeu, leController=self, idTour=self.idTour, leRange=rangeTemp)
#ajouter aux listes
self.lesTours.append(self.aPlacer)
self.lesToursVue.append(self.aPlacerVue)
self.idTour = self.idTour + 1
def listeTypesTours(self): #retourne tous les types de tours existants pour avoir assez de boutons et les associer aux bonnes cmd
return (TourStandard,)
def appliquerTour(self):#, skip=False):
if self.empVal == True:
self.laMap.changerEmplacement(self.aPlacer.x, self.aPlacer.y)
self.aPlacerVue.leRange.cacher() #on cache le range car on construit la tour
self.leJoueur.enleverArgent(self.aPlacer.cout*self.aPlacer.lvl)#enlever de l'argent au joueur
self.interface.actualiserVieArgent()
self.aPlacer = None #on efface les objets temporaires
self.aPlacerVue = None
self.interface.zoneJeu.config(cursor="") #on reset le curseur
def annulerTour(self):
#on cache la tour et son range
self.aPlacerVue.cacher()
self.aPlacerVue.leRange.cacher() #on cache le range car on construit la tour
self.aPlacer = None #on efface les objets temporaires
self.aPlacerVue = None
self.interface.zoneJeu.config(cursor="") #on reset le curseur
#enlever les objets temporaires de la liste
self.lesTours = self.lesTours[:-1]
self.lesToursVue = self.lesToursVue[:-1]
#on recule d'un id
self.idTour = self.idTour - 1
def deplacerObjets(self, event): #deplacer les objets temporaire (quand la tour flotte sous la souris pour la construire)
self.interface.zoneJeu.config(cursor="cross")
self.aPlacer.x = event.x
self.aPlacer.y = event.y
self.aPlacerVue.leRange.cacher() #pour bouger/actualiser
self.aPlacerVue.leRange.affichage()
self.aPlacerVue.cacher()
self.empVal = self.laMap.emplacementValide(event.x, event.y) #est-ce un emplacement valide sur la map?
self.aPlacerVue.affichage(valide=self.empVal)
def selectionTour(self,event):
lesObjets = self.interface.zoneJeu.find_overlapping(event.x-10, event.y-10, event.x+10, event.y+10) #liste des objets sous la souris
found = False #est-ce qu'on a clique sur une tour?
for i in lesObjets:
lesTags = self.interface.zoneJeu.gettags(i)
if len(lesTags) > 0: #protection contre objet none
if lesTags[0] == "Tour": #on regarde si l'objet en cours est une tour
if self.tourSelect != None: #on doit deselectionner la tour actuelle ou popper le menu d'upgrade si c'est la meme tour
if int(lesTags[1]) == self.tourSelect.idTour: #si tour deja selectionnee, on ouvre le menu d'upgrade
self.interface.unPopup = PopupUpgradeTour(leCanvas=self.interface.zoneJeu, x=350, y=100, leController=self, idTour = self.tourSelect.idTour) #popper fenetre
else: #si une autre tour, on deselectionne
self.getInfoTourVue(self.tourSelect.idTour).leRange.cacher() #cacher range de l'ancienne tour
self.tourSelect = self.getInfoTour(int(lesTags[1])) #afficher autre tour
self.getInfoTourVue(self.tourSelect.idTour).leRange.affichage()
self.getInfoTourVue(self.tourSelect.idTour).affichage(True) #pour pas etre cache par le range
else: #si aucune tour selectionnee auparavant, on en selectionne une
self.tourSelect = self.getInfoTour(int(lesTags[1])) #la tour cliquee devient la tour selectionnee
self.getInfoTourVue(self.tourSelect.idTour).leRange.affichage()
self.getInfoTourVue(self.tourSelect.idTour).affichage(True) #pour pas etre cache par le range
found = True #on a clique sur une tour
elif lesTags[0] == "Creep": #on choisi une cible
if self.tourSelect != None:
self.tourSelect.cible = self.getInfoCreep(int(lesTags[1])) #donner la priorite a ce creep
#print self.tourSelect.cible.idCreep #debug
found = True
if found == False: #pas clique sur une tour ou creep = deselectionner tour
if self.tourSelect != None:
self.getInfoTourVue(self.tourSelect.idTour).leRange.cacher()
self.tourSelect = None
self.interface.zoneJeu.config(cursor="")
else: #si on a selectionne quelque chose
self.interface.zoneJeu.config(cursor="cross")
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.visuel = Vue(self) self.modele = MainBoard(self)
