import pygame, sys,win32api,win32con
import re
import sys
import os
from tkinter import *
from pygame.locals import *
"""|-------------start宏定义模块start-----------------|"""
WINDOWWIDTH=1000    #窗体大小
WINDOWHEIGHT=700
CHESSWIDTH=30      #棋子大小
CIRCLEWIDTH=25
GAP=3             #棋子间距
XMARGIN=int((WINDOWWIDTH-(CHESSWIDTH+GAP)*28)/2)      #左边距
TOPMARGIN=int((WINDOWHEIGHT-(CHESSWIDTH+GAP)*18)/2)   #上边距
#定义颜色       R   G   B
BLACK       = (  0,  0,0)
LIGHTBLUE  = ( 40, 191,255)
LIGHTBLUE2 = ( 0, 0,255)
BGCOLOR    = (230,230,250)
LIGHTYELLOW= (255,225,0)
MYCOLOR    = (255,165,0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
Crimson=(220,20,60)
LightPink=(255,182,193)
DeepSkyBlue=(0,191,255)
DISPLAYSURF=pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT))#设置窗体
firstChess=None     #第一个选择的棋子
midChess=None       #中间将被吃掉的棋子
currentChess=None   #当前点击的棋子
index=0             #记录棋盘上的棋子数量
#定义棋盘
ALLCHESS={



29:[7,0,0],
22:[6,1,0],
16:[5,2,0],           30:[7,2,0],
11:[4,3,0],           23:[6,3,0],
5:[3,4,5],           17:[5,4,0],           31:[7,4,0],
6:[2,5,6],          12:[4,5,0],           24:[6,5,0],
10:[1,6,10],        4:[3,6,4],           18:[5,6,0],           32:[7,6,0],
1:[0,7,1],          7:[2,7,7],          13:[4,7,0],           25:[6,7,0],
9:[1,8,9],          3:[3,8,3],           19:[5,8,0],           33:[7,8,0],
8:[2,9,8],          14:[4,9,0],           26:[6,9,0],
2:[3,10,2],         20:[5,10,0],          34:[7,10,0],
15:[4,11,0],          27:[6,11,0],
21:[5,12,0],          35:[7,12,0],
28:[6,13,0],
36:[7,14,0],
37:[8,1,0],
44:[9,2,0],
38:[8,3,0],           50:[10,3,0],
45:[9,4,0],            55:[11,4,12],
39:[8,5,0],           51:[10,5,0],            61:[12,5,18],
46:[9,6,0],            56:[11,6,13],            62:[13,6,19],
40:[8,7,0],           52:[10,7,0],            60:[12,7,17],            64:[14,7,11],
47:[9,8,0],            57:[11,8,14],            63:[13,8,20],
41:[8,9,0],           53:[10,9,0],            59:[12,9,16],
48:[9,10,0],           58:[11,10,15],
42:[8,11,0],          54:[10,11,0],
49:[9,12,0],
43:[8,13,0],         
}
"""|-------------end宏定义模块end-----------------|"""
def restart_program():
python = sys.executable
os.execl(python, python, * sys.argv)
"""|-------------start棋盘绘制模块start-----------------|"""
def drawqipan(od):#绘制棋盘格子
drawLine_l()
drawLine_r()
drawcircle()
color4 = (100, 100, 100)
pygame.draw.rect(DISPLAYSURF, color4, [780, 20, 120, 40], 3)
pygame.draw.rect(DISPLAYSURF, color4, [70, 20, 120, 40], 3)

    pygame.draw.rect(DISPLAYSURF, color4, [820, 500, 80, 40], 3)
pygame.draw.rect(DISPLAYSURF, color4, [60, 500, 80, 40], 3)
pygame.draw.rect(DISPLAYSURF, color4, [820, 550, 80, 40], 3)
pygame.draw.rect(DISPLAYSURF, color4, [60, 550, 80, 40], 3)

