import pygame
from copy import copy
from os import _exit  # 退出
from collections import Counter as aniSet  # 490行
import win32api  # 鼠标类操作、屏幕
import win32con  # 鼠标类操作、屏幕

pygame.init()
# 主界面
pygame.display.set_mode((1200, 600))
menu_image = pygame.image.load("./mainGround.png")
menu_image = pygame.transform.scale(menu_image, (1200, 600))
flag = True
while flag:
    for event in pygame.event.get():
        x, y = pygame.mouse.get_pos()
        if pygame.mouse.get_pressed()[0] and 500 <= x <= 900 and 300 <= y <= 500:
            flag = False
    menu = pygame.display.get_surface()
    menu.blit(menu_image, (0, 0))
    pygame.display.update()
# 获取屏幕大小
sizel = 0.8
size = width, height = win32api.GetSystemMetrics(win32con.SM_CXSCREEN) * sizel, win32api.GetSystemMetrics(
    win32con.SM_CYSCREEN) * sizel
# 满屏推算棋格大小
ul = 135 * height // 1080
# 特殊区域
river = [(3, 1), (3, 2), (3, 4), (3, 5),
         (4, 1), (4, 2), (4, 4), (4, 5),
         (5, 1), (5, 2), (5, 4), (5, 5)]
# 陷阱
Blue_trap = [(0, 2), (0, 4), (1, 3)]
Red_trap = [(8, 2), (8, 4), (7, 3)]
rd = 0
# 穴
Blue_home = [(0, 3)]
Red_home = [(8, 3)]
# 是否可走
Blue_way = 0
Red_way = 0


def get_rect(i, pos):  # 定位
    j = i.get_rect()
    j.left, j.top = pos
    return j


def is_chess_in_board(x, y):  # 在棋盘里
    return 0 <= x < 9 and 0 <= y < 7


def tryout():
    global movable, win, rd, Blue_way, Red_way
    movable = True  # 判断移动变量
    win = 0  # 胜负判断变量：初始为0，为1时红方胜，为2时蓝方胜
    rd = 0  # 回合计数变量
    Blue_way = 0  # 蓝方总可走位置数目
    Red_way = 0  # 红方总可走位置数目
    # 对方进入洞穴判胜负
    if grid[0][3]:
        if grid[0][3].camp == 1:
            movable = False
            win = 1
    if grid[8][3]:
        if grid[8][3].camp == 0:
            movable = False
            win = 2

    if rd == 100:  # 回合数为100时不能继续移动
        movable = False
    # 遍历双方可走位置总数
    for i in range(7):
        for j in range(9):
            if grid[i][j]:
                if grid[i][j].camp == 0:
                    Blue_way += len(grid[i][j].next)
                else:
                    Red_way += len(grid[i][j].next)

    if Blue_way == 0:
        win = 1
        movable = False
    if Red_way == 0:
        win = 2
        movable = False


def refresh():  # 继续
    for i in grid:
        for j in i:
            if j:
                j.next_step(grid)


