def production_unite_defense_combat(self, X, Y):
"""
Produit une unité de combat pour le défenseur, si celui-ci a suffisamment de ressources,
sur la case qu'il a indiqué en entrée.
Cette case doit cependant être comprise dans les emplacements de production
disponibles.
Paramètres :
------------
X,Y : int
Les coordonnées de la case sur laquelle le joueur veut placer l'unité.
Renvoie :
----------
Rien.
"""
if (self.L_joueur[0].metal_tot >= Constante.cout_M_RC
and self.L_joueur[0].energie_tot >= Constante.cout_E_RC):
x_inf = (self.__xmax) // 2 - 1
x_sup = (self.__xmax) // 2 + 2
y_inf = (self.__ymax) // 2 - 1
y_sup = (self.__ymax) // 2 + 2
L_pos = self.placement_pos(x_inf, x_sup, y_inf, y_sup, ' ')
if (X, Y) in L_pos:
U = Robot_combat(self.L_joueur[0]._role, self._carte, X, Y)
self.L_joueur[0]._liste_unite.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 production_unite_defense_combat(self):
"""
Produit une unité de combat pour le défenseur, si celui-ci a suffisamment de ressources et avec son accord.
Il doit également décider de la position de cette unité, parmi les positions possibles.
Paramètres :
------------
Aucun.
Renvoie :
----------
Rien.
"""
if (self.L_joueur[0].metal_tot>=Constante.cout_M_RC and self.L_joueur[0].energie_tot>=Constante.cout_E_RC):
choix_DH=input("construire un robot de combat? (YES/NO)")
if choix_DH=='YES':
x_inf = (self.__xmax )//2 -1
x_sup = (self.__xmax)//2 +2
y_inf = (self.__ymax)//2 - 1
y_sup = (self.__ymax)//2 +2
#A VERIF
L_pos = self.placement_pos(x_inf,x_sup,y_inf,y_sup,' ')
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=Robot_combat(self.L_joueur[0]._role,self._carte,X,Y)
self.L_joueur[0]._liste_unite.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")
elif choix_DH=='NO':
pass
def __init__(self,L_joueur,l =0):
"""
Permet la création d'un objet carte.
Cette initialisation a deux comportements différents, selon la variable
d'entrée l :
*Si l = 0 : cela indique que l'objet carte crée ne correspond pas
à une sauvegarde. Les variables de la carte sont donc initialisés
par rapport aux constantes ne correspondant pas à des variables de
chargement.
De plus, les objets de début de partie du défenseur (un QG, 4 unités
de combat) sont créées.
*Si l != 0 (l = 1 par convention): cela indique que l'objet carte crée
correspond à une sauvegarde. Les variables de la carte sont donc
initialisés par rapport aux constantes correspondant à des variables
de chargement.
Les murs délimitant la zone de construction, et impossible à traverser
par les unités, sont également tracées dans la sous-carte de l'objet
carte.
Paramètres
----------
L_joueur : list
La liste des objets Joueurs dans le jeu.
l : int
L'indice indiquant si l'objet carte doit être issu d'une sauvegarde
ou non.
Renvoie
--------
Rien
"""
if l == 0 :
self.__xmax = Constante.xmax
self.__ymax = Constante.ymax
self.nbtour = Constante.nbt
self.tr_actuel = 0
self.H=Constante.H_Z_Constructible
self.L=Constante.L_Z_Constructible
self.Epp = Constante.Ep_app
self.Ltr_actuel = 0
self.L_joueur = L_joueur
self.ss_carte = np.array([[' ' for j in range(self.__ymax)] for i in range(self.__xmax)], dtype = object)
B = QG(self.__xmax//2,self.__ymax//2,self)
u1 = Robot_combat('DH',self,self.__xmax//2 -2,self.__ymax//2)
u2 = Robot_combat('DH',self,self.__xmax//2,self.__ymax//2 +2)
u3 = Robot_combat('DH',self,self.__xmax//2 +2,self.__ymax//2)
u4 = Robot_combat('DH',self,self.__xmax//2,self.__ymax//2-2)
self.L_joueur[0]._liste_bat[0].append(B)
self.L_joueur[0]._liste_unite.append(u1)
self.L_joueur[0]._liste_unite.append(u2)
self.L_joueur[0]._liste_unite.append(u3)
self.L_joueur[0]._liste_unite.append(u4)
else :
self.__xmax = Constante.xL
self.__ymax = Constante.yL
self.nbtour = Constante.Lnbt
self.Ltr_actuel = Constante.Lnbta
self.H=Constante.LH_Z_Constructible
self.L=Constante.LL_Z_Constructible
self.Epp = Constante.LEp_app
self.L_joueur = L_joueur
self.ss_carte = np.array([[' ' for j in range(self.__ymax)] for i in range(self.__xmax)], dtype = object)
self.spawn_ress=Constante.spawn_ress
self.TrHn = Un_Tour_Joueur_Hn(self)
self.TrIA = Un_Tour_Joueur_IA(self)
self.V_atta = 0
# Trace les murs dans la sous-map
for i in ( (self.__xmax - self.L )//2, (self.__xmax + self.L )//2-1 ): # -1 ; -1
#Trace les murs du haut et du bas, avec un trou au milieu de ces deux lignes.
for j in range( (self.__ymax - self.H + 1)//2, self.__ymax//2 - 1):
self.ss_carte[i][j] = '/'
for j in range( self.__ymax//2 + 2, (self.__ymax + self.H )//2):
self.ss_carte[i][j] = '/'
for j in ( (self.__ymax -self.H)//2 , (self.__ymax + self.H )//2-1 ):
# Trace les murs de gauche et de droite, avec un trou au milieu de ces deux colonnes
for i in range( (self.__xmax - self.L +1)//2 , self.__xmax//2 -1 ):
self.ss_carte[i][j] = '/'
for i in range( self.__xmax//2 + 2, (self.__xmax + self.L )//2 ) :
self.ss_carte[i][j] = '/'
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:]