font1 = pygame.font.Font('C:\Windows\Fonts\STXINGKA.TTF', 20)
font2 = pygame.font.Font('C:\Windows\Fonts\STXINGKA.TTF', 30)
text1 = font1.render("红方得分", True, RED)
text2 = font1.render("蓝方得分", True, BLUE)
text3 = font2.render("红方叫停", True, RED)
text4 = font2.render("蓝方叫停", True, BLUE)

text5 = font2.render("悔棋", True, RED)
text6 = font2.render("认输", True, RED)
text7 = font2.render("悔棋", True, BLUE)
text8 = font2.render("认输", True, BLUE)

DISPLAYSURF.blit(text1, (800, 130))
DISPLAYSURF.blit(text2, (90, 130))
DISPLAYSURF.blit(text3, (780, 20))
DISPLAYSURF.blit(text4, (70, 20))

DISPLAYSURF.blit(text5, (830, 500))
DISPLAYSURF.blit(text6, (830, 550))
DISPLAYSURF.blit(text7, (70, 500))
DISPLAYSURF.blit(text8, (70, 550))

print_score(my_Scores(),his_Scores())
my_font = pygame.font.SysFont("freesansbold.ttf", 100)

    if od==1:
text6 = my_font.render("RED PLAY", True, RED)
DISPLAYSURF.blit(text6, (330, 550))
else:
text5 = my_font.render("BULE PLAY", True, BLUE)
DISPLAYSURF.blit(text5, (310, 550))

    
def drawLine_l(ind=0,ynd=7):#绘制棋盘左边格子
x1,y1=getChessXY(ind,ynd)
x2,y2=getChessXY(ind+1,ynd+1)
x3,y3=getChessXY(ind+1,ynd-1)
pygame.draw.line(DISPLAYSURF,BLACK,(x1+int(CHESSWIDTH/2),y1+int(CHESSWIDTH/2)),(x2+int(CHESSWIDTH/2),y2+int(CHESSWIDTH/2)),3)
pygame.draw.line(DISPLAYSURF,BLACK,(x1+int(CHESSWIDTH/2),y1+int(CHESSWIDTH/2)),(x3+int(CHESSWIDTH/2),y3+int(CHESSWIDTH/2)),3)
pygame.draw.line(DISPLAYSURF,BLACK,(x2+int(CHESSWIDTH/2),y2+int(CHESSWIDTH/2)),(x3+int(CHESSWIDTH/2),y3+int(CHESSWIDTH/2)),3)
ind=ind+1
if(ind==7):
return 
drawLine_l(ind,ynd+1)
drawLine_l(ind,ynd-1)

def drawLine_r(ind=14,ynd=7):#绘制棋盘右边格子
x1,y1=getChessXY(ind,ynd)
x2,y2=getChessXY(ind-1,ynd+1)
x3,y3=getChessXY(ind-1,ynd-1)
pygame.draw.line(DISPLAYSURF,BLACK,(x1+int(CHESSWIDTH/2),y1+int(CHESSWIDTH/2)),(x2+int(CHESSWIDTH/2),y2+int(CHESSWIDTH/2)),3)
pygame.draw.line(DISPLAYSURF,BLACK,(x1+int(CHESSWIDTH/2),y1+int(CHESSWIDTH/2)),(x3+int(CHESSWIDTH/2),y3+int(CHESSWIDTH/2)),3)
pygame.draw.line(DISPLAYSURF,BLACK,(x2+int(CHESSWIDTH/2),y2+int(CHESSWIDTH/2)),(x3+int(CHESSWIDTH/2),y3+int(CHESSWIDTH/2)),3)
ind=ind-1
if(ind==7):
return 
drawLine_r(ind,ynd+1)
drawLine_r(ind,ynd-1)

