salut! C'est cool! !!
Cette fois, je voudrais faire Othello avec Python.
(Ajout) (1) aléatoire n'était pas nécessaire. Je suis désolé. Les bibliothèques requises sont les suivantes. (1) random (2) numpy
(1) s'appelle une bibliothèque standard et est à l'origine intégré à Python, il n'est donc pas nécessaire d'installer pip.
Si numpy in (2) n'est pas installé,
Tapez l'invite de commande et essayez d'installer.
Lorsque la bibliothèque est prête, je voudrais entrer dans le programme principal d'Othello.
from numpy import zeros, where, float32
class othello:
#constant(-En multipliant par 1, vous pouvez exprimer le basculement du noir au blanc et du blanc au noir.)
white = 1.
black = -1.
empty = 0.
edge = 8 #Nombre de côtés
#Initialisation
def __init__(self):
self.board = zeros(self.edge**2, dtype=float32) #0 au tableau(=self.empty)Initialiser avec
self.board[27] = self.board[36] = self.white #Disposition initiale du cadre
self.board[28] = self.board[35] = self.black #Disposition initiale du cadre
self.turn = True # white:True black:False
self.available = [] #Un tableau contenant les coordonnées de l'endroit où vous pouvez retourner
#Retournez s:Numéro de lieu ex:Si c'est vrai, retournez,Si faux, vérifiez simplement s'il peut être placé sans le retourner
def over(self, s, ex=True):
s = int(s)
start = s
my_color = self.white if self.turn else self.black
flag = False #Indique s'il peut être placé dans s
for i in range(-1, 2):
for j in range(-1, 2):
v = self.edge * i + j #v est 8 directions(N'importe quel)Représente un passage à
if v == 0:
continue
s = start
for k in range(self.edge - 1):
s += v #Ajouter la quantité de mouvement
if (s < 0 or s > self.edge**2 - 1 or self.board[s] == self.empty): #S'il est hors du plateau ou vide, il ne peut pas être retourné dans cette direction.
break
if self.board[s] == my_color: #Si cela correspond à votre couleur
if k > 0: # k=Quand c'est 0,Endroit où tu le mets(start)Puisqu'il s'agit d'un carré en contact avec, il n'y a pas de retournement
if ex:
self.board[start + v: s : v] *= -1 #Effectuer le retournement
flag = True #Si vous pouvez retourner ne serait-ce qu'une seule feuille, vous pouvez la mettre à cet endroit
break
if (((s % self.edge == 0 or s % self.edge == self.edge - 1) and abs(v) != self.edge)
or ((s // self.edge == 0 or s // self.edge == self.edge - 1) and abs(v) != 1)):
break
if flag and ex: #Si vous pouvez mettre une pièce à l'endroit spécifié, mettez-la
self.board[start] = my_color
return flag
#Jugement gagnant / perdant
def judge(self):
n_white = len(where(self.board == self.white)[0]) #Nombre de Shiraishi
n_black = len(where(self.board == self.black)[0]) #Nombre de pierres noires
print("\n", "noir>> ", n_black, "blanc>> ", n_white, "\n") #Sortie du nombre de pierres
if n_white < n_black:
print("Noir gagne")
elif n_black < n_white:
print("Blanc gagne")
else:
print("dessiner")
#Fonction de mise à jour
def update(self, end=False):
self.turn ^= True
self.available = [] # self.Mettez les coordonnées qui peuvent être placées dans disponibles
for i in range(self.edge**2):
if self.board[i] == self.empty and self.over(i, ex=False):
self.available.append(i)
if len(self.available) == 0:
return False if end else self.master(end=True) #Si vous ne pouvez pas le mettre deux fois de suite, le jeu se termine
self._input()
return True
#contribution(CUI)
def _input(self):
while True:
msg = "Virage blanc" if self.turn else "Tour noir"
x, y = map(int, input(msg + "Spécification de la matrice>> ").split())
if 8 * x + y in self.available: #Lorsque l'endroit où la pierre peut être placée est entré
self.over(8 * x + y) #Le processus de retournement
break
print("---Invalid Position---") #Message d'avertissement lorsqu'un endroit où les pierres ne peuvent pas être placées est entré
#Dessin de planche(CUI)
def draw(self):
edge = self.edge
print("\n 0 1 2 3 4 5 6 7")
for i in range(edge):
temp = []
temp.append(str(int(i)))
for el in self.board[edge * i:edge * (i + 1)]:
if el == self.white:
temp.append("○")
elif el == self.black:
temp.append("●")
else:
temp.append("＋")
print(" ".join(temp))
#Fonction principale
def main():
s = othello() #Génération d'instances d'Othello
flag = True #Drapeau indiquant si le jeu continue(True:En cours, False:Fin)
while flag:
s.draw() #Dessin de planche
flag = s.update() #Fonction de mise à jour
s.judge() #Jugement gagnant / perdant à la fin du jeu
if __name__ == "__main__":
main()
(point important) (1) Dans la méthode over, le mot-clé argument ex est utilisé pour déterminer si la trame est effectivement retournée ou non. Le moment où vous n'avez pas à le retourner est celui où vous voulez savoir où placer les pièces à l'avance.
(2) Dans la méthode over, les coordonnées du tableau sont exprimées par l'index sur self.board au lieu du format matriciel. Soyez donc prudent avec les conversions de matrice et d'index. Par exemple, l'indice de i-by-j est i * self.edge + j.
Essayez de copier et d'exécuter ce programme. N'hésitez pas à nous contacter si vous rencontrez des problèmes.
Recommended Posts