from graphics import *
from math import *
import numpy as np
 
 
def ai():
 """
 AI计算落子位置
 """
 maxmin(True, DEPTH, -99999999, 99999999)
 return next_point[0], next_point[1]
 
 
def maxmin(is_ai, depth, alpha, beta):
 """
 负值极大算法搜索 alpha + beta剪枝
 """
 # 游戏是否结束 | | 探索的递归深度是否到边界
 if game_win(list1) or game_win(list2) or depth == 0:
  return evaluation(is_ai)
 
 blank_list = list(set(list_all).difference(set(list3)))
 order(blank_list) # 搜索顺序排序 提高剪枝效率
 # 遍历每一个候选步
 for next_step in blank_list[0:60]:
 
  # 如果要评估的位置没有相邻的子， 则不去评估 减少计算
  if not has_neightnor(next_step):
   continue
 
  if is_ai:
   list1.append(next_step)
  else:
   list2.append(next_step)
  list3.append(next_step)
 
  value = -maxmin(not is_ai, depth - 1, -beta, -alpha)
  if is_ai:
   list1.remove(next_step)
  else:
   list2.remove(next_step)
  list3.remove(next_step)
 
  if value > alpha:
   if depth == DEPTH:
    next_point[0] = next_step[0]
    next_point[1] = next_step[1]
   # alpha + beta剪枝点
   if value >= beta:
    return beta
   alpha = value
 return alpha
 
 
def order(blank_list):
 """
 离最后落子的邻居位置最有可能是最优点
 计算最后落子点的8个方向邻居节点
 若未落子，则插入到blank列表的最前端
 :param blank_list: 未落子节点集合
 :return: blank_list
 """
 last_pt = list3[-1]
 # for item in blank_list:
 for i in range(-1, 2):
  for j in range(-1, 2):
   if i == 0 and j == 0:
    continue
   if (last_pt[0] + i, last_pt[1] + j) in blank_list:
    blank_list.remove((last_pt[0] + i, last_pt[1] + j))
    blank_list.insert(0, (last_pt[0] + i, last_pt[1] + j))
 
 
def has_neightnor(pt):
 """
 判断是否有邻居节点
 :param pt: 待评测节点
 :return:
 """
 for i in range(-1, 2):
  for j in range(-1, 2):
   if i == 0 and j == 0:
    continue
   if (pt[0] + i, pt[1] + j) in list3:
    return True
 return False
 
 
def evaluation(is_ai):
 """
 评估函数
 """
 if is_ai:
  my_list = list1
  enemy_list = list2
 else:
  my_list = list2
  enemy_list = list1
 # 算自己的得分
 score_all_arr = [] # 得分形状的位置 用于计算如果有相交 得分翻倍
 my_score = 0
 for pt in my_list:
  m = pt[0]
  n = pt[1]
  my_score += cal_score(m, n, 0, 1, enemy_list, my_list, score_all_arr)
  my_score += cal_score(m, n, 1, 0, enemy_list, my_list, score_all_arr)
  my_score += cal_score(m, n, 1, 1, enemy_list, my_list, score_all_arr)
  my_score += cal_score(m, n, -1, 1, enemy_list, my_list, score_all_arr)
 # 算敌人的得分， 并减去
 score_all_arr_enemy = []
 enemy_score = 0
 for pt in enemy_list:
  m = pt[0]
  n = pt[1]
  enemy_score += cal_score(m, n, 0, 1, my_list, enemy_list, score_all_arr_enemy)
  enemy_score += cal_score(m, n, 1, 0, my_list, enemy_list, score_all_arr_enemy)
  enemy_score += cal_score(m, n, 1, 1, my_list, enemy_list, score_all_arr_enemy)
  enemy_score += cal_score(m, n, -1, 1, my_list, enemy_list, score_all_arr_enemy)
 
 total_score = my_score - enemy_score * 0.1
 return total_score
 
 