def drawcircle():#绘制格子
basicFont = pygame.font.Font(None, 24)
for i in range(1,65):
x=ALLCHESS[i][0]
y=ALLCHESS[i][1]
x1, y1 = getChessXY(ALLCHESS[i][0], ALLCHESS[i][1])
#pygame.draw.circle(DISPLAYSURF,BLACK,(XMARGIN+2*x*(CHESSWIDTH+GAP),TOPMARGIN+y*(CHESSWIDTH+GAP)),int(CIRCLEWIDTH/2),0)
if i <= 10:
pygame.draw.circle(DISPLAYSURF,DeepSkyBlue,(XMARGIN+2*x*(CHESSWIDTH+GAP),TOPMARGIN+y*(CHESSWIDTH+GAP)),int(CIRCLEWIDTH/2)-3,0)
k=str((i-1)%10)
DISPLAYSURF.blit(basicFont.render(k, True, BLACK),(x1+CHESSWIDTH/3,y1+CHESSWIDTH/3-1))
elif i>10 and i<55:
pygame.draw.circle(DISPLAYSURF, WHITE,(XMARGIN + 2 * x * (CHESSWIDTH + GAP), TOPMARGIN + y * (CHESSWIDTH + GAP)),int(CIRCLEWIDTH / 2) - 3, 0)
else:
pygame.draw.circle(DISPLAYSURF, RED,(XMARGIN + 2 * x * (CHESSWIDTH + GAP), TOPMARGIN + y * (CHESSWIDTH + GAP)),int(CIRCLEWIDTH / 2) - 3, 0)
if i==64:
DISPLAYSURF.blit(basicFont.render("0", True, BLACK), (x1 + CHESSWIDTH / 3, y1 + CHESSWIDTH / 3-1))
else:
k = str(i-54)
DISPLAYSURF.blit(basicFont.render(k, True, BLACK), (x1 + CHESSWIDTH / 3, y1 + CHESSWIDTH / 3-1))

"""|-------------end棋盘绘制模块end-----------------|"""

"""|-------------start棋子绘制模块start-----------------|"""
def drawChess():#绘制棋子
basicFont = pygame.font.Font(None, 24)
for i in range(1,65):
if ALLCHESS[i][2]>0:
x=ALLCHESS[i][0]
y=ALLCHESS[i][1]
if ALLCHESS[i][2]<=10:
pygame.draw.circle(DISPLAYSURF,LIGHTBLUE,(XMARGIN+2*x*(CHESSWIDTH+GAP),TOPMARGIN+y*(CHESSWIDTH+GAP)),int(CHESSWIDTH/2),0)
pygame.draw.circle(DISPLAYSURF,LIGHTBLUE2,(XMARGIN+2*x*(CHESSWIDTH+GAP),TOPMARGIN+y*(CHESSWIDTH+GAP)),int(CHESSWIDTH/2)-3,0)
else:
pygame.draw.circle(DISPLAYSURF, LightPink,(XMARGIN + 2 * x * (CHESSWIDTH + GAP), TOPMARGIN + y * (CHESSWIDTH + GAP)),int(CHESSWIDTH / 2), 0)
pygame.draw.circle(DISPLAYSURF, Crimson,(XMARGIN + 2 * x * (CHESSWIDTH + GAP), TOPMARGIN + y * (CHESSWIDTH + GAP)),int(CHESSWIDTH / 2) - 3,0)
q = str((ALLCHESS[i][2]-1)%10)
DISPLAYSURF.blit(basicFont.render(q, True, BLACK), (XMARGIN+2*x*(CHESSWIDTH+GAP)-6,TOPMARGIN+y*(CHESSWIDTH+GAP)-7))

def drawSide(x,y):#在点击的棋子上换一个圆环
pygame.draw.circle(DISPLAYSURF,LIGHTYELLOW,(x+int(CHESSWIDTH/2),y+int(CHESSWIDTH/2)),int(CHESSWIDTH/2)+3,3)

def getChessXY(chessX,chessY):#得到的棋子坐标
left=XMARGIN+2*chessX*(CHESSWIDTH+GAP)-int(CHESSWIDTH/2)
top=TOPMARGIN+chessY*(CHESSWIDTH+GAP)-int(CHESSWIDTH/2)
return(left,top)

