简单四子棋程序

 AI 就忽略吧， 这个版本的程序还没做出来。。。。。。

import copy
import random

situation = []
row = 7
column = 5
situation = [[0 for j in range(column)] for i in range(row)]
situation[-1] = [3 for j in range(column)]


class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'


def play(time, max_column=column):  # 落子
    global times
    if time % 2 == 0:
        player = 2
    else:
        player = 1
    while 1:
        while 1:  # inputing
            try:
                column = int(input('PLZ INPUT column'))
                if -1 < column < max_column:
                    break
                else:
                    print(bcolors.FAIL+'IndexError: list index out of range'+bcolors.ENDC)
            except:
                print(bcolors.FAIL+'wrong input'+bcolors.ENDC)
                column = int(input('PLZ INPUT column'))

        try:
            for i in range(row):
                if situation[i][column] == 3:
                    situation[i][column] = player
                    break
            break
        except:
            print('index error')

    times = time+1


class AI():
    def detect_will_win(row=row, column=column):  # ——检测
        Win = False
        winner = None
        type = None
        row_win = None
        win_column = None
        for i in range(row):
            for j in range(column-2):
                counter1 = 0
                counter2 = 0
                for increment in range(3):
                    if situation[i][j+increment]==1:
                        counter1+=1
                    if situation[i][j+increment]==2:
                        counter2+=1
                if counter1 == 3:
                    Win=True
                    winner = 1
                    type = 'horizontal'
                    row_win, win_column = i, j
                if counter2 == 3:
                    Win=True
                    winner = 2
                    type = 'horizontal'
                    row_win, win_column = i, j


        for i in range(row-2):  # | 检测
            for j in range(column):
                counter1 = 0
                counter2 = 0
                for increment in range(3):
                    if situation[i+increment][j]==1:
                        counter1+=1
                    if situation[i+increment][j]==2:
                        counter2+=1
                if counter1 == 3:
                    Win=True
                    winner = 1
                    type = 'verticle'
                    row_win, win_column = i, j
                if counter2 == 3:
                    Win=True
                    winner = 2
                    type = 'verticle'
                    row_win, win_column = i, j


        for i in range(row-2):  # / 检测
            for j in range(2,column):
                counter1 = 0
                counter2 = 0
                for increment in range(3):
                    if situation[i+increment][j-increment]==1:
                        counter1+=1
                    if situation[i+increment][j-increment]==2:
                        counter2+=1
                if counter1 == 3:
                    Win=True
                    winner = 1
                    type = 'left oblique'
                    row_win, win_column = i, j
                if counter2 == 3:
                    Win=True
                    winner = 2
                    type = 'left oblique'  
                    row_win, win_column = i, j  


        for i in range(row-2):  # \ 检测
            for j in range(column-2):
                counter1 = 0
                counter2 = 0
                for increment in range(3):
                    if situation[i+increment][j+increment]==1:
                        counter1+=1
                    if situation[i+increment][j+increment]==2:
                        counter2+=1
                if counter1 == 3:
                    Win=True
                    winner = 1
                    type = 'right oblique'
                    row_win, win_column = i, j
                if counter2 == 3:
                    Win=True
                    winner = 2 
                    type = 'right oblique'
                    row_win, win_column = i, j
        return Win, winner, type, row_win, win_column
    

    def predict_play(time , column2, max_column=column):  # 落子_fake
        if time % 2 == 0:
            player = 2
        else:
            player = 1

        for i in range(row):
            try:
                if situation2[i][column2] == 3:
                    situation2[i][column2] = player
                    opperation.append([i,column2])

            except IndexError:
                print(i, column2)


    def predict_detect_space(row=row, column=column):  # 模拟检测
        find = False
        for j in range(column):
            for i in range(row):
                if situation2[i][j] == 1 or situation2[i][j] == 2:
                    try:
                        situation2[i-1][j]= 3
                        find=True
                        break
                    except IndexError:
                        break
        if find==False:
            return find, j


    def AI_predict(row=row, column=column):
        global situation2