class Base:  # 定义棋子的类
    def __init__(self, camp, b, r, Rank):  # 初始化：camp为阵营，camp=1红方，camp=0蓝方
        self.camp = camp  # Rank为吃子顺序，从0到6依次为鼠、鹰、狐、狼、豹、狮、象
        if self.camp:  # camp=1，红方
            self.img = r
        else:
            self.img = b
        self.rank = Rank
        self.x = self.y = 0
        self.next = []  # 可走位置的集合
        self.eat = []  # 可吃位置的集合
        self.pro = []  # 不可走位置的集合

    def hint(self):  # 显示可走路径
        for i, j in self.next:
            htrect.center = pos[i][j].center
            screen.blit(ht, htrect)
        for i, j in self.eat:
            screen.blit(cpht, pos[i][j])

    def next_step(self, grid):  # 步法
        pass

    def eagle_next(self, grid):  # 老鹰走法
        for i in range(self.x + 1, 9):  # 向右飞
            if grid[i][self.y]:
                if grid[i][self.y].camp != self.camp and (grid[i][self.y].rank <= self.rank or
                                                          (((i, self.y) in Blue_trap or (i, self.y) in Red_trap) and grid[i][
                                                              self.y].camp == 1) or
                                                          (((i, self.y) in Blue_trap or (i, self.y) in Red_trap) and grid[i][
                                                              self.y].camp == 0)) and (i, self.y) not in river:
                    self.eat.append([i, self.y])
                else:
                    self.pro.append([i, self.y])
                break
            if (i, self.y) in Blue_trap or (i, self.y) in Red_trap:
                self.next.append([i, self.y])
                break
            # 判断老鹰不能进河不能进入本方兽穴
            if (i, self.y) not in river and (
                    ((i, self.y) not in Blue_home and self.camp == 0) or ((i, self.y) not in Red_home and self.camp == 1)):
                self.next.append([i, self.y])

        for i in range(self.x - 1, -1, -1):  # 向左飞
            if grid[i][self.y]:
                if grid[i][self.y].camp != self.camp and (grid[i][self.y].rank <= self.rank or
                                                          (((i, self.y) in Blue_trap or (i, self.y) in Red_trap) and grid[i][
                                                              self.y].camp == 1) or
                                                          (((i, self.y) in Blue_trap or (i, self.y) in Red_trap) and grid[i][
                                                              self.y].camp == 0)) and (i, self.y) not in river:
                    self.eat.append([i, self.y])
                else:
                    self.pro.append([i, self.y])
                break
            if (i, self.y) in Blue_trap or (i, self.y) in Red_trap:
                self.next.append([i, self.y])
                break
            if (i, self.y) not in river and (
                    ((i, self.y) not in Blue_home and self.camp == 0) or ((i, self.y) not in Red_home and self.camp == 1)):
                self.next.append([i, self.y])

        for i in range(self.y + 1, 7):  # 向上飞
            if grid[self.x][i]:
                if grid[self.x][i].camp != self.camp and (grid[self.x][i].rank <= self.rank or
                                                          (((self.x, i) in Blue_trap or (self.x, i) in Red_trap) and
                                                           grid[self.x][i].camp == 1) or
                                                          (((self.x, i) in Blue_trap or (self.x, i) in Red_trap) and
                                                           grid[self.x][i].camp == 0)) and (self.x, i) not in river:
                    self.eat.append([self.x, i])
                else:
                    self.pro.append([self.x, i])
                break
            if (self.x, i) in Blue_trap or (self.x, i) in Red_trap:
                self.next.append([self.x, i])
                break
            if (self.x, i) not in river and (
                    ((self.x, i) not in Blue_home and self.camp == 0) or ((self.x, i) not in Red_home and self.camp == 1)):
                self.next.append([self.x, i])

        for i in range(self.y - 1, -1, -1):  # 向下飞
            if grid[self.x][i]:
                if grid[self.x][i].camp != self.camp and (grid[self.x][i].rank <= self.rank or
                                                          (((self.x, i) in Blue_trap or (self.x, i) in Red_trap) and
                                                           grid[self.x][i].camp == 1) or
                                                          (((self.x, i) in Blue_trap or (self.x, i) in Red_trap) and
                                                           grid[self.x][i].camp == 0)) and (self.x, i) not in river:
                    self.eat.append([self.x, i])
                else:
                    self.pro.append([self.x, i])
                break
            if (self.x, i) in Blue_trap or (self.x, i) in Red_trap:
                self.next.append([self.x, i])
                break
            if (self.x, i) not in river and (
                    ((self.x, i) not in Blue_home and self.camp == 0) or ((self.x, i) not in Red_home and self.camp == 1)):
                self.next.append([self.x, i])

    def lion_next(self, grid):  # 狮子跳河
        tx, ty = self.x, self.y
        i = 1  # 向右走
        if is_chess_in_board(tx + i, ty):
            while (tx + i, ty) in river:
                if grid[tx + i][ty]:
                    break
                i += 1

            if grid[tx + i][ty]:
                if grid[tx + i][ty].camp != self.camp and (grid[tx + i][ty].rank <= self.rank or
                                                           (((tx + i, ty) in Blue_trap or (tx + i, ty) in Red_trap) and
                                                            grid[tx + i][ty].camp == 1) or
                                                           (((tx + i, ty) in Blue_trap or (tx + i, ty) in Red_trap) and
                                                            grid[tx + i][ty].camp == 0)) and (tx + i, ty) not in river:
                    self.eat.append([tx + i, ty])
                else:
                    self.pro.append([tx + i, ty])
            # 判断狮子不能进入己方洞穴
            elif ((tx + i, ty) not in Blue_home and self.camp == 0) or ((tx + i, ty) not in Red_home and self.camp == 1):
                self.next.append([tx + i, ty])

        i = -1  # 向左走
        if is_chess_in_board(tx + i, ty):
            while (tx + i, ty) in river:

                if grid[tx + i][ty]:
                    break
                i -= 1
            if grid[tx + i][ty]:
                if grid[tx + i][ty].camp != self.camp and (grid[tx + i][ty].rank <= self.rank or
                                                           (((tx + i, ty) in Blue_trap or (tx + i, ty) in Red_trap) and
                                                            grid[tx + i][ty].camp == 1) or
                                                           (((tx + i, ty) in Blue_trap or (tx + i, ty) in Red_trap) and
                                                            grid[tx + i][ty].camp == 0)) and (tx + i, ty) not in river:
                    self.eat.append([tx + i, ty])
                else:
                    self.pro.append([tx + i, ty])
            elif ((tx + i, ty) not in Blue_home and self.camp == 0) or ((tx + i, ty) not in Red_home and self.camp == 1):
                self.next.append([tx + i, ty])

        i = 1  # 向上走
        if is_chess_in_board(tx, ty + i):
            while (tx, ty + i) in river:

                if grid[tx][ty + i]:
                    break
                i += 1
            if grid[tx][ty + i]:
                if grid[tx][ty + i].camp != self.camp and (grid[tx][ty + i].rank <= self.rank or
                                                           (((tx, ty + i) in Blue_trap or (tx, ty + i) in Red_trap) and
                                                            grid[tx][ty + i].camp == 1) or
                                                           (((tx, ty + i) in Blue_trap or (tx, ty + i) in Red_trap) and
                                                            grid[tx][ty + i].camp == 0)) and (tx, ty + i) not in river:
                    self.eat.append([tx, ty + i])
                else:
                    self.pro.append([tx, ty + i])
            elif (((tx, ty + i) not in Blue_home and self.camp == 0) or ((tx, ty + i) not in Red_home and self.camp == 1)):
                self.next.append([tx, ty + i])

        i = -1  # 向下走
        if is_chess_in_board(tx, ty + i):
            while (tx, ty + i) in river:

                if grid[tx][ty + i]:
                    break
                i -= 1
            if grid[tx][ty + i]:
                if grid[tx][ty + i].camp != self.camp and (grid[tx][ty + i].rank <= self.rank or
                                                           (((tx, ty + i) in Blue_trap or (tx, ty + i) in Red_trap) and
                                                            grid[tx][ty + i].camp == 1) or
                                                           (((tx, ty + i) in Blue_trap or (tx, ty + i) in Red_trap) and
                                                            grid[tx][ty + i].camp == 0)) and (tx, ty + i) not in river:
                    self.eat.append([tx, ty + i])
                else:
                    self.pro.append([tx, ty + i])
            elif (((tx, ty + i) not in Blue_home and self.camp == 0) or ((tx, ty + i) not in Red_home and self.camp == 1)):
                self.next.append([tx, ty + i])


