So implementieren Sie ein dreiteiliges Schachspiel in Python

1. Grundlegender Prozess

Die Implementierungslogik des dreiteiligen Schachspiels ist wie folgt:

1. Erstellen Sie ein initialisiertes 3*3-Schachbrett; 🎜🎜#2. Der Spieler führt U T-Stück aus, bewegt das Stück zuerst;
3 Bestimmen Sie das Ergebnis [gewinnen, verlieren, unentschieden], wenn das Ergebnis nicht entschieden ist, fahren Sie wie folgt fort
4 . Der Computer hält das T-Stück und bewegt es. Bestimmen Sie das Ergebnis. Fahren Sie mit Schritt 2 fort.
#🎜🎜 🎜#
1. Menüoberfläche

#🎜🎜 #Wählen Sie 1, um das Spiel zu starten, wählen Sie 2, um das Spiel zu beenden

def menu():
    print('-'*20)
    print('1---------------begin')
    print('2---------------exit')
    print('please select begin or exit')
    print('-' * 20)
    while(1):
        select = input('please input:')
        if select == '1':
            begin_games()
            pass
        elif select == '2':
            print('exit the game')
            break
            #pass
    pass

2. Initialisieren Sie das Schachbrett und drucken Sie es aus. 🎜🎜#

Das dreiteilige Schachbrett ist eine 3*3-Quadratmatrix, in Python werden Listen zur Speicherung verwendet.

chess_board = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

Wie druckt man also diese Speicherliste aus und verwandelt sie in ein Schachbrett?

def init_cheaa_board(chess_board): #先对列表进行初始化
    for i in range(MAX_ROW):
        for j in range(MAX_COL):
            chess_board[i][j] = ' '
    pass

def print_chess_board(chess_board): #棋盘打印
    print('*'+'-'*7+'*'+'-'*7+'*'+'-'*7+'*')
    for i in range(MAX_ROW):
        print('|'+' '*3+chess_board[i][0]+' '*3+'|'+' '*3+chess_board[i][1]+' '*3+'|'+' '*3+chess_board[i][2]+' '*3+'|')
        print('*' + '-' * 7 + '*' + '-' * 7 + '*' + '-' * 7 + '*')
        pass
    pass

3 Der Spieler wählt die horizontalen und vertikalen Koordinaten des Zuges auf dem 3*3-Schachbrett. Der Koordinatenpunkt muss die folgenden Anforderungen erfüllen: 1. Der Punkt liegt innerhalb des Schachbretts. 2. Der Punkt wurde noch nicht platziert.

