def changeCoordPoint(self, oldCoord, newCoord, MAJ=True):
"""
Change les coordonnées du point connu par ses anciennes coordonnées vers de nouvelles coordonnées
Met à jour la géométrie qui en a besoin
"""
if self.sommets.count(oldCoord)<1:
print "Erreur planete::changeCoordPoint,",oldCoord,"ce sommet n'existe pas"
raw_input()
idx = self.sommets.index(oldCoord)
self.sommets[idx] = Vec3(*general.floatise(newCoord))
self.modifieVertex(idx, MAJ=MAJ)
elements = self.sommetDansFace[idx]
for element in elements:
element.normale = None #On a bougé un point, donc sa normale a changée
if MAJ:
general.planete.aiNavigation.majGraphNavigation(idx)
def fabriqueSoleil(self, type=None):
if type==None:
type = general.configuration.getConfiguration("affichage", "effets", "typeEclairage", "shader", str)
type=type.lower().strip()
couleurSoleil = general.configuration.getConfiguration("Planete", "Univers", "couleurSoleil", "0.9 0.9 0.9 0.8", str)
couleurSoleil = VBase4(*general.floatise(couleurSoleil.split(" ")))
if type=="flat":
light = PointLight('soleil')
light.setColor(couleurSoleil)
self.soleil = self.geoide.racine.attachNewNode(light)
self.soleil.setPos(0,0,0)
self.soleil.setLightOff()
self.geoide.racine.setLight(self.soleil)
cardMaker = CardMaker('soleil')
cardMaker.setFrame(-0.5, 0.5, -0.5, 0.5)
bl = self.geoide.racine.attachNewNode(cardMaker.generate())
#Applique la tecture dessus
tex = loader.loadTexture("data/textures/soleil.png")
bl.setTexture(tex)
#Active la transprence
bl.setTransparency(TransparencyAttrib.MDual)
#Fait une mise à l'échelle
bl.setScale(0.8)
#On fait en sorte que la carte soit toujours tournée vers la caméra, le haut vers le haut
bl.setBillboardPointEye()
#bl = loader.loadModel("./data/modeles/sphere.egg")
bl.reparentTo(self.soleil)
self.soleil.reparentTo(self.geoide.racine)
elif type=="none":
self.soleil = loader.loadModel("./data/modeles/sphere.egg")
self.soleil.reparentTo(self.geoide.racine)
else:
print "Type d'éclairage inconnu",type
def charge(self, fichier, simple=False):
"""Charge le géoïde depuis un fichier"""
self.afficheTexte("Chargement en cours...", parametres={}, type="sauvegarde")
self.detruit()
self.spritesJoueur = []
self.spritesNonJoueur = []
self.joueurs = []
if general.configuration.getConfiguration("debug", "planete", "debug_charge_planete", "f", bool):
self.afficheTexte("Lecture du fichier...", parametres={}, type="sauvegarde")
#Lecture depuis le zip
zip = zipfile.ZipFile(fichier, "r")
if zip.testzip()!=None:
print "PLANETE :: Charge :: Erreur : Fichier de sauvegarde corrompu !"
data = zip.read("sauvegarde")
zip.close()
lignes = data.split("\r\n")
if general.configuration.getConfiguration("debug", "planete", "debug_charge_planete", "f", bool):
self.afficheTexte("Parsage des infos...", parametres={}, type="sauvegarde")
lignes = self.geoide.charge(lignes, simple)
tot = len(lignes)
for i in range(0, tot):
if general.configuration.getConfiguration("debug", "planete", "debug_charge_planete", "f", bool):
if i%500==0:
self.afficheTexte("Parsage des infos... %{a}i/%{b}i", parametres={"a":i, "b":tot}, type="sauvegarde")
ligne = lignes[i]
elements = ligne.strip().lower().split(":")
type = elements[0]
elements = elements[1:]
if type=="parametres":
if elements[0]=="distancesoleil":
#Attrapage des infos de distanceSoleil
self.distanceSoleil = float(elements[1])
elif elements[0]=="anglesoleil":
#Attrapage des infos de angleSoleil
self.angleSoleil = float(elements[1])
else:
print "Donnée inconnue : ",element[0]
if type=="details":
if elements[0]=="nomplanete":
#Attrapage des infos de distanceSoleil
self.nom = elements[1]
else:
print "Détail inconnu : ",element[0]
elif type=="joueur":
#Création d'un joueur
type, nom, couleur, estJoueur, vide = elements
couleur = VBase4(general.floatise(couleur.replace("(","").replace(")","").replace("[","").replace("]","").split(",")))
classe = Joueur
if type=="ia":
classe = JoueurIA
elif type=="local":
classe = JoueurLocal
elif type=="distant":
classe = JoueurDistant
else:
print "PLANETE :: Charge :: Erreur, type de joueur inconnu :", type
self.ajouteJoueur(classe(nom, couleur, estJoueur.lower().strip()=="true"))
elif type=="joueur-ressource":
#Création des ressources d'un joueur
nomjoueur, nomressource, valeur, vide = elements
for joueur in self.joueurs:
if joueur.nom.lower().strip()==nomjoueur.lower().strip():
joueur.ressources[nomressource] = int(valeur)
elif type=="sprite":
#Sprites
id, nomjoueur, modele, symbole, position, vitesse, vie, bouge, aquatique, dureeDeVie, tempsDeVie, fichierDefinition, vide = elements
position = Vec3(*general.floatise(position.replace("[","").replace("]","").replace("(","").replace(")","").split(",")))
if nomjoueur.lower().strip()=="none":
joueur = None
else:
for joueurT in self.joueurs:
if joueurT.nom.lower().strip()==nomjoueur.lower().strip():
joueur = joueurT
if fichierDefinition.lower().strip()=="none":
fichierDefinition = None
sprite = Sprite(id, position, fichierDefinition, joueur)
sprite.modele = modele
sprite.symbole = symbole
sprite.vie = float(vie)
sprite.bouge = bouge.lower().strip()=="t"
sprite.aquatique = aquatique.lower().strip()=="t"
sprite.dureeDeVie = float(dureeDeVie)
sprite.tempsDeVie = float(tempsDeVie)
sprite.vitesse = float(vitesse)
if joueur!=None:
self.spritesJoueur.append(sprite)
joueur.sprites.append(sprite)
else:
self.spritesNonJoueur.append(sprite)
elif type=="sprite-contenu":
id, type, valeur = elements
valeur = float(valeur)
for sprite in self.spritesJoueur:
if sprite.id.lower().strip() == id.lower().strip():
sprite.contenu[type]=valeur
for sprite in self.spritesNonJoueur:
if sprite.id.lower().strip() == id.lower().strip():
sprite.contenu[type]=valeur
elif ligne.strip()!="":
print
print "Avertissement : Planete::charge, type de ligne inconnue :", type,"sur la ligne :\r\n",ligne.strip()
general.TODO("Ajouter la prise en charge du chargement de "+type)
self.afficheTexte("Chargement terminé", parametres={}, type="sauvegarde")
def fabriqueModel(self):
"""Produit un modèle 3D à partir du nuage des faces"""
if self.soleil == None:
cardMaker = CardMaker("soleil")
cardMaker.setFrame(-0.5, 0.5, -0.5, 0.5)
self.soleil = self.racine.attachNewNode(cardMaker.generate())
# Applique la tecture dessus
tex = loader.loadTexture("data/textures/soleil.png")
self.soleil.setTexture(tex)
# Active la transprence
self.soleil.setTransparency(TransparencyAttrib.MDual)
# Fait une mise à l'échelle
self.soleil.setScale(100.0)
# On fait en sorte que la carte soit toujours tournée vers la caméra, le haut vers le haut
self.soleil.setBillboardPointEye()
# Étoiles
self.etoiles = loader.loadModel("data/modeles/sphere.egg")
self.etoiles.setTransparency(TransparencyAttrib.MDual)
tex = loader.loadTexture("data/textures/etoiles4.tif")
# tex.setMagfilter(Texture.FTLinear)
# tex.setMinfilter(Texture.FTLinearMipmapLinear)
# etoiles.setTexGen(TextureStage.getDefault(), TexGenAttrib.MEyeSphereMap)
self.etoiles.setTexture(tex, 1)
self.etoiles.setTwoSided(False)
self.etoiles.setScale(
general.configuration.getConfiguration("planete", "Univers", "distanceSoleil", "10.0", float)
* 3.0
/ 2.0
)
self.etoiles.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
self.etoiles.reparentTo(self.racine)
self.etoiles.setBin("background", 1)
self.etoiles.setDepthTest(False)
self.etoiles.setDepthWrite(False)
self.etoiles.setPythonTag("type", "ciel")
# On coupe la collision avec les étoiles pour pas qu'on détecte de clics sur le fond
self.etoiles.setCollideMask(BitMask32.allOff())
# Lumière dans le noir
couleurNuit = general.configuration.getConfiguration(
"Planete", "Univers", "couleurNuit", "0.2 0.2 0.275 1.0", str
)
couleurNuit = VBase4(*general.floatise(couleurNuit.split(" ")))
alight = AmbientLight("alight")
alight.setColor(couleurNuit)
alnp = self.racine.attachNewNode(alight)
self.racine.setLight(alnp)
# Lumière du soleil
couleurSoleil = general.configuration.getConfiguration(
"Planete", "Univers", "couleurSoleil", "0.9 0.9 0.9 0.8", str
)
couleurSoleil = VBase4(*general.floatise(couleurSoleil.split(" ")))
light = PointLight("soleil")
light.setColor(couleurSoleil)
lampe = self.racine.attachNewNode(light)
lampe.setPos(0, 0, 0)
self.racine.setLight(lampe)
# Le fond et le soleil ne sont pas affectés par la lumière
self.soleil.setLightOff()
self.etoiles.setLightOff()
for i in range(0, len(self.planetes)):
planete, rayonplanete, rayonorbite, angleDepart, planetemdl, vitesse = self.planetes[i]
if planetemdl == None:
planetemdl = loader.loadModel("./data/modeles/sphere.egg")
planetemdl.reparentTo(self.racine)
planetemdl.setScale(rayonplanete)
# planetemdl.setColor(random.random()*0.5, random.random()*0.5, random.random()*0.5)
planetemdl.setPythonTag("type", "planete") # Pour dire que c'est une planète
planetemdl.setPythonTag(
"nomPlanete", planete
) # Pour indiquer de quelle planète il sagit et le retrouver facilement
# Si c'est une vraie sauvegarde, on prend sa minimap comme etxture
if planete != "--n/a--":
fichier = os.path.join(".", "data", "cache", planete + "-tex.png")
zip = zipfile.ZipFile(os.path.join(".", "data", "planetes", planete), "r")
if zip.testzip() != None:
print "SystemeSolaire :: Charge :: Erreur : Fichier de sauvegarde corrompu !"
data = zip.read("minimap.png")
zip.close()
img = open(fichier, "w")
img.write(data)
img.close()
planetemdl.setTexture(loader.loadTexture("./data/cache/" + planete + "-tex.png"))
# Sinon on utili celle par défaut
else:
planetemdl.setTexture(loader.loadTexture("./data/textures/planete-vide.png"))
# planetemdl.setHpr(random.random()*360, random.random()*360, random.random()*360)
self.planetes[i] = (planete, rayonplanete, rayonorbite, angleDepart, planetemdl, vitesse)
anneau = self.racine.attachNewNode(self.dessineCercle(rayonorbite, 40))
anneau.setBin("background", 2)
anneau.setDepthTest(False)
anneau.setDepthWrite(False)
anneau.setLightOff()
def fabriqueCiel(self):
"""Ajoute une sphère qui représente l'eau"""
if general.configuration.getConfiguration("debug", "planete", "debug_construction_sphere", "f", bool):
return
#Crée le modèle du ciel
self.modeleCiel = NodePath("ciel")
self.modeleCiel.reparentTo(self.racine)
self.niveauCiel = 1.0+self.delta*1.25+0.0001
if general.configuration.getConfiguration("planete", "nuages", "affiche-nuages", "t", bool):
nuages = NodePath("nuage")
densite = general.configuration.getConfiguration("planete", "nuages", "densite", "15", int)
taille = general.configuration.getConfiguration("planete", "nuages", "taille", "0.15", float)
quantite = general.configuration.getConfiguration("planete", "nuages", "quantite", "80", int)
for i in range(0, quantite):
a = sprite.Nuage(densite, taille)
a.fabriqueModel().reparentTo(nuages)
general.planete.spritesNonJoueur.append(a)
nuages.reparentTo(self.modeleCiel)
#Ciel bleu
self.azure = loader.loadModel("data/modeles/sphere.egg")
self.azure.setTransparency(TransparencyAttrib.MDual )
self.azure.setColor(0.6, 0.6, 1.0, 1.0)
self.azure.setTwoSided(True)
self.azure.setScale((self.niveauCiel+0.001+0.0001))
#self.azure.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
self.azure.reparentTo(self.modeleCiel)
#self.azure.setTexture("data/textures/EarthClearSky2.png", 1)
self.azure.setBin('background', 2)
self.azure.setDepthTest(False)
self.azure.setDepthWrite(False)
if general.configuration.getConfiguration("affichage","general", "multitexturage","heightmap",str)=="shader" or general.configuration.getConfiguration("affichage", "general", "type-eau", "texture", str)=="shader":
self.azure.setShader( loader.loadShader( 'data/shaders/atmosphere.sha' ) )
tex = loader.loadTexture( 'data/textures/EarthClearSky2.png' )
self.azure.setTexture( tex, 1 )
#Fabrique une lumière ambiante pour que la nuit soit moins noire
if general.configuration.getConfiguration("affichage", "Effets", "typeEclairage","shader",str)=="flat":
couleurNuit = general.configuration.getConfiguration("Planete", "Univers", "couleurNuit", "0.2 0.2 0.275 1.0", str)
couleurNuit = VBase4(*general.floatise(couleurNuit.split(" ")))
alight = AmbientLight('alight')
alight.setColor(couleurNuit)
alnp = self.racine.attachNewNode(alight)
self.racine.setLight(alnp)
#L'azure n'est pas affectée par la lumière ambiante
self.azure.setLightOff(alnp)
#Ciel orange
#couchant = loader.loadModel("data/modeles/sphere.egg")
#couchant.setTransparency(TransparencyAttrib.MDual )
#couchant.setColor(1.0, 0.3, 0.1, 1.0)
#couchant.setTwoSided(False)
#couchant.setScale((self.niveauCiel+0.001+0.0005))
#couchant.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
#couchant.reparentTo(self.modeleCiel)
#Étoiles
etoiles = loader.loadModel("data/modeles/sphere.egg")
etoiles.setTransparency(TransparencyAttrib.MDual )
tex = loader.loadTexture('data/textures/etoiles4.tif')
#tex.setMagfilter(Texture.FTLinear)
#tex.setMinfilter(Texture.FTLinearMipmapLinear)
#etoiles.setTexGen(TextureStage.getDefault(), TexGenAttrib.MEyeSphereMap)
etoiles.setTexture(tex, 1)
etoiles.setTwoSided(False)
etoiles.setScale(general.configuration.getConfiguration("planete", "Univers", "distanceSoleil","10.0",float)*3.0/2.0)
etoiles.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
etoiles.reparentTo(self.modeleCiel)
etoiles.setLightOff()
etoiles.setBin('background', 1)
etoiles.setDepthTest(False)
etoiles.setDepthWrite(False)
self.modeleCiel.setPythonTag("type","ciel")
#On coupe la collision avec le ciel pour pas qu'on détecte de clics sur le ciel
self.modeleCiel.setCollideMask(BitMask32.allOff())