# 非特殊棋子
class Elephant(Base):  # 大象
    def __init__(self, camp):
        Base.__init__(self, camp, Bel, Rel, 6)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        dir = [[-1, 0], [1, 0], [0, -1], [0, 1]]
        for i, j in dir:
            tx, ty = self.x + i, self.y + j
            if is_chess_in_board(tx, ty):
                if (tx, ty) not in river:
                    if grid[tx][ty]:
                        # 判断可吃，但对方不能为老鼠
                        if grid[tx][ty].camp != self.camp and (grid[tx][ty].rank <= self.rank or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 1) or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 0)) and (tx, ty) not in river and \
                                grid[tx][ty].rank != 0:
                            self.eat.append([tx, ty])
                        else:
                            self.pro.append([tx, ty])
                    # 不能进入本方兽穴
                    elif ((tx, ty) not in Blue_home and self.camp == 0) or ((tx, ty) not in Red_home and self.camp == 1):
                        self.next.append([tx, ty])


class Lion(Base):  # 狮子基本走法
    def __init__(self, camp):
        Base.__init__(self, camp, Bl, Rl, 5)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        self.lion_next(grid)


class Leopard(Base):  # 豹子
    def __init__(self, camp):
        Base.__init__(self, camp, Ble, Rle, 4)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        dir = [[-1, 0], [1, 0], [0, -1], [0, 1]]
        for i, j in dir:
            tx, ty = self.x + i, self.y + j
            if is_chess_in_board(tx, ty):
                if (tx, ty) not in river:
                    if grid[tx][ty]:
                        if grid[tx][ty].camp != self.camp and (grid[tx][ty].rank <= self.rank or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 1) or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 0)) and (tx, ty) not in river:
                            self.eat.append([tx, ty])
                        else:
                            self.pro.append([tx, ty])
                    elif (((tx, ty) not in Blue_home and self.camp == 0) or ((tx, ty) not in Red_home and self.camp == 1)):
                        self.next.append([tx, ty])


