写一个经过剪枝后的六子棋决策算法代码

这里是一个简单的六子棋决策算法代码，经过了alpha-beta剪枝优化：

import numpy as np

# 棋盘大小
BOARD_SIZE = 8

# 评估函数中的权重
WEIGHTS = [1, 10, 100, 1000]

# 六个方向
DIRECTIONS = [(0, 1), (1, 0), (1, 1), (1, -1), (0, -1), (-1, 0)]

# alpha-beta剪枝算法
def alpha_beta(board, depth, alpha, beta, maximizing_player):
    # 到达搜索深度或者棋局结束时返回评估值
    if depth == 0 or is_game_over(board):
        return evaluate(board), None

    if maximizing_player:
        # 最大化玩家
        max_eval = float('-inf')
        best_move = None
        for move in get_possible_moves(board):
            new_board = make_move(board, move, 1)
            eval, _ = alpha_beta(new_board, depth - 1, alpha, beta, False)
            if eval > max_eval:
                max_eval = eval
                best_move = move
            alpha = max(alpha, eval)
            if beta <= alpha:
                break
        return max_eval, best_move
    else:
        # 最小化玩家
        min_eval = float('inf')
        best_move = None
        for move in get_possible_moves(board):
            new_board = make_move(board, move, -1)
            eval, _ = alpha_beta(new_board, depth - 1, alpha, beta, True)
            if eval < min_eval:
                min_eval = eval
                best_move = move
            beta = min(beta, eval)
            if beta <= alpha:
                break
        return min_eval, best_move


# 获取可能的落子位置
def get_possible_moves(board):
    moves = []
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            if board[i][j] == 0:
                moves.append((i, j))
    return moves


# 落子
def make_move(board, move, player):
    new_board = np.copy(board)
    new_board[move[0]][move[1]] = player
    return new_board


# 判断是否游戏结束
def is_game_over(board):
    # 横向检查
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE - 5):
            if board[i][j] != 0 and all(board[i][j+k] == board[i][j] for k in range(1, 6)):
                return True

    # 纵向检查
    for i in range(BOARD_SIZE - 5):
        for j in range(BOARD_SIZE):
            if board[i][j] != 0 and all(board[i+k][j] == board[i][j] for k in range(1, 6)):
                return True

    # 斜向检查（右上-左下）
    for i in range(BOARD_SIZE - 5):
        for j in range(BOARD_SIZE - 5):
            if board[i][j] != 0 and all(board[i+k][j+k] == board[i][j] for k in range(1, 6)):
                return True

    # 斜向检查（左上-右下）
    for i in range(BOARD_SIZE - 5):
        for j in range(5, BOARD_SIZE):
            if board[i][j] != 0 and all(board[i+k][j-k] == board[i][j] for k in range(1, 6)):
                return True

    # 棋盘已满
    if np.count_nonzero(board) == BOARD_SIZE ** 2:
        return True

    return False


# 评估函数
def evaluate(board):
    score = 0
    # 横向检查
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE - 5):
            window = [board[i][j+k] for k in range(6)]
            score += evaluate_window(window)

    # 纵向检查
    for i in range(BOARD_SIZE - 5):
        for j in range(BOARD_SIZE):
            window = [board[i+k][j] for k in range(6)]
            score += evaluate_window(window)

    # 斜向检查（右上-左下）
    for i in range(BOARD_SIZE - 5):
        for j in range(BOARD_SIZE - 5):
            window = [board[i+k][j+k] for k in range(6)]
            score += evaluate_window(window)

    # 斜向检查（左上-右下）
    for i in range(BOARD_SIZE - 5):
        for j in range(5, BOARD_SIZE):
            window = [board[i+k][j-k] for k in range(6)]
            score += evaluate_window(window)

    return score


# 评估窗口
def evaluate_window(window):
    score = 0
    player_count = window.count(1)
    opponent_count = window.count(-1)
    empty_count = window.count(0)

    # 判断胜负
    if player_count == 6:
        score += WEIGHTS[3]
    elif opponent_count == 6:
        score -= WEIGHTS[3]

    # 判断四子
    if player_count == 4 and empty_count == 2:
        score += WEIGHTS[2]
    elif opponent_count == 4 and empty_count == 2:
        score -= WEIGHTS[2]

    # 判断三子
    if player_count == 3 and empty_count == 3:
        score += WEIGHTS[1]
    elif opponent_count == 3 and empty_count == 3:
        score -= WEIGHTS[1]

    # 判断二子
    if player_count == 2 and empty_count == 4:
        score += WEIGHTS[0]
    elif opponent_count == 2 and empty_count == 4:
        score -= WEIGHTS[0]

    return score


# 初始化棋盘
board = np.zeros((BOARD_SIZE, BOARD_SIZE))

# 最大化玩家先手
maximizing_player = True

# alpha-beta剪枝搜索
eval, move = alpha_beta(board, 4, float('-inf'), float('inf'), maximizing_player)

print("最佳落子位置：", move)