def cal_score(m, n, x_decrict, y_derice, enemy_list, my_list, score_all_arr):
 """
 每个方向上的分值计算
 :param m:
 :param n:
 :param x_decrict:
 :param y_derice:
 :param enemy_list:
 :param my_list:
 :param score_all_arr:
 :return:
 """
 add_score = 0 # 加分项
 # 在一个方向上， 只取最大的得分项
 max_score_shape = (0, None)
 
 # 如果此方向上，该点已经有得分形状，不重复计算
 for item in score_all_arr:
  for pt in item[1]:
   if m == pt[0] and n == pt[1] and x_decrict == item[2][0] and y_derice == item[2][1]:
    return 0
 
 # 在落子点 左右方向上循环查找得分形状
 for offset in range(-5, 1):
  # offset = -2
  pos = []
  for i in range(0, 6):
   if (m + (i + offset) * x_decrict, n + (i + offset) * y_derice) in enemy_list:
    pos.append(2)
   elif (m + (i + offset) * x_decrict, n + (i + offset) * y_derice) in my_list:
    pos.append(1)
   else:
    pos.append(0)
  tmp_shap5 = (pos[0], pos[1], pos[2], pos[3], pos[4])
  tmp_shap6 = (pos[0], pos[1], pos[2], pos[3], pos[4], pos[5])
 
  for (score, shape) in shape_score:
   if tmp_shap5 == shape or tmp_shap6 == shape:
    if score > max_score_shape[0]:
     max_score_shape = (score, ((m + (0 + offset) * x_decrict, n + (0 + offset) * y_derice),
            (m + (1 + offset) * x_decrict, n + (1 + offset) * y_derice),
            (m + (2 + offset) * x_decrict, n + (2 + offset) * y_derice),
            (m + (3 + offset) * x_decrict, n + (3 + offset) * y_derice),
            (m + (4 + offset) * x_decrict, n + (4 + offset) * y_derice)),
          (x_decrict, y_derice))
 
 # 计算两个形状相交， 如两个3活 相交， 得分增加 一个子的除外
 if max_score_shape[1] is not None:
  for item in score_all_arr:
   for pt1 in item[1]:
    for pt2 in max_score_shape[1]:
     if pt1 == pt2 and max_score_shape[0] > 10 and item[0] > 10:
      add_score += item[0] + max_score_shape[0]
 
  score_all_arr.append(max_score_shape)
 
 return add_score + max_score_shape[0]
 
 
def game_win(list):
 """
 胜利条件判断
 """
 # for m in range(COLUMN):
 #  for n in range(ROW):
 #   if n < ROW - 4 and (m, n) in list and (m, n + 1) in list and (m, n + 2) in list and (
 #     m, n + 3) in list and (m, n + 4) in list:
 #    return True
 #   elif m < ROW - 4 and (m, n) in list and (m + 1, n) in list and (m + 2, n) in list and (
 #     m + 3, n) in list and (m + 4, n) in list:
 #    return True
 #   elif m < ROW - 4 and n < ROW - 4 and (m, n) in list and (m + 1, n + 1) in list and (
 #     m + 2, n + 2) in list and (m + 3, n + 3) in list and (m + 4, n + 4) in list:
 #    return True
 #   elif m < ROW - 4 and n > 3 and (m, n) in list and (m + 1, n - 1) in list and (
 #     m + 2, n - 2) in list and (m + 3, n - 3) in list and (m + 4, n - 4) in list:
 #    return True
 return False
 
 
def draw_window():
 """
 绘制棋盘
 """
 # 绘制画板
 win = GraphWin("五子棋", GRAPH_HEIGHT, GRAPH_WIDTH)
 win.setBackground("gray")
 # 绘制列
 i1 = 0
 while i1 <= GRID_WIDTH * COLUMN:
  i1 = i1 + GRID_WIDTH
  l = Line(Point(i1, GRID_WIDTH), Point(i1, GRID_WIDTH * COLUMN))
  l.draw(win)
 # 绘制行
 i2 = 0
 while i2 <= GRID_WIDTH * ROW:
  i2 = i2 + GRID_WIDTH
  l = Line(Point(GRID_WIDTH, i2), Point(GRID_WIDTH * ROW, i2))
  l.draw(win)
 return win
 
 
def main():
 """
 程序循环
 :return:
 """
 mode = int(input("先手 AI先手 "))
 # 绘制棋盘
 win = draw_window()
 # 添加棋盘所有点
 for i in range(COLUMN + 1):
  for j in range(ROW + 1):
   list_all.append((i, j))
 # 循环条件
 g = 0
 change = 0
 # 开始循环
 while g == 0:
  # AI
  if change % 2 == mode:
   # AI先手 走天元
   if change == 0:
    pos = (6, 6)
   else:
    pos = ai()
   # 添加落子
   list1.append(pos)
   list3.append(pos)
   # 绘制白棋
   piece = Circle(Point(GRID_WIDTH * (pos[0]), GRID_WIDTH * (pos[1])), 12)
   piece.setFill('white')
   piece.draw(win)
   # AI胜利
   if game_win(list1):
    message = Text(Point(GRAPH_WIDTH / 2, GRID_WIDTH / 2), "AI获胜")
    message.draw(win)
    g = 1
   change = change + 1
 
  # User
  else:
   p2 = win.getMouse()
   x = round((p2.getX()) / GRID_WIDTH)
   y = round((p2.getY()) / GRID_WIDTH)
 
   # 若点未被选取过
   if not (x, y) in list3:
    # 添加落子
    list2.append((x, y))
    list3.append((x, y))
    # 绘制黑棋
    piece = Circle(Point(GRID_WIDTH * x, GRID_WIDTH * y), 12)
    piece.setFill('black')
    piece.draw(win)
    # 胜利
    if game_win(list2):
     message = Text(Point(GRAPH_WIDTH / 2, GRID_WIDTH / 2), "人类胜利")
     message.draw(win)
     g = 1
    change = change + 1
 
 message = Text(Point(GRAPH_WIDTH / 2 + 100, GRID_WIDTH / 2), "游戏结束")
 message.draw(win)
 win.getMouse()
 win.close()
 
 
if __name__ == '__main__':
 GRID_WIDTH = 40
 COLUMN = 11
 ROW = 11
 GRAPH_WIDTH = GRID_WIDTH * (ROW + 1)
 GRAPH_HEIGHT = GRID_WIDTH * (COLUMN + 1)
 
 list1 = [] # AI
 list2 = [] # human
 list3 = [] # all
 list_all = [] # 整个棋盘的点
 next_point = [0, 0] # AI下一步最应该下的位置
 
 mode=int(input("请选择: 快不准 或 慢却准 "))
 if mode==1:
  DEPTH=1
 elif mode==0:
  DEPTH=3
 else:
  DEPTH=3
 
 shape_score = [(50, (0, 1, 1, 0, 0)),
     (50, (0, 0, 1, 1, 0)),
     (200, (1, 1, 0, 1, 0)),
     (500, (0, 0, 1, 1, 1)),
     (500, (1, 1, 1, 0, 0)),
     (5000, (0, 1, 1, 1, 0)),
     (5000, (0, 1, 0, 1, 1, 0)),
     (5000, (0, 1, 1, 0, 1, 0)),
     (5000, (1, 1, 1, 0, 1)),
     (5000, (1, 1, 0, 1, 1)),
     (5000, (1, 0, 1, 1, 1)),
     (5000, (1, 1, 1, 1, 0)),
     (5000, (0, 1, 1, 1, 1)),
     (50000, (0, 1, 1, 1, 1, 0)),
     (99999999, (1, 1, 1, 1, 1))]
 main()