class Wolf(Base):  # 狼
    def __init__(self, camp):
        Base.__init__(self, camp, Bw, Rw, 3)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        dir = [[-1, 0], [1, 0], [0, -1], [0, 1]]
        for i, j in dir:
            tx, ty = self.x + i, self.y + j
            if is_chess_in_board(tx, ty):
                if (tx, ty) not in river:
                    if grid[tx][ty]:
                        if grid[tx][ty].camp != self.camp and (grid[tx][ty].rank <= self.rank or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 1) or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 0)) and (tx, ty) not in river:
                            self.eat.append([tx, ty])
                        else:
                            self.pro.append([tx, ty])
                    elif ((tx, ty) not in Blue_home and self.camp == 0) or ((tx, ty) not in Red_home and self.camp == 1):
                        self.next.append([tx, ty])


class Fox(Base):  # 狐狸
    def __init__(self, camp):
        Base.__init__(self, camp, Bf, Rf, 2)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        dir = [[-1, 0], [1, 0], [0, -1], [0, 1],
               [-1, -1], [-1, 1], [1, -1], [1, 1]]
        for i, j in dir:
            tx, ty = self.x + i, self.y + j
            if is_chess_in_board(tx, ty):
                if (tx, ty) not in river:
                    if grid[tx][ty]:
                        if grid[tx][ty].camp != self.camp and (grid[tx][ty].rank <= self.rank or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 1) or
                                                               (((tx, ty) in Blue_trap or (tx, ty) in Red_trap) and grid[tx][
                                                                   ty].camp == 0)) and (tx, ty) not in river:
                            self.eat.append([tx, ty])
                        else:
                            self.pro.append([tx, ty])
                    elif ((tx, ty) not in Blue_home and self.camp == 0) or ((tx, ty) not in Red_home and self.camp == 1):
                        self.next.append([tx, ty])


class Eagle(Base):  # 老鹰
    def __init__(self, camp):
        Base.__init__(self, camp, Bea, Rea, 1)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        self.eagle_next(grid)


class Mouse(Base):  # 老鼠
    def __init__(self, camp):
        Base.__init__(self, camp, Bm, Rm, 0)

    def next_step(self, grid):
        self.next = []
        self.eat = []
        self.pro = []
        dir = [[-1, 0], [1, 0], [0, -1], [0, 1]]
        for i, j in dir:
            tx, ty = self.x + i, self.y + j
            if is_chess_in_board(tx, ty):
                if grid[tx][ty]:
                    if grid[tx][ty].camp != self.camp and (self.x, self.y) not in river and (
                            (grid[tx][ty].rank == 6 or grid[tx][ty].rank == 0)
                            or (((tx, ty) in Red_trap or (tx, ty) in Blue_trap) and grid[tx][ty].camp == 1)
                            or (((tx, ty) in Red_trap or (tx, ty) in Blue_trap) and grid[tx][ty].camp == 0)):
                        self.eat.append([tx, ty])
                    else:
                        self.pro.append([tx, ty])
                elif ((tx, ty) not in Blue_home and self.camp == 0) or ((tx, ty) not in Red_home and self.camp == 1):
                    self.next.append([tx, ty])


# 导入背景音乐
file = r'.\Space - Just Blue.mp3'
pygame.mixer.init()
# 加载音乐文件
pygame.mixer.music.load(file)
# 开始播放音乐流
pygame.mixer.music.play()
# def game_start():
# 导入图片
size1 = 0.91
chessboard = pygame.transform.scale(pygame.image.load("backGround.png"), (1080 * size1 * sizel, 827 * size1 * sizel))
Bel = pygame.transform.scale(pygame.image.load("BElephant.jpg"), (ul, ul))
Rel = pygame.transform.scale(pygame.image.load("RElephant.jpg"), (ul, ul))
Bea = pygame.transform.scale(pygame.image.load("BEagle.jpg"), (ul, ul))
Rea = pygame.transform.scale(pygame.image.load("REagle.jpg"), (ul, ul))
Bf = pygame.transform.scale(pygame.image.load("BFox.jpg"), (ul, ul))
Rf = pygame.transform.scale(pygame.image.load("RFox.jpg"), (ul, ul))
Ble = pygame.transform.scale(pygame.image.load("BLeopard.jpg"), (ul, ul))
Rle = pygame.transform.scale(pygame.image.load("RLeopard.jpg"), (ul, ul))
Bl = pygame.transform.scale(pygame.image.load("BLion.jpg"), (ul, ul))
Rl = pygame.transform.scale(pygame.image.load("RLion.jpg"), (ul, ul))
Bw = pygame.transform.scale(pygame.image.load("BWolf.jpg"), (ul, ul))
Rw = pygame.transform.scale(pygame.image.load("RWolf.jpg"), (ul, ul))
Bm = pygame.transform.scale(pygame.image.load("BMouse.jpg"), (ul, ul))
Rm = pygame.transform.scale(pygame.image.load("RMouse.jpg"), (ul, ul))
ht = pygame.transform.scale(pygame.image.load("AimAt.png"), (44 * sizel, 44 * sizel))
htrect = ht.get_rect()
cpht = pygame.transform.scale(pygame.image.load("prey.png"), (108 * sizel, 108 * sizel))
grid = []  # 位置上有没有棋子
pos = []
occ = []
movable = False
for i in range(9):
    grid.append([])
    pos.append([])
    occ.append([])
    for j in range(9):
        occ[i].append([])
        grid[i].append(None)
        recthere = Bl.get_rect()
        recthere.left, recthere.top = (width - height) / 2 + ul * i, ul * j  # 中心点计算位置
        pos[i].append(recthere)

dir = (1, 0), (-1, 0), (0, 1), (0, -1)  # 坐标存储

times = 1
lastmove = []
selected = False
chesslst = []


def scan():
    tmp2 = []
    for i in grid:
        tmp = []
        for j in i:
            if j:
                tmp.append(type(j))
                yield type(j)
            else:
                tmp.append(j)
        tmp2.append(tmp)
    chesslst.append(tmp2)