#        situation2 = copy.deepcopy(situation)
#        times2 = 0
#        Win_1 = False
#        times_predict = 100
#        win_list = []
#        for i in range(times_predict):
#            oppertion = []
#            situation2 = copy.deepcopy(situation)
#            for i2 in range(100):
#                column1 = random.randint(0,column-1)
#                AI.predict_play(times2, column1)
#                times2 += 1
#                AI.predict_detect_space()
#                fakewin, fake_winner = AI.detect_win()
#
#                if fakewin:
#                    win_list.append(opperation)
#                    break
#        print(win_list)
        # 3子检测
        win_column = None
        Win_will, winner_will, type, win_row, win_column = AI.detect_will_win()
        if Win_will:
            if winner_will == 2 or winner_will == 1:
                try:
                    print('要赢', type)                            
                    win_row, win_column = AI.detect_if_can_win(type, win_row, win_column)
                except Exception as e:
                    print(e)
                    win_column = random.randint(0, column)
        return win_column

    def detect_if_can_win(type, win_row, win_column):
        if type == 'horizontal':
            if situation[win_row][win_column-1] == 3:
                return win_row, win_column-1
            if situation[win_row][win_column+3] == 3:
                return win_row, win_column+3

        if type == 'verticle':
            if situation[win_row-1][win_column] == 3:
                return win_row-1, win_column  
            if situation[win_row+3][win_column] == 3:
                return win_row+3, win_column

        if type == 'left oblique':
            if situation[win_row-1][win_column+1] == 3:
                return win_row-1, win_column-1 
            if situation[win_row+3][win_column-3] == 3:
                return win_row+3, win_column-3         

        if type == 'right oblique':
            if situation[win_row-1][win_column-1] == 3:
                return win_row-1, win_column+3 
            if situation[win_row+3][win_column+3] == 3:
                return win_row+1, win_column+3  

    def AI_play():
        final_column = AI.AI_predict()
        if final_column == None:
            final_column = random.randint(0,column-1)
            print('random choosing')
        player = 2
        error_counter = 0
        for i in range(100):

            try:
                for i in range(row):
                    if situation[i][final_column] == 3:
                        situation[i][final_column] = player
                        break
            except:
                error_counter += 1
                final_column = random.randint(0, column)
        if error_counter > 99:
            print('已满，平局')


    def detect_win(row=row, column=column):  # ——检测
        Win = False
        winner = None
        for i in range(row):
            for j in range(column-3):
                counter1 = 0
                counter2 = 0
                for increment in range(4):
                    if situation[i][j+increment]==1:
                        counter1+=1
                    if situation[i][j+increment]==2:
                        counter2+=1
                if counter1 == 4:
                    Win=True
                    winner = 1
                if counter2 == 4:
                    Win=True
                    winner = 2


        for i in range(row-3):  # | 检测
            for j in range(column):
                counter1 = 0
                counter2 = 0
                for increment in range(4):
                    if situation[i+increment][j]==1:
                        counter1+=1
                    if situation[i+increment][j]==2:
                        counter2+=1
                if counter1 == 4:
                    Win=True
                    winner = 1
                if counter2 == 4:
                    Win=True
                    winner = 2


        for i in range(row-3):  # / 检测
            for j in range(3,column):
                counter1 = 0
                counter2 = 0
                for increment in range(4):
                    if situation[i+increment][j-increment]==1:
                        counter1+=1
                    if situation[i+increment][j-increment]==2:
                        counter2+=1
                if counter1 == 4:
                    Win=True
                    winner = 1
                if counter2 == 4:
                    Win=True
                    winner = 2    


        for i in range(row-3):  # \ 检测
            for j in range(column-3):
                counter1 = 0
                counter2 = 0
                for increment in range(4):
                    if situation[i+increment][j+increment]==1:
                        counter1+=1
                    if situation[i+increment][j+increment]==2:
                        counter2+=1
                if counter1 == 4:
                    Win=True
                    winner = 1
                if counter2 == 4:
                    Win=True
                    winner = 2 
        return Win, winner


def detect_space(row=row, column=column):  # 检测可落子区域
    find = False
    for j in range(column):
        for i in range(row):
            if situation[i][j] == 1 or situation[i][j] == 2:
                try:
                    situation[i-1][j]= 3
                    find=True
                    break
                except IndexError:
                    print(j, '已经满了')
                    break
    if find==False:
        return find, j
def virtualise():
    for row in situation:
        for column in row:
            if column == 1:
                print(bcolors.HEADER + str(column) +bcolors.ENDC, end='  ')
            elif column == 2:
                print(bcolors.FAIL + str(column) +bcolors.ENDC, end='  ')
            else:
                print(column,end='  ')
        print('')
    print('\n')


def detect_win(row=row, column=column):  # ——检测
    Win = False
    winner = None
    for i in range(row):
        for j in range(column-3):
            counter1 = 0
            counter2 = 0
            for increment in range(4):
                if situation[i][j+increment]==1:
                    counter1+=1
                if situation[i][j+increment]==2:
                    counter2+=1
            if counter1 == 4:
                Win=True
                winner = 1
            if counter2 == 4:
                Win=True
                winner = 2


    for i in range(row-3):  # | 检测
        for j in range(column):
            counter1 = 0
            counter2 = 0
            for increment in range(4):
                if situation[i+increment][j]==1:
                    counter1+=1
                if situation[i+increment][j]==2:
                    counter2+=1
            if counter1 == 4:
                Win=True
                winner = 1
            if counter2 == 4:
                Win=True
                winner = 2


    for i in range(row-3):  # / 检测
        for j in range(3,column):
            counter1 = 0
            counter2 = 0
            for increment in range(4):
                if situation[i+increment][j-increment]==1:
                    counter1+=1
                if situation[i+increment][j-increment]==2:
                    counter2+=1
            if counter1 == 4:
                Win=True
                winner = 1
            if counter2 == 4:
                Win=True
                winner = 2    
    

    for i in range(row-3):  # \ 检测
        for j in range(column-3):
            counter1 = 0
            counter2 = 0
            for increment in range(4):
                if situation[i+increment][j+increment]==1:
                    counter1+=1
                if situation[i+increment][j+increment]==2:
                    counter2+=1
            if counter1 == 4:
                Win=True
                winner = 1
            if counter2 == 4:
                Win=True
                winner = 2 
    return Win, winner



Win = False
times = 1
mode = int(input('Do you want to play with machine? \n if yes please input 1 ,no input 0\n'))
opperation = []
situation2 = []
while Win != True and mode == 0:
    play(times)
    detect_space()
    Win, winner = detect_win()
    virtualise()



print('congradulation! Winner is '+bcolors.WARNING + str(winner) + bcolors.UNDERLINE)