def getChessIndex(x,y):#将的棋子的坐标转换成编号
for i in range(1,65):
left,top=getChessXY(ALLCHESS[i][0],ALLCHESS[i][1])
chessRect=pygame.Rect(left,top,CHESSWIDTH,CHESSWIDTH)
if chessRect.collidepoint(x,y):
return(i)
return(None)
"""|-------------end棋子绘制模块end-----------------|"""

"""|-------------start棋子移动模块start-----------------|"""
def jumpChess(firstChess,currentChess):#跳子
"""if hui==1:
ALLCHESS[currentChess][2] = ALLCHESS[firstChess][2]
ALLCHESS[firstChess][2] = 0
return True"""
if canGo(firstChess,currentChess):
ALLCHESS[currentChess][2] = ALLCHESS[firstChess][2]
ALLCHESS[firstChess][2]=0
return True
else:
return False

def jumpChess_back(firstChess,currentChess):#跳子
ALLCHESS[currentChess][2] = ALLCHESS[firstChess][2]
ALLCHESS[firstChess][2]=0

def canGo(firstChess,goalChess):
if s_Move(firstChess,goalChess) or sn_Move(firstChess,goalChess) or s_Jump(firstChess,goalChess):
return True

return False

def s_Move(firstChess,goalChess):#检测是否可以进行“移”操作
if checkNeibor(firstChess,goalChess) and ALLCHESS[firstChess][2]>0 and ALLCHESS[goalChess][2]==0:
return True
return False

def sn_Move(firstChess,goalChess):#检测是否可以进行“邻”操作
x=abs(ALLCHESS[firstChess][0]-ALLCHESS[goalChess][0])
y=abs(ALLCHESS[firstChess][1]-ALLCHESS[goalChess][1])
x1=ALLCHESS[firstChess][0]+ALLCHESS[goalChess][0]
y1=ALLCHESS[firstChess][1]+ALLCHESS[goalChess][1]
if (x==y and x==2)or (x==0 and y==4):
x2,y2=getChessXY(x1/2,y1/2)
z1=getChessIndex(x2,y2)
if ALLCHESS[z1][2]>0:
return True#
return False

def s_Jump(firstChess,goalChess):#检测是否可以进行“单跨”操作
m=ALLCHESS[firstChess][0]-ALLCHESS[goalChess][0]
n=ALLCHESS[firstChess][1]-ALLCHESS[goalChess][1]
u=abs(m)
v=abs(n)
if u != 0:
p=m/u
q=n/u
else:
p=0
q=n/v*2
rg=abs(ALLCHESS[firstChess][1]-ALLCHESS[goalChess][1])#纵坐标之差可表示连线之间棋子个数
xx0=ALLCHESS[goalChess][0]
yy0=ALLCHESS[goalChess][1]
xx1,yy1=getChessXY(xx0+p,yy0+q)
zz0=getChessIndex(xx1,yy1)
#|上述语句用于判断单跨目标棋子的上一个位置
x=[]#准备一个空列表，用于添加当前和目标间棋子的权值
if u==0:
rg=int(rg/2)#在竖直方向时个数为纵坐标之差的一半
if check_in_line(firstChess,goalChess):#当目标连线在同一直线时
for i in range(1,rg):
x0=xx0+p
y0=yy0+q
xx0=x0
yy0=y0
xx,yy=getChessXY(x0,y0)
z=int(getChessIndex(xx,yy))
if ALLCHESS[z][2] != 0:
if ALLCHESS[z][2]<11:
tmp=ALLCHESS[z][2]-1
else:
tmp=ALLCHESS[z][2]-11
x+=[tmp]#将希望跨过的棋子加到列表中
root = Tk()
root.minsize(200, 200)

        # b = Button(root, text="BUTTON4", background="red", foreground="white")
