def placer_un_Panneau_solaire(self):
"""
Permet au joueur s'il le souhaite et s'il en a le droit de construire le batiment Panneau solaire
Mets également à jour la quantité de ressource à sa disposition
"""
if (self.L_joueur[0].metal_tot >= Constante.cout_M_P
and self.L_joueur[0].energie_tot >= Constante.cout_E_P):
choix2 = input("placer Panneau solaire ? (YES/NO)")
if choix2 == 'YES':
x_inf_b = (self.__xmax - self.L) // 2 + 1
x_sup_b = (self.__xmax + self.L) // 2
y_inf_b = (self.__ymax - self.H) // 2 + 1
y_sup_b = (self.__ymax + self.H) // 2
#Noter que x_inf et x_sup doivent être +1 par rapport à leur valeur réelle (pour bien tout sélectionner dans la matrice)
L_pos = self.placement_pos_bat(x_inf_b, x_sup_b, y_inf_b,
y_sup_b, ' ')
if len(L_pos) == 0:
print('Aucune position disponible, étape suivante. \n')
else:
print('Positions possibles :', L_pos)
L = input(
'Envoyez la nouvelle position en x et en y (format x,y). \n'
)
k = L.find(',')
while k == -1:
print("Erreur de synthaxe. Recommencez svp")
L = input(
'Envoyez la nouvelle position en x et en y (format x,y). \n'
)
k = L.find(',')
X = int(L[0:k])
Y = int(L[k + 1:])
while (X, Y) not in L_pos:
print("Position hors du rayon d'action de l'unité. \n")
L = input(
'Envoyez la nouvelle position en x et en y (format x,y). \n'
)
k = L.find(',')
X, Y = int(L[0:k]), int(L[k + 1:])
U = Panneau_solaire(X, Y, self._carte)
self.L_joueur[0]._liste_bat[1].append(U)
self.L_joueur[0].metal_tot = self.L_joueur[
0].metal_tot - Constante.cout_M_P
self.L_joueur[0].energie_tot = self.L_joueur[
0].energie_tot - Constante.cout_E_P
print("Energie restante :", self.L_joueur[0].energie_tot,
"\n")
print("Métal restant :", self.L_joueur[0].energie_tot,
"\n")
def testRessources_tot(self):
"""
Test vérifiant qu'après avoir ajouté trois foreuses et 3 panneaux solaires,
et après 10 tours de jeu sans avoir effectué aucune dépense, que le défenseur
ait bien le bon total de ressources.
"""
Def = Game.L_joueur[0]
for i in range(3):
X = i
Y = i
Def._liste_bat[1].append(Panneau_solaire(X,Y,Carte))
Def._liste_bat[2].append(Foreuse(X+1,Y+1,Carte))
for k in range(10):
Carte.ressource_tot()
M = 10*(Constante.prod_M_F*3 + Constante.prod_M_QG)+Constante.metal_tot
E = 10*(Constante.prod_E_P*3 + Constante.prod_E_QG)+Constante.energie_tot
self.assertEqual(Def.metal_tot,M)
self.assertEqual(Def.energie_tot,E)
def placer_un_Panneau_solaire(self, X, Y):
"""
Permet au joueur, s'il en a le droit, de construire le batiment
Panneau solaire sur la case dont il a indiqué les coordonnées en entrée.
Cette case doit cependant être comprise dans les emplacements de construction
disponibles.
Met également à jour la quantité de ressource à sa disposition.
Paramètres :
-------------
X,Y : int
Les coordonnées de la case sur laquelle le joueur veut placer le batiment.
Renvoie :
----------
Rien.
"""
if (self.L_joueur[0].metal_tot >= Constante.cout_M_P
and self.L_joueur[0].energie_tot >= Constante.cout_E_P):
x_inf_b = (self.__xmax - self.L) // 2 + 1
x_sup_b = (self.__xmax + self.L) // 2 - 1
y_inf_b = (self.__ymax - self.H) // 2 + 1
y_sup_b = (self.__ymax + self.H) // 2 - 1
L_pos = self.placement_pos_bat(x_inf_b, x_sup_b, y_inf_b, y_sup_b,
' ')
if (X, Y) in L_pos:
U = Panneau_solaire(X, Y, self._carte)
self.L_joueur[0]._liste_bat[1].append(U)
self.L_joueur[0].metal_tot = self.L_joueur[
0].metal_tot - Constante.cout_M_P
self.L_joueur[0].energie_tot = self.L_joueur[
0].energie_tot - Constante.cout_E_P
def process(self, L):
"""
Effectue le processus de chargement de la partie, en testant les différentes chaînes de caractères de
la liste L.
Paramètres:
------------
L : list
Liste contenant toutes les chaînes de caractères de la sauvegarde; chaque élément de
la liste correspond à une ligne de la sauvegarde.
Renvoie :
----------
Rien.
"""
Tst = ['S', 'R']
if type(self.IHM) != str:
self.IHM.tr_en_crs = 1
self.IHM.tr_Hn_en_crs = 1
while len(L) != 0:
if L[0] == 'Carte':
# Processus de recréation de la carte sauvegardée.
Dims = L[2]
Nbta = L[4]
Nbt = L[6]
U_disp = L[7]
Jr_en_crs = L[8]
L = L[9:]
Dims = Dims[1:-1]
k = Dims.find(',')
X = int(Dims[0:k])
Y = int(Dims[k + 1:])
Constante.xL = X
Constante.yL = Y
if int(X / 2) % 2 == 0:
LL = int(X / 2) + 1
else:
LL = int(X / 2)
if int(Y / 2) % 2 == 0:
LH = int(Y / 2) + 1
else:
LH = int(Y / 2)
LEp = int(max(X, Y) / 20)
Constante.LL_Z_Constructible = LL
Constante.LH_Z_Constructible = LH
Constante.LEp_app = LEp
Constante.Lnbta = int(Nbta)
Constante.Lnbt = int(Nbt)
U_disp = float(U_disp)
self.Lcarte = Map.Map([], 1, self.IHM)
self.Lcarte.TrIA.unite_disp_par_tour = U_disp
self.Lcarte.TrHn.unite_disp_par_tour = U_disp
self.Lcarte.TrHn.Jr_en_crs = int(Jr_en_crs)
print("Carte OK")
while L[0] == 'Ressource':
#Processus de chargement des ressources sauvegardées sur la carte.
Val = L[1]
Pos = L[2]
L = L[4:]
Pos = Pos[1:-1]
k = Pos.find(',')
X = int(Pos[0:k])
Y = int(Pos[k + 1:])
Val = int(Val)
metal(X, Y, self.Lcarte, Val)
print("Ressource OK")
while L[0] == 'Joueur':
# Processus de chargement des joueurs de la partie, et de leurs caractéristiques principales.
Role = L[1]
Metal_tot = int(L[2])
Energie_tot = int(L[3])
Ur = float(L[4])
self.Jr = Joueur(Role)
self.Lcarte.L_joueur.append(self.Jr)
self.Jr.metal_tot = Metal_tot
self.Jr.energie_tot = Energie_tot
self.Jr.nbe_unite_restantes = Ur
L = L[6:]
while L[0] == 'Bat':
# Processus de chargement des batiments du joueur actuel.
Typ = L[1]
Sante = L[2]
Pos = L[3]
L = L[4:]
Sante = int(Sante)
Typ = Typ[-2:]
Pos = Pos[1:-1]
k = Pos.find(',')
X = int(Pos[0:k])
Y = int(Pos[k + 1:])
if Typ == "QG":
B = QG(X, Y, self.Lcarte)
B.sante = Sante
self.Jr._liste_bat[0].append(B)
elif Typ[0] == "P":
Id = int(Typ[1])
B = Panneau_solaire(X, Y, self.Lcarte)
B.sante = Sante
B.id = Id
self.Jr._liste_bat[1].append(B)
elif Typ[0] == "F":
Id = int(Typ[1])
B = Foreuse(X, Y, self.Lcarte)
B.sante = Sante
B.id = Id
self.Jr._liste_bat[2].append(B)
if L[0] == "Fin bat":
print("Fin bat")
L = L[2:]
while L[0] == "Unite":
# Processus de chargement des unités du joueur actuel.
k = -2
Typ = L[1]
Num_joueur = L[2]
Sante = L[3]
Pos = L[4]
if Role[1] == 'H':
Capmvt = int(L[5])
L = L[6:]
else:
L = L[5:]
tTyp = Typ[k:]
while tTyp[0] not in Tst:
k = k - 1
tTyp = Typ[k:]
Typ = tTyp
Num_joueur = int(Num_joueur)
Sante = int(Sante)
Pos = Pos[1:-1]
k = Pos.find(',')
X = int(Pos[0:k])
Y = int(Pos[k + 1:])
if Typ[0:2] == "RC":
Id = int(Typ[2:])
U = Robot_combat(Role, self.Lcarte, X, Y)
U.sante = Sante
U.capmvt = Capmvt
self.Jr._liste_unite.append(U)
elif Typ[0:2] == "RO":
Id = int(Typ[2:])
U = Robot_Ouvrier(Role, self.Lcarte, X, Y)
U.sante = Sante
U.capmvt = Capmvt
self.Jr._liste_unite.append(U)
elif Typ[0] == "S":
if len(Role) > 3 and Role[3] == "0":
Id = int(Typ[3:])
U = Scorpion0(Role, self.Lcarte, X, Y, Num_joueur)
U.sante = Sante
U.id = Id
self.Jr._liste_unite.append(U)
elif len(Role) > 3 and Role[3] == "1":
Id = int(Typ[3:])
U = Scorpion1(Role, self.Lcarte, X, Y, Num_joueur)
U.sante = Sante
U.id = Id
self.Jr._liste_unite.append(U)
elif Role[1] == "H":
Id = int(Typ[1:])
U = Scorpion(Role, self.Lcarte, X, Y, Num_joueur)
U.sante = Sante
U.id = Id
U.capmvt = Capmvt
self.Jr._liste_unite.append(U)
if L[0] == "Fin unite":
print("Fin unite")
L = L[1:]
if L[0] == "Fin sauvegarde":
L = []
else:
L = L[1:]