def extraire_modeles_depuis_bdd(self):
""" Créer les modèles à partir des données chargées
---
"""
for c in self.liste_pays:
if self.est_enregistre(c.tag):
self.liste_modeles.append(Modele(c, self))
def __init__(self):
self.modele = Modele(self)
self.vue = Vue(self)
self.modele.init_grid_Pathfinding(self)
self.client = None
self.serveur = None
self.nomBatiment = None
self.infoCreation = None
self.etatCreation = None
self.tempsDebut = None
self.compteur = 0
self.afterID = None
#Section Temporaire
self.verbose = False # //Mettre verbose a True pour plus de print venant du serveur
self.client = Client()
self.initServerLobby()
self.vue.root.mainloop()
self.closeGame()
def __init__(self):
Modele.__init__(self)
self.pi = 0
self.mu1 = np.array(0)
self.mu0 = np.array(0)
return
class Controleur():
def __init__(self):
self.modele = None
self.gui = None
nbCol = 25
nbLignes = 20
nbPlanete = 35
self.initModele(nbCol, nbLignes, nbPlanete)
self.initGui()
def initGui(self):
self.gui = Gui(self.gameLoop)
self.gui.activerValiderDeplacement(False)
self.gui.activerBarreAugmentation(False)
data = {}
data["anneeCourante"] = self.modele.anneeCourante
data["listePlanetes"] = self.modele.planetes
data["nbPlanetesHumain"] = self.modele.getNbPlanetesRace(Races.HUMAIN)
data["nbPlanetesGubru"] = self.modele.getNbPlanetesRace(Races.GUBRU)
data["nbPlanetesCzin"] = self.modele.getNbPlanetesRace(Races.CZIN)
data["selection1"] = None
data["selection2"] = None
data["flottesHumaines"] = None
data["flottes"] = self.modele.flottes
self.gui.rafraichir(data)
def initModele(self, nbCols, nbLignes, nbPlanetes):
self.modele = Modele(nbCols, nbLignes, nbPlanetes)
self.modele.creerPlanetes()
def executer(self):
""" permet de lancer le GUI """
self.gui.run()
def gameLoop(self, userAction, coordinates=None):
""" the coordiantes should be tuples """
if userAction == UserActions.VALIDER_DEPLACEMENT:
self.validationDeplacement()
elif userAction == UserActions.VALIDER_TOUR:
self.finTour()
elif userAction is UserActions.SELECT_PLANETE or userAction is UserActions.SELECT_PLANETE_2:
self.gestionSelectionPlanete(coordinates, userAction)
elif userAction == UserActions.FLOTTE_CHANGEMEMT:
self.gestionChangementFlotte()
# MÉTHODES DE CONTRÔLES PRINCIPALES #
def gestionSelectionPlanete(self, coordonnee, userAction):
""" Méthode gérant le cas de la sélection d'une planète """
planete = self.modele.getPlaneteAt(coordonnee[0], coordonnee[1])
if not planete: # Si on clique dans le vide
if userAction is UserActions.SELECT_PLANETE:
self.modele.planeteSelectionnee = None
self.gui.resetNombreVaisseaux()
self.gui.activerBarreAugmentation(False)
self.gui.activerValiderDeplacement(False)
else:
self.modele.planeteSelectionnee2 = None
else:
self.inspecterPlanete(planete)
if userAction is UserActions.SELECT_PLANETE:
self.gestionSelection1(planete)
else:
self.gestionSelection2(planete)
self.rafraichirFlotte()
self.rafraichirGui()
def gestionSelection1(self, planete):
self.modele.planeteSelectionnee = planete
if self.modele.planeteSelectionnee.civilisation == Races.HUMAIN:
self.gui.nbVaisseauxWidget.configure(to_=planete.nbVaisseaux)
activation = True
else:
activation = False
self.gui.resetNombreVaisseaux()
self.gui.activerBarreAugmentation(activation)
def gestionSelection2(self, planete):
self.modele.planeteSelectionnee2 = planete
if self.modele.planeteSelectionnee:
if self.modele.planeteSelectionnee.civilisation == Races.HUMAIN:
self.gui.nbVaisseauxWidget.configure(to_=self.modele.planeteSelectionnee.nbVaisseaux)
activation = True
else:
activation = False
self.gui.resetNombreVaisseaux()
self.gui.activerBarreAugmentation(activation)
def gestionChangementFlotte(self):
""" Méthode gérant le cas du changement du nombre de vaisseaux d'une flotte """
if self.gui.getNbVaisseaux() <= 0 or not self.modele.planeteSelectionnee2:
activation = False
else:
activation = True
self.gui.activerValiderDeplacement(activation)
def rafraichirFlotte(self):
depart = self.modele.planeteSelectionnee
arrivee = self.modele.planeteSelectionnee2
data = {"planeteDepart": depart, "planeteArrivee": arrivee}
if depart and arrivee:
data["distance"] = self.modele.calculerDistance(depart, arrivee)
else:
data["distance"] = None
self.gui.rafraichirFlotte(data)
def inspecterPlanete(self, planete):
""" Inspecte une la planete selon le niveau de connaissance """
if planete.civilisation == Races.HUMAIN:
self.gui.inspecterPlanete(planete.nom, planete.posX, planete.posY, planete.nbManufactures,
planete.nbVaisseaux)
return
if planete.nbVisites == 0:
self.gui.inspecterPlanete(planete.nom, planete.posX, planete.posY)
if planete.nbVisites == 1:
self.gui.inspecterPlanete(planete.nom, planete.posX, planete.posY, planete.nbManufactures)
if planete.nbVisites == 2:
self.gui.inspecterPlanete(planete.nom, planete.posX, planete.posY, planete.nbManufactures)
if planete.nbVisites >= 3:
self.gui.inspecterPlanete(planete.nom, planete.posX, planete.posY, planete.nbManufactures, planete.nbVaisseaux)
def validationDeplacement(self):
""" Méthode gérant le cas de la validation d'un déplacement """
# Rafraîchissement du GUI
self.rafraichirGui()
planeteDepart = self.modele.planeteSelectionnee
planeteArrive = self.modele.planeteSelectionnee2
nbVaisseaux = self.gui.getNbVaisseaux()
self.modele.ajouterFlotte(planeteDepart, planeteArrive, Races.HUMAIN, nbVaisseaux)
self.gui.resetNombreVaisseaux()
self.gui.activerBarreAugmentation(False)
self.gui.activerValiderDeplacement(False)
self.rafraichirGui()
def finTour(self):
""" Méthode gérant le cas de la fin d'un tour"""
self.modele.avancerTemps()
self.gestionNotifications()
self.rafraichirGui()
def rafraichirGui(self):
data = {}
data["anneeCourante"] = self.modele.anneeCourante
data["listePlanetes"] = self.modele.planetes
data["nbPlanetesHumain"] = self.modele.getNbPlanetesRace(Races.HUMAIN)
data["nbPlanetesGubru"] = self.modele.getNbPlanetesRace(Races.GUBRU)
data["nbPlanetesCzin"] = self.modele.getNbPlanetesRace(Races.CZIN)
data["selection1"] = self.modele.planeteSelectionnee
data["selection2"] = self.modele.planeteSelectionnee2
data["flottes"] = self.modele.flottes
self.gui.rafraichir(data)
def gestionNotifications(self):
""" Permet de gérer les notifications """
notifications = self.modele.notifications
for notif in notifications:
if isinstance(notif, Affrontement):
self.gestionNotifAffrontement(notif)
elif isinstance(notif, Annihilation):
self.gestionNotifAnnihilation(notif)
self.modele.notifications = [] # On vide les notifications
def gestionNotifAnnihilation(self, notif):
""" Gestion notifications d'annihilation """
self.gui.consoleHumains.annihilation(notif.annee, notif.race)
self.gui.consoleEnnemis.annihilation(notif.annee, notif.race)
def gestionNotifAffrontement(self, notif):
""" Gestion notifications d'affrontement """
isHumainConcernes = False
if notif.attaquant is Races.HUMAIN or notif.defenseur is Races.HUMAIN:
isHumainConcernes = True
# il y eu affrontement
if isHumainConcernes:
self.gui.consoleHumains.affrontementPlanete(notif.annee, notif.attaquant, notif.defenseur, notif.planete)
self.gui.consoleEnnemis.affrontementPlanete(notif.annee, notif.attaquant, notif.defenseur, notif.planete)
if notif.isDefenseReussie: # Défense réussie
if isHumainConcernes:
self.gui.consoleHumains.defensePlanete(notif.annee, notif.defenseur, notif.attaquant, notif.planete)
self.gui.consoleEnnemis.defensePlanete(notif.annee, notif.defenseur, notif.attaquant, notif.planete)
else: # Défense ratée, perte planète gain pour autre
if isHumainConcernes:
self.gui.consoleHumains.victoirePlanete(notif.annee, notif.attaquant, notif.planete)
self.gui.consoleHumains.pertePlanete(notif.annee, notif.defenseur, notif.attaquant, notif.planete)
self.gui.consoleEnnemis.pertePlanete(notif.annee, notif.defenseur, notif.attaquant, notif.planete)
self.gui.consoleEnnemis.victoirePlanete(notif.annee, notif.attaquant, notif.planete)
def initModele(self, nbCols, nbLignes, nbPlanetes):
self.modele = Modele(nbCols, nbLignes, nbPlanetes)
self.modele.creerPlanetes()
class Controleur:
def __init__(self):
self.modele = Modele(self)
self.vue = Vue(self)
self.modele.init_grid_Pathfinding(self)
self.client = None
self.serveur = None
self.nomBatiment = None
self.infoCreation = None
self.etatCreation = None
self.tempsDebut = None
self.compteur = 0
self.afterID = None
#Section Temporaire
self.verbose = False # //Mettre verbose a True pour plus de print venant du serveur
self.client = Client()
self.initServerLobby()
self.vue.root.mainloop()
self.closeGame()
#Fonction qui crée le serveur. Un seul est nécéssaire par partie
def creeServeur(self, nameServer, nomPartie, nomJoueur):
print(nameServer, nomPartie, nomJoueur, self.verbose)
self.serveur = Server(nameServer, nomPartie, nomJoueur, test = self.verbose) #Initialisation
self.serveur.daemon = True
self.serveur.start() #Démarrage du serveur
def initServerLobby(self):
self.vue.removeGridDisplay()
self.vue.displayServers([])
self.serverLobby()
#Fait afficher le lobby de choix de serveur
def serverLobby(self):
if(self.client.nameServer):
try:
self.vue.refreshServers(self.client.getServers())#Affichage du lobby
except:
print("oups le nameServer ne répond plus...")
self.client.nameServer = None
else:
self.vue.refreshServers({})
self.client.findNameServerThread()
self.afterID = self.vue.root.after(5000,self.serverLobby)
#Fonction qui permet d'entrer dans un Lobby et affiche le lobby de partie
def joinLobby(self):
selectedServer = self.vue.serverList.get(self.vue.serverList.curselection()[0])#Pour obtenir le serveur selectionne dans la listbox
if(selectedServer):
self.vue.root.after_cancel(self.afterID)
self.client.nom = self.vue.entreClient.get()
print("Connecting "+self.client.nom+" to "+selectedServer)
self.client.connect(selectedServer)#Se connecter au serveur
self.vue.removeGridDisplay()
self.vue.displayLobby(self.serveur)
self.playerLobby()
#Creation d'un nouveau serveur et affiche le lobby de partie
def createLobby(self):
self.vue.root.after_cancel(self.afterID)
self.client.nom = self.vue.entreClient.get()
self.creeServeur(self.client.nameServer, self.vue.entreServeur.get(), self.client.nom)
while not self.serveur.isReady:
time.sleep(0.1)
#possibilité d'affficher un loading ici
self.client.findNameServer()
self.client.connect(self.vue.entreServeur.get())
self.vue.removeGridDisplay()
self.vue.displayLobby(self.serveur)
self.playerLobby()
def playerLobby(self):
self.vue.refreshLobby(self.client.proxy.getStartingInfo())
if(self.client.proxy.isGameStarted()):
self.lancerPartie()
else:
if(self.serveur):
self.client.setCpuClient( int(self.vue.spinBox.get()) ) #Afin que tous les joueurs puisse afficher les joueur IA dans leur lobby
if(not self.client.isNameServerAlive()):
self.server.startNameServer()
self.afterID = self.vue.root.after(300,self.playerLobby)
#Retourne si le client est aussi le host
def isHost(self):
if(self.serveur): return True
return False
def clearLog(self):
se = platform.system()
if(se == 'Windows'):
os.system('cls')
else:
os.system('clear')
#Fonction qui démarre la partie
def lancerPartie(self):
self.vue.root.after_cancel(self.afterID)
if(self.serveur):
self.serveur.removeServerBroadcast()
self.client.proxy.startGame()
self.vue.removeGridDisplay()
self.clearLog()
print("Numero de joueur : " + str(self.client.noJoueur))
self.modele.initPartie(self.client.noJoueur, self.client.getStartingInfo(), self.isHost())
self.client.setCpuClient(self.modele.getAIcount())
self.vue.displayMap(self.modele.map)
self.vue.generateSpriteSet(self.modele.noJoueurLocal)
self.vue.displayObject(self.modele.listeJoueur,[],self.modele.noJoueurLocal,self.modele.selection)
self.vue.displayHUD()
self.vue.displayRessources(self.modele.listeJoueur[self.modele.noJoueurLocal].listeRessource)
self.tempsDebut = time.time()
self.gameLoop()
def packAction2Server(self):
retour = []
retour.append((self.modele.noJoueurLocal,self.modele.dicAction2Server))
if(self.serveur):
for joueur in self.modele.listeJoueur:
if isinstance(joueur,AI):
retour.append((joueur.noJoueur, joueur.dictionaireAction))
return retour
def gameLoop(self):
reception = None
if(self.verbose):print("\n----------------------------\n",self.compteur, "ENVOIE : ", self.packAction2Server())
self.client.pushAction( self.packAction2Server() )
self.modele.dicAction2Server.clear()
while not reception:
reception = self.client.pullAction()
#if(self.verbose):print("RECOIE : ", reception)
if(not reception):
time.sleep(0.01)
#print("laaaaag!")
self.modele.gestion( reception )
"""if(self.vue.etatCreation==True):
self.vue.dessinerShadowBatiment()"""
self.modele.actualiser()
self.vue.displayRessources(self.modele.listeJoueur[self.modele.noJoueurLocal].listeRessource)
self.vue.displayObject(self.modele.listeJoueur,[],self.modele.noJoueurLocal,self.modele.selection)
self.vue.displayPop(self.modele.listeJoueur[self.modele.noJoueurLocal])
#self.vue.displayNodes(self.modele.cutNodes)
self.compteur+=1
self.vue.root.after(24,self.gameLoop)
def gererMouseClick(self,event):
offset = self.vue.getSurfacePos()#Obtenir la position du canvas
self.modele.clickPosx = event.x+offset[0]
self.modele.clickPosy = event.y+offset[1]
def gererMouseDrag(self, event):
offset = self.vue.getSurfacePos()
self.vue.displaySelection((self.modele.clickPosx,self.modele.clickPosy), event)
def gererMouseRelease(self,event):
self.vue.eraseSelection()
offset = self.vue.getSurfacePos()#Obtenir la position du canvas
self.modele.releasePosx = event.x+offset[0]
self.modele.releasePosy = event.y+offset[1]
self.modele.gererMouseRelease(event,self.etatCreation, self.infoCreation)
try:
self.vue.displayInfoUnit(self.modele.selection[0],self.modele.noJoueurLocal)
except Exception:
self.vue.hud.delete("infos")
self.vue.hud.delete("button")
self.vue.hud.delete("thumbnail")
print("Pas de selection!")
self.vue.etatCreation = False
def getResearch(self, noLocal):
return self.modele.listeJoueur[noLocal].availableResearch
def spawnUnit(self, unitName):
self.modele.spawnUnit(unitName)
def moveUnitWithMinimap(self, event):
#print("Avant : ",event.x, event.y)
event.x = event.x * (len(self.modele.map.map[0])*64)/self.vue.miniMapW
event.y = event.y * (len(self.modele.map.map)*64)/self.vue.miniMapH
self.modele.releasePosx = event.x
self.modele.releasePosy = event.y
#print("Apres : ",event.x, event.y)
self.modele.gererMouseRelease(event,self.etatCreation, self.infoCreation)
def getSizeBatiment(self, batiment):
return self.modele.dictBatiment[batiment]
def closeGame(self):
if(self.client and self.client.proxy):
self.client.disconnect()
if(self.serveur):
self.serveur.close()
def __init__(self):
Modele.__init__(self)
self.beta = np.array(0)
return
def exec():
opti = Modele()
print(
" 1-Heuristique Ordre croissant des prix des packs \nordre:{} \nsolution :{}\nz={}\n\n"
.format(opti.ordeByPrix(),
opti.heuristique(opti.ordeByPrix())[4],
opti.heuristique(opti.ordeByPrix())[2]))
print(
" 2-Heuristique Ordre croissant des prix des packs \nordre:{} \nsolution :{}\nz={}\n\n"
.format(opti.orderByNombreHeure(),
opti.heuristique(opti.orderByNombreHeure())[4],
opti.heuristique(opti.orderByNombreHeure(False))[2]))
print(
" 3-Heuristique Ordre décroissant du nombre d’heures par packs \nordre:{} \nsolution :{}\nz={}\n\n"
.format(opti.orderByRatioPrixSurNbHeure(),
opti.heuristique(opti.orderByRatioPrixSurNbHeure(False))[4],
opti.heuristique(opti.orderByRatioPrixSurNbHeure(False))[2]))
print(
" 4-Heuristique Ordre croissant du ratio (prix/nombre d’heures) \nordre:{} \nsolution :{}\nz={}\n\n"
.format(opti.orderByRatioPrixSurNbHeure(),
opti.heuristique(opti.orderByRatioPrixSurNbHeure(False))[4],
opti.heuristique(opti.orderByRatioPrixSurNbHeure())[2]))
print(" 5-La meilleur Heuristique :{}\n\n".format(
opti.bestHeuristique()[0]))
# input("entrez une touche pour continuer")
s = opti.borneSUp()
print(
"Q2-\nL’ordre initial{} \n la solution de la relaxation {} \nz={}\n\n".
format(opti.orderByRatioPrixSurNbHeure(False), s[4], s[2]))
deb = time()
print("Debut parcours de noeud[bourne sup-sol relaxée]")
s = opti.solve()
print("Fin parcours")
duree = time() - deb
print("Q3-")
print("La solution :{}\nl'objectif de la solution:{}\nz={}\n\n".format(
s[0], s[2], s[1]))
print("Le nombre de nœuds explorer par l’ordre de B&B :",
Node.nbre)
print("Temps d execution :%f" % duree)
print("la solution optimale{}\n Z:{}".format(s[0], s[1]))