def player_first(chess_board):
    while(1):
        x = int(input('please input x:'))
        y = int(input('please input y:'))
        if(chess_board[x][y] != ' '): #若已被置子，则重新选择坐标
            print('This position is already occupied!')
            pass
        elif(x >= MAX_ROW or y >= MAX_COL or x < 0 or y < 0): #所选坐标超出棋盘范围，重新选择坐标
            print(&#39;This position is beyond the chessboard!&#39;)
            pass
        else: #若坐标可以落子，则将该坐标置为玩家的棋子U
            chess_board[x][y] = &#39;U&#39;
            print_chess_board(chess_board)
            #return x,y
            break
            pass
    pass

4. Computerzug

Computerzugalgorithmus:

4.1 Überprüfen Sie zunächst, ob bereits Schachfiguren besetzt sind der Computer Der Zustand, in dem zwei Figuren verbunden sind und eine Schachfigur bilden. Wenn es bereits existiert, holen Sie sich den Koordinatenpunkt, der den Sieg fördern kann, und machen Sie einen Zug. Wenn 4.1 nicht erfüllt ist, überprüfen Sie das Schachbrett erneut, um zu sehen, ob sich bereits zwei Spieler auf dem Schachbrett befinden . Der Zustand, in dem die Figuren verbunden sind und im Begriff sind, eine Schachfigur zu werden. Wenn es bereits existiert, ermitteln Sie den Koordinatenpunkt, an dem der Spieler gewinnen wird, und bewegen Sie das T zum Abfangen. Wenn weder 4.1 noch 4.2 erfüllt sind, wählen Sie einen günstigen Punkt auf der Computerseite aus auf dem Schachbrett, um den Zug auszuführen;

A. Bestimmen Sie zunächst, ob die Mittelposition [1][1] besetzt ist. Wenn nicht, ist dies der vorteilhafteste Punkt. Wenn der Punkt [1][1] besetzt ist, sind die vier horizontalen, vertikalen, diagonalen und subdiagonalen Linien des Spielers blockiert.

B, der sekundäre vorteilhafte Punkt sind jeweils die vier Linien des 3*3-Bretts Eine besetzte Ecke blockiert die drei Linien des Spielers. Der letzte vorteilhafte Punkt ist die Mitte jeder Seite, wodurch die beiden Linien des Spielers blockiert werden

Endergebnis: Verlieren, gewinnen, Unentschieden D

Bestimmungsprozess: Bestimmen Sie, ob sich Spieler U auf jeder horizontalen Linie, vertikalen Linie und diagonalen Linie befindet oder ob der Computer T drei Teile in a bildet Wenn ja, gewinnt diese Seite; wenn die gesamte Schachfläche besetzt ist, aber weder der Spieler noch der Computer eine Schachfigur gebildet hat, bedeutet dies ein Unentschieden.

def Intercept_player(chess_board,key):
    count2 = 0
    index2 = []
    intercept_index = {'x':-1,'y':-1}
    for i in range(MAX_ROW):
        index = []
        count = 0
        count1 = 0
        index1 = []
        allindex = [0,1,2]
        for j in range(MAX_ROW):
            if(chess_board[i][j] == key): #每一行的玩家落子情况
                count += 1
                index.append(j)
            if(chess_board[j][i] == key): #每一列的玩家落子情况
                #print('j'+str(j)+',i'+str(i)+'='+chess_board[j][i])
                count1 += 1
                index1.append(j)
            if (i == j and chess_board[j][i] == key):  # 在主对角线中的玩家落子情况
                count2 += 1
                index2.append(j)
        if(count == 2):    #在每一行中  获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
            result = list(set(allindex).difference(set(index)))
            result = result[0]
            if(chess_board[i][result] == ' '): #当这个位置可以进行拦截时，进行坐标返回
                #return i,result
                intercept_index['x'] = i
                intercept_index['y'] = result
                return intercept_index
        #print(count1,'------->',index1)
        if (count1 == 2):  # 在每一列中 获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
            result = list(set(allindex).difference(set(index1)))
            result = result[0]
            #print('count1==2,result:',result)
            if (chess_board[result][i] == ' '):  # 当这个位置可以进行拦截时，进行坐标返回
                intercept_index['x'] = result
                intercept_index['y'] = i
                return intercept_index
                #return i, result
        if (count2 == 2):  # 在主对角线上 获取具体的可以拦截的位置坐标  需要排除掉已经填充的位置
            result = list(set(allindex).difference(set(index2)))
            result = result[0]
            if (chess_board[i][result] == ' '):  # 当这个位置可以进行拦截时，进行坐标返回
                intercept_index['x'] = i
                intercept_index['y'] = result
                return intercept_index
                #return i, result
    count3 = 0
    if(chess_board[0][2] == key):
        count3 += 1
    if (chess_board[1][1] == key):
        count3 += 1
    if (chess_board[2][0] == key):
        count3 += 1
    if(count3 == 2):
        if(chess_board[0][2] == ' '):
            intercept_index['x'] = 0
            intercept_index['y'] = 2

        elif (chess_board[1][1] == ' '):
            intercept_index['x'] = 1
            intercept_index['y'] = 1

        elif (chess_board[2][0] == ' '):
            intercept_index['x'] = 2
            intercept_index['y'] = 0
    return intercept_index
    
def computer_second(chess_board):  #电脑智能出棋
    #1、先检查一下电脑是否两子成棋  若已有，则获取空位置坐标 自己先成棋
    intercept_index = Intercept_player(chess_board, 'T')
    if (intercept_index['x'] == -1 and intercept_index['y'] == -1):
        pass
    else:  # 电脑可落子
        x = intercept_index['x']
        y = intercept_index['y']
        chess_board[x][y] = 'T'
        return
    #2、若玩家快成棋   则先进行拦截
    intercept_index = Intercept_player(chess_board,'U')   #若玩家已经两子成棋  则获取空位置的坐标
    #print('intercept_index---:')
    #print(intercept_index)
    if(intercept_index['x'] == -1 and intercept_index['y'] == -1):
        pass
    else:  #电脑可落子
        x = intercept_index['x']
        y = intercept_index['y']
        chess_board[x][y] = 'T'
        return
    #3、如果没有，则电脑端排棋  以促进成棋
    #3.1、 占领中心位置  如若中心位置[1,1]未被占领
    if(chess_board[1][1] == ' '):
        chess_board[1][1] = 'T'
        return
    #3.2、 占领四角位置  若[0,0]  [0,2]  [2,0]  [2,2]未被占领
    if (chess_board[0][0] == ' '):
        chess_board[0][0] = 'T'
        return
    if (chess_board[0][2] == ' '):
        chess_board[0][2] = 'T'
        return
    if (chess_board[2][0] == ' '):
        chess_board[2][0] = 'T'
        return
    if (chess_board[2][2] == ' '):
        chess_board[2][2] = 'T'
        return
    # 3.3、 占领每一边中心位置  若[0,1]  [1,0]  [1,2]  [2,1]未被占领
    if (chess_board[0][1] == ' '):
        chess_board[0][1] = 'T'
        return
    if (chess_board[1][0] == ' '):
        chess_board[1][0] = 'T'
        return
    if (chess_board[1][2] == ' '):
        chess_board[1][2] = 'T'
        return
    if (chess_board[2][1] == ' '):
        chess_board[2][1] = 'T'
        return

3. Gesamtcode

def chess_board_isfull(chess_board):   #判断棋盘是否填充满
    for i in range(MAX_ROW):
        if (' ' in chess_board[i]):
            return 0
    return 1
    pass
    
def Win_or_lose(chess_board):
    isfull = chess_board_isfull(chess_board)
    for i in range(MAX_ROW):  #每一列的判断
        if( chess_board[0][i] == chess_board[1][i] == chess_board[2][i]):
            return chess_board[0][i]
            pass
        pass

    for i in range(MAX_ROW):  # 每一行的判断
        if( chess_board[i][0] == chess_board[i][1] == chess_board[i][2]):
            return chess_board[i][0]
            pass
        pass

    if (chess_board[0][0] == chess_board[1][1] == chess_board[2][2]):  # 判断棋盘正对角线
        return chess_board[0][0]

    if (chess_board[0][2] == chess_board[1][1] == chess_board[2][0]):  # 判断棋盘反对角线
        return chess_board[0][2]

    if isfull:
        return 'D'  # 经过以上的判断，都不满足(既没赢也没输)，但是棋盘也已经填充满，则说明和棋
    else:
        return ' '

4. Ergebnisanzeige

4.1 In den folgenden Screenshots wird gezeigt, dass der Computer a abfängt günstige Position und der Prozess, die Führung auf dem Weg zum Schachspieler zu übernehmen

Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein dreiteiliges Schachspiel in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!