# b.pack()
if ALLCHESS[firstChess][2]<11:
tp=ALLCHESS[firstChess][2]-1
else:
tp=ALLCHESS[firstChess][2]-11
sss = str(x)
sss2=str(tp)
Label(root, text="请输入用只含下列数字且只用一次，结果为").pack()
Label(root, text=sss2).pack()
Label(root, text="的表达式").pack()
Label(root, text=sss).pack()
l1 = Label(root, text="请输入表达式：")
root.geometry("%dx%d+%d+%d" % (300, 100, 480, (WINDOWHEIGHT) / 2))
xls_text = StringVar()
l1.pack()  # 这里的side可以赋值为LEFT  RTGHT TOP  BOTTOM
xls = Entry(root, textvariable=xls_text)
xls_text.set("")
xls.pack()
Button(root, text="确认", command=root.destroy).pack( expand=YES)
#Button(root, text="取消", command=root.destroy).pack(side=LEFT, expand=YES)

        root.mainloop()
expression=xls_text.get()
print(xls_text)
expre=re.findall(r"\d+",expression)#将输入的字符串运算式的数字转换到为列表
expre=list(map(int,expre))#将列表元素转换为整型
bingo1=is_Sameset(expre,x)#表示输入的算式数字和棋子一一对应
if tp==t_Result(expression):#表示输入的算式结果对应
bingo2=True
else:
bingo2=False
if bingo1 and bingo2 and ALLCHESS[zz0][2]>0:
return True
if bingo2==False or bingo1==False:
root3=Tk()
Label(root3,text="表达式错误").pack()
root3.geometry("%dx%d+%d+%d" % (100, 100, (WINDOWWIDTH +50) / 2, (WINDOWHEIGHT +50) / 2))
root3.mainloop()
return False

def checkNeibor(firstChess,midChess):#检查欲跳向的位置是否是相临格子
x=abs(ALLCHESS[firstChess][0]-ALLCHESS[midChess][0])
y=abs(ALLCHESS[firstChess][1]-ALLCHESS[midChess][1])
if x==y and x==1:
return True
elif ALLCHESS[firstChess][0]==ALLCHESS[midChess][0] and y==2:
return True
return False

def check_in_line(firstChess,midChess):#检查欲跳向的位置是否是在同一直线上
x=abs(ALLCHESS[firstChess][0]-ALLCHESS[midChess][0])
y=abs(ALLCHESS[firstChess][1]-ALLCHESS[midChess][1])
if x==y:
return True
elif ALLCHESS[firstChess][0]==ALLCHESS[midChess][0]:
return True
return False

def is_Sameset(a=[],b=[]):
a.sort()
b.sort()
if a==b:
return True
else:
return False

class Calculator(object):
def __init__(self):
# 操作符集合
self.operators = ['+', '-', '*', '/', '(', ')']
# 操作符优先级
self.priority = {
'+': 1,
'-': 1,
'*': 2,
'/': 2,
'(': 3,
')': 3
}

    def generate_postfix_expression(self, expression):
