J'ai essayé de faire d'Othello pour enseigner Python3 aux enfants (6) Final

Expliquons la classe d'Othello Partie 3

"Examinez le cadre à côté de X et Y passé à la fonction et le cadre à côté" fonction

Eh bien, c'est peut-être le plus difficile, mais je vais l'expliquer. La fonction de classe Othello ʻot_next_onepeace () ʻexpliquée ci-dessous est une fonction avec la fonction ** "Examinez le cadre à côté de X et Y passé à la fonction et le cadre à côté" **. Ce mot est une fonction très importante. Je le répète. Cette fonction n'exécute que ** "Examiner le cadre à côté de X et Y passé à la fonction et le cadre à côté" **. Même si les carrés de la carte Othello sont des cartes 100x100, cette fonction n'exécute que ** "Examiner le cadre à côté de X et Y passé à la fonction et le cadre à côté" **. est.

Parce que c'est une "fonction que vous vous appelez (fonction récursive)"!

Si vous décidez que vous pouvez placer une pièce dans une petite mesure, vous devez retourner toutes les directions qui peuvent être retournées. Pour cela, est-il possible de retourner dans 8 directions? Jusqu'où pouvez-vous le retourner? Il faut y penser.

Dans cette fonction, par exemple, si ● est placé à une coordonnée spécifique, les coordonnées X et Y où il est placé et le caractère clé dans la direction que vous voulez vérifier sont passés en arguments, et ** "des X et Y sont passés à la fonction. Examinez le cadre suivant et le cadre à côté "**. (C'est persistant!)

La clé de la variable de dictionnaire ʻot_direction, qui représente les coordonnées à côté des huit directions, est passée comme troisième argument. Chaînes de clés telles que «ul» et «up». Le tableau tupple [0]qui correspond à cette chaîne clé contient un nombre qui représente la main à côté de la coordonnée X. Si vous regardez vers la gauche, -1 est inclus. Il vaut 0 s'il est directement au-dessus ou en dessous, +1 s'il est à droite, et ainsi de suite. De même, letaple array [1]contient un nombre représentant la main à côté de la coordonnée Y. Stockez cetaple array [0]dans une variable appelée nx et letaple array [1]dans une variable appelée ny. La méthode pour accéder au tableau de dictionnaire est ʻot_direction [caractère clé (troisième argument)] [indice du tableau tapple]. N'oubliez pas de cette façon. S'il n'y a qu'une seule valeur pour la clé, l'accès est effectué en utilisant la même méthode d'accès que le tableau unidimensionnel ʻot_direction [caractère clé (troisième argument)] `. Cette fois, il s'agit d'un tableau tapple pour la chaîne de caractères clé, il a donc la même méthode d'accès que le tableau bidimensionnel.

        self.ot_direction = { 'ul' : ( -1 , -1 ) ,  #En diagonale au-dessus à gauche
                              'up' : (  0 , -1 ) ,  #Juste au dessus
                              'ur' : ( +1 , -1 ) ,  #En diagonale au-dessus à droite
                              'lt' : ( -1 ,  0 ) ,  #la gauche
                              'rt' : ( +1 ,  0 ) ,  #droite
                              'dl' : ( -1 , +1 ) ,  #En diagonale en dessous à gauche
                              'dn' : (  0 , +1 ) ,  #Directement en dessous
                              'dr' : ( +1 , +1 ) }  #En diagonale en dessous à droite

La coordonnée X ʻot_x et la coordonnée Y ʻot_y où le cadre est placé sont passées aux premier et deuxième arguments de cette fonction. D'autre part, en ajoutant les nx et ny suivants, la trame dans la direction à rechercher est déterminée. Si vous vérifiez la coordonnée X ʻot_x passée dans cet argument et à côté et à côté de la coordonnée Y ʻot_y, décalez-la de un et appelez à nouveau votre fonction. Cela ressemble à ceci sur la figure.

1. La première fois, vérifiez le cadre à gauche de X = 6 et Y = 5, et le cadre à gauche de celui-ci. (○ et ○!)
2. Cette fonction décale les valeurs passées par ot_x et ot_y de un selon les instructions des nombres dans le tableau tapple des variables du dictionnaire, et appelle à nouveau sa propre fonction.
3. Les arguments de la fonction appelée la deuxième fois sont X = 5, Y = 5. De là, vérifiez le cadre à gauche et le cadre à gauche. (C'est ○ et ○ encore !!)
4. Encore une fois, cette fonction décale les valeurs passées par ot_x et ot_y de un selon les instructions des nombres dans l'exemple de tableau de variables de dictionnaire, et appelle à nouveau sa propre fonction.
5. Les arguments de la fonction appelée la troisième fois sont X = 4 et Y = 5. De là, vérifiez le cadre à gauche et le cadre à gauche. (C'est ○ et ○ encore !!)
6. Encore une fois, cette fonction décale les valeurs passées par ot_x et ot_y de un selon les instructions des nombres dans l'exemple de tableau de variables de dictionnaire, et appelle à nouveau sa propre fonction.
7. Les arguments de la fonction appelée la quatrième fois sont X = 3, Y = 5. De là, vérifiez le cadre à gauche et le cadre à gauche. Puisque les cadres continus avec ○ ● sont apparus, stockez-les dans ʻot_lastposX et ʻot_lastposY comme des positions où la position noire peut être retournée, et cette fonction se termine.

Même si le cadre à gauche et le cadre à gauche de celui-ci sont ○○, si le résultat du décalage de un et de continuer à vous appeler ne devient pas ○ ● comme le montre la figure ci-dessous (○ ・)? (Fin par ○) est jugé qu'il ne peut pas être placé et la fonction se termine.

Qu'est-ce que tu penses? Avez-vous en quelque sorte compris la fonction récursive? Pour être honnête, il n'y a que 8 carrés dans les directions verticale et horizontale, il n'est donc pas nécessaire d'en faire une fonction récursive, mais en plus du fait que le code est susceptible d'être redondant, cette idée peut être un peu difficile compte tenu du point où elle peut être appliquée. J'ai essayé d'utiliser une fonction récursive.

En passant, avec cette fonction, cela peut être une fourmi de transformer le cadre dans la direction spécifiée en une chaîne de caractères et de le rechercher avec «^ ○ + ●» dans l'expression régulière et de le remplacer. J'y ai pensé, mais ce n'était pas amusant en programmation, alors je l'ai laissé tomber.

    #Traitement pour placer le coup suivant (y compris le traitement qui ne peut pas être placé)
    def ot_next_onepeace(self,ot_x,ot_y,ot_dir):
        #Lorsque le prochain mouvement dans toutes les directions à partir de votre position est la main opposée et votre propre main
        nx = self.ot_direction[ot_dir][0]
        ny = self.ot_direction[ot_dir][1]

        #Jugement que le coup suivant ne peut pas être placé en premier lieu
        if ( nx < 0 and ot_x == 1 ) or ( ny < 0 and ot_y == 1 ) or ( nx == 1 and ot_x == 8 ) or ( ny == 1 and ot_y == 8 ):
            return -1

        #Obtenez le suivant (la gauche et le haut sont dans la direction négative lorsqu'ils sont vus de votre main)
        nextpeace = self.ot_peace(ot_x+nx,ot_y+ny)

        #Jugement que vous ne pouvez pas le mettre si la main suivante est ...
        if nextpeace == '・' or nextpeace == self.ot_offdef:
            return -1

        #Déterminez s'il y a un voisin à côté
        cx = ot_x+(nx*2)
        cy = ot_y+(ny*2)

        #Jugé qu'il ne peut pas être placé s'il n'y a pas de voisin à côté (si la direction est à gauche ou en haut, jugez l'extrémité gauche et le haut)
        if ( nx < 0 and cx == 0 ) or ( nx > 0 and cx == 9 ) or ( ny < 0 and cy == 0 ) or ( ny > 0 and cy == 9 ):
            return -1

        #Je peux avoir le suivant, alors cherche
        nextnextpeace = self.ot_peace(cx,cy)

        if nextnextpeace == '・' :
            return -1         #Je ne peux pas le retourner Notification

        if nextnextpeace == self.ot_offdef:
            #Enregistrez la position finale qui peut être retournée
            self.ot_lastposX = cx
            self.ot_lastposY = cy
            return 1         #Vous pouvez le retourner Notification

        #Si votre main et votre main continuent, appelez à nouveau votre fonction (récursif)
        return self.ot_next_onepeace(ot_x+nx, ot_y+ny, ot_dir)

Une fonction qui ne retourne qu'une seule image de l'adversaire dans la direction spécifiée (également une fonction récursive)

Oui, cette fonction est à peu près la même que la précédente.

Nous sommes en train de remplacer le cadre de l'adversaire par votre propre cadre dans la direction spécifiée dans le troisième. Cependant, cette fonction remplace également uniquement les cadres à côté des coordonnées X et Y passées en arguments.

Maintenant, retournez-en un et appelez à nouveau votre fonction en décalant les valeurs passées par ot_x et ot_y par un selon les instructions des nombres dans le tableau tapple de la variable dictionnaire. Le processus se termine lorsque les coordonnées à côté correspondent à ot_lastposX et ot_lastposY.

    #Le processus de retourner votre main
    def ot_changepeace(self,ot_x,ot_y,ot_dir):
        #Lorsque le prochain mouvement dans toutes les directions à partir de votre position est la main opposée et votre propre main
        nx = self.ot_direction[ot_dir][0]
        ny = self.ot_direction[ot_dir][1]
        #Retourner le suivant
        nextpeace = self.ot_peace(ot_x+nx,ot_y+ny,self.ot_offdef)

        #Déterminer si le suivant est la position finale
        cx = ot_x+(nx*2)
        cy = ot_y+(ny*2)

        #Fin si à côté du suivant est la position finale
        if cx == self.ot_lastposX and cy == self.ot_lastposY:
            return
        return self.ot_changepeace(ot_x+nx, ot_y+ny, ot_dir)

Je vais vous expliquer les deux dernières fonctions de la classe et terminer

Bien que ce soit une fonction ʻot_peace () `, cette fonction a deux rôles.

1. Renvoie le cadre avec les coordonnées spécifiées comme valeur de retour de la fonction
2. Si un cadre est spécifié dans le troisième argument, le cadre avec les coordonnées spécifiées sera remplacé par le cadre d'argument.

Ce que j'ai trouvé intéressant en Python, c'est que vous pouvez spécifier des valeurs par défaut pour les arguments de fonction et omettre ces arguments. Par conséquent, lorsque vous appelez ʻot_peace () `, il y a des cas où il y a deux arguments et des cas où il y a trois arguments, et le traitement change en fonction des rôles ci-dessus.

Maintenant, la dernière fonction de la classe Othello est la fonction ʻot_display () `pour afficher le tableau. Comme je l'ai dit au début, cette fonction est chargée d'afficher les données stockées dans le tableau ot_bit en carrés 8X8 et d'afficher le nombre de ● et ○.

   #Obtenez la main à la position spécifiée (et réécrivez-la également)
    def ot_peace(self,ot_x,ot_y,ot_chr=None):
        if ot_chr != None:
            self.ot_bit[(ot_y - 1) * 8 + (ot_x - 1)] = ot_chr
        return self.ot_bit[(ot_y-1)*8+(ot_x-1)]

    #Afficher le plateau d'Othello
    def ot_display(self):
        print("Ｘ① ② ③ ④ ⑤ ⑥ ⑦ ⑧")
        for l in range(1,9):
            print("{}".format(l), end='' )
            for c in range(1,9):
                print(" {}".format(self.ot_bit[(l-1)*8+(c-1)]), end='')
            print()
        print("            ○：{}　●：{}".format(self.ot_bit.count('○'),self.ot_bit.count('●')))

Comment était-ce? Le programme apparemment ésotérique de la classe d'Othello ne devient-il pas progressivement plus significatif? ** La bonté de ce programme est qu'il fonctionne pour le moment **. Et l'étape pour améliorer la programmation est de lire le code source des autres, de le modifier, d'ajouter des éléments à votre manière et de jouer avec.

C'est la fin de l'explication du programme, mais après un certain temps, je vais créer un jeu graphique d'Othello en utilisant PyQt5 et je reviendrai ici. D'ici là, amusez-vous bien avec Python! !!

À la prochaine! !!

c u

    print("to be continue...")