def add(i, x, y):
    i.x, i.y = x - 1, y - 1
    grid[x - 1][y - 1] = i


# 左边棋子放置
add(Elephant(0), 3, 1)
add(Lion(0), 3, 4)
add(Leopard(0), 3, 5)
add(Wolf(0), 3, 3)
add(Fox(0), 2, 6)
add(Eagle(0), 2, 2)
add(Mouse(0), 3, 7)
# 右边棋子放置
add(Elephant(1), 7, 7)
add(Lion(1), 7, 4)
add(Leopard(1), 7, 3)
add(Wolf(1), 7, 5)
add(Fox(1), 8, 2)
add(Eagle(1), 8, 6)
add(Mouse(1), 7, 1)

scan()
refresh()
running = True

screen = pygame.display.set_mode(size)


def animate():
    screen.blit(chessboard, [(width - height) / 2, 0])
    if selected:
        selected.hint()
    for x, i in enumerate(grid):
        for y, j in enumerate(i):
            if j:
                screen.blit(j.img, [(width - height) / 2 + ul * x, ul * y])
    pygame.display.flip()


while running:
    for event in pygame.event.get():
        # 程序退出
        if event.type == pygame.QUIT:
            running = False
        # 点击鼠标
        elif event.type == pygame.MOUSEBUTTONDOWN:
            mousex, mousey = pygame.mouse.get_pos()  # 获取鼠标坐标
            x = y = z = j = False
            for y, i in enumerate(grid):
                for z, j in enumerate(i):
                    if pos[y][z].collidepoint(mousex, mousey):
                        x = j
                        break
                if pos[y][z].collidepoint(mousex, mousey):
                    break
            if x is False:
                continue
            if selected:
                if [y, z] in selected.next or [y, z] in selected.eat:
                    lastmove = []
                    selected.used = True
                    lastmove.append(copy(selected))
                    grid[y][z] = selected
                    grid[selected.x][selected.y] = None
                    grid[y][z].x, grid[y][z].y = y, z
                    lastmove.append(grid[y][z])
                    selected = False
                    times ^= 1
                    refresh()
                    tryout()
                    for i2 in occ:
                        for j2 in range(len(i2)):
                            i2[j2] = []
                    for i in grid:
                        for j in i:
                            if j:
                                for k, t in j.eat:
                                    occ[k][t].append(j)
                    animate()
                    scanlst = scan()
                    camp = aniSet()
                    camp.update(scanlst)
                    if not movable:
                        if rd != 100:
                            print("BLue" if win == 2 else "RED", "check!!!")
                            my_font = pygame.font.SysFont("Consolas", 100)
                            time_surf = my_font.render("BLUE WIN!!!" if win == 2 else "RED WIN!!!", 1,
                                                       [255, 0, 0] if win == 1 else [0, 0, 255])
                            gor = time_surf.get_rect()
                            gor.center = width / 2, height / 2
                            screen.blit(time_surf, gor)
                            pygame.display.update()
                            running2 = True
                            while running2:
                                for event2 in pygame.event.get():
                                    if event2.type == pygame.KEYDOWN:
                                        if event2.key == pygame.K_ESCAPE:
                                            _exit(0)
                        else:
                            print("平局", "check!!!")
                            my_font = pygame.font.SysFont("Consolas", 100)
                            time_surf = my_font.render("平局", 1, [255, 255, 255])
                            gor = time_surf.get_rect()
                            gor.center = width / 2, height / 2
                            screen.blit(time_surf, gor)
                            pygame.display.update()
                            running2 = True
                            while running2:
                                for event2 in pygame.event.get():
                                    if event2.type == pygame.KEYDOWN:
                                        if event2.key == pygame.K_ESCAPE:
                                            _exit(0)
                    rd += 1

                elif x:
                    if x.camp == times:
                        selected = x
                    else:
                        selected = False
                else:
                    selected = False
            else:
                if x:
                    if x.camp == times:
                        selected = x

    animate()
pygame.quit()