"""
生成后缀表达式
:param expression:
:return:
"""
# 去除表达式中所有空格
expression = expression.replace(' ', '')
# 创建list作为栈，list的append和pop方法刚好和栈的入栈和出栈方法相同
# 操作符栈
operator_stack = list()
# 后缀表达式是从尾部插入数据，使用后缀表达式计算结果是从头开始遍历，可以理解为先进先出，可以使用队列实现，
# 这里为了简便用list代替，不做内存释放处理
expression_stack = list()
for element in expression:
# 如果是数字则直接入表达式栈
if element in self.operators:
# 如果栈为空，操作符直接入操作符栈，或者为左括号，也直接入操作符栈
if not operator_stack:
operator_stack.append(element)
else:
# 如果目标元素是右括号，操作符栈顶出栈直接遇到左括号，且出栈的操作符除了括号入到表达式队列中
if element == ')':
for top in operator_stack[::-1]:
if top != '(':
expression_stack.append(top)
operator_stack.pop()
else:
operator_stack.pop()
break
else:
for top in operator_stack[::-1]:
# 如果目标元素大于栈顶元素，则直接入栈，否则栈顶元素出栈，入到表达式队列中
# 左括号只有遇到右括号才出栈
if self.priority[top] >= self.priority[element] and top != '(':
expression_stack.append(top)
operator_stack.pop()
else:
operator_stack.append(element)
break
# 可能操作符栈所有的元素优先级都大于等于目标操作符的优先级，这样的话操作符全部出栈了，
# 而目标操作符需要入栈操作
if not operator_stack:
operator_stack.append(element)
else:
expression_stack.append(element)
# 中缀表达式遍历结束，操作符栈仍有操作符，将操作符栈中的操作符入到表达式栈中
for i in range(len(operator_stack)):
expression_stack.append(operator_stack.pop())
return expression_stack

    def calcaulate(self, expression):
# 生成后缀表达式
expression_result = self.generate_postfix_expression(expression)
calcalate_stack = list()# 使用list作为栈来计算
# 遍历后缀表达式
for element in expression_result:
# 如果为数字直接入栈
# 遇到操作符，将栈顶的两个元素出栈
if element not in self.operators:
calcalate_stack.append(element)
else:
number1 = calcalate_stack.pop()# 操作数
number2 = calcalate_stack.pop()# 被操作数
result = self.operate(number1, number2, element) # 结果 =  被操作数 操作符 操作数 （例：2 - 1）
calcalate_stack.append(result) # 计算结果入栈
return calcalate_stack[0]

    def operate(self, number1, number2, operator):
"""
计算结果
:param number1: 操作数
:param number2: 被操作数
:param operator: 操作符
:return: 
"""
number1 = int(number1)
number2 = int(number2)
if operator == '+':
return number2 + number1
if operator == '-':
return number2 - number1
if operator == '*':
return number2 * number1
if operator == '/':
if number2 % number1 == 0:
return number2 / number1
else:
return -1

def t_Result(expression):
c = Calculator()
try:
expression_result = c.calcaulate(expression)
except(BaseException):
return -1
return (expression_result)

"""|-------------end棋子移动模块end-----------------|"""

"""|-------------start计算分数模块start-----------------|"""
def my_Scores():
tmp=0
ans=0
for i in range(1,11):
if ALLCHESS[i][2]>10:
ans=(i-1)*(ALLCHESS[i][2]-11)+tmp
tmp=ans
return ans

def his_Scores():
tmp=0
s=0
for i in range(55,65):
if ALLCHESS[i][2]<11 and ALLCHESS[i][2]>0:
if i==64:
s+=0
else:
s=(i-54)*(ALLCHESS[i][2]-1)+tmp
tmp=s
return s
def print_score(a,b):
my_font = pygame.font.SysFont("arial", 30)
DISPLAYSURF.blit(my_font.render(str(a), True, BLACK), (830, 90))
DISPLAYSURF.blit(my_font.render(str(b), True, BLACK), (120, 90))

"""|-------------end计算分数模块end-----------------|"""
def main():#主程序
pygame.init()
DISPLAYSURF=pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT))
pygame.display.set_caption("国际数棋")
mousex=0
mousey=0
working=True#如果叫停，则停止操作，working变为false
order=True#每一次跳跃后order改变，执子方转换0-1
DISPLAYSURF.fill(BGCOLOR)
drawqipan(order)
drawChess()
goback_s = []
goback_e = []
order_stack = []
iswantgb = 0  # 标记是否需要悔棋
iswantl = 0  # 判断是否认输0-无人认输，1-认输：认输后比较分数，可能存在平局
while True:
mouseClicked=False
for event in pygame.event.get():
if event.type==QUIT or  (event.type==KEYUP and event.key==K_ESCAPE):
pygame.quit()
sys.exit()
elif event.type==MOUSEBUTTONUP:
mousex,mousey=event.pos
mouseClicked=True

iswantgb =0
if  mouseClicked==True:
index=getChessIndex(mousex,mousey)
if ((820<mousex<900 and 550<mousey<590) or  (60 < mousex < 140 and 550 < mousey < 590))and working==True:
working=False#认输

            if index!=None and ALLCHESS[index][2]>0:#棋盘刷新/移动棋子
#if goback_s!=[]:
#goback_s .pop()
firstChess=index
x,y=getChessXY(ALLCHESS[index][0],ALLCHESS[index][1])
DISPLAYSURF.fill(BGCOLOR)
drawqipan(order)
drawChess()
drawSide(x,y)
elif index!=None and ALLCHESS[index][2]==0 and firstChess!=None:
currentChess=index
if order==False and ALLCHESS[firstChess][2]<11 and working==True:
j=jumpChess(firstChess,currentChess)
if j:
order=True
goback_s += [currentChess]
goback_e += [firstChess]
order_stack +=[order]
elif order==True and ALLCHESS[firstChess][2]>10 and working==True:
j=jumpChess(firstChess,currentChess)
if j:
order=False
goback_s += [currentChess]
goback_e += [firstChess]
order_stack +=[order]
firstChess=None
DISPLAYSURF.fill(BGCOLOR)
drawqipan(order)
drawChess()


if ((820<mousex<900 and 500<mousey<540) or  (60 < mousex < 140 and 500 < mousey < 540))and working==True:
if goback_s!=[] and goback_e!=[]:
print(goback_s)
print(goback_e)
firstChess = goback_s.pop()
currentChess = goback_e.pop()
order = not order_stack.pop()
jumpChess_back(firstChess, currentChess)
firstChess=None
DISPLAYSURF.fill(BGCOLOR)
drawqipan(order)
drawChess()



if 780<mousex<900 and 20<mousey<60 and working==True :#红方叫停
tanchuang = 0
for i in range(1,11):
if ALLCHESS[i][2]<=10 or ALLCHESS[i][2]==0:
tanchuang=1
if tanchuang==1:
root1 = Tk()
Label(root1, text="未达到胜利条件").pack()
root1.geometry("%dx%d+%d+%d" % (100, 100, (WINDOWWIDTH +50) / 2, (WINDOWHEIGHT +50) / 2))
root1.mainloop()
else:
working = False
elif 70<mousex<190 and 20<mousey<60 and working==True:#蓝方叫停
tanchuang = 0
for i in range(55,65):
if ALLCHESS[i][2]>10 or ALLCHESS[i][2]==0:
tanchuang=1
if tanchuang==1:
root1 = Tk()
Label(root1, text="未达到胜利条件").pack()
#size = '%dx%d+%d+%d' % (100, 100, (WINDOWWIDTH - 100) / 2, (WINDOWHEIGHT - 100) / 2)
root1.geometry("%dx%d+%d+%d" %(100, 100, (WINDOWWIDTH - 50) / 2, (WINDOWHEIGHT - 50) / 2))
root1.mainloop()
else:
working=False

if working==False:#游戏结束
root2=Tk()
root2.minsize(300,200)
Label(root2,text="游戏结束").pack()
if my_Scores()>his_Scores():
Label(root2,text="红方胜利").pack()
elif my_Scores()==his_Scores():
Label(root2,text="旗鼓相当-平局").pack()
else:
Label(root2,text="蓝方胜利").pack()
root2.geometry("%dx%d+%d+%d" % (200, 200, (WINDOWWIDTH +50) / 2, (WINDOWHEIGHT +50) / 2))
Button(root2, text="再来一把", command=root2.destroy).pack(side=LEFT, expand=YES)
Button(root2, text="退出游戏", command=quit).pack(side=LEFT, expand=YES)
root2.mainloop()
restart_program()

pygame.display.update()
if __name__=='__main__':
main()