From 6a33fbe9bea20c16b254aad9f868e2206a519c3e Mon Sep 17 00:00:00 2001
From: hnu202210040322 <2991888313@qq.com>
Date: Sat, 27 May 2023 11:03:26 +0800
Subject: [PATCH] ADD file via upload

---
 chess.py | 454 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 454 insertions(+)
 create mode 100644 chess.py

diff --git a/chess.py b/chess.py
new file mode 100644
index 0000000..8d59b9a
--- /dev/null
+++ b/chess.py
@@ -0,0 +1,454 @@
+from abc import ABC, abstractmethod
+from tkinter import Tk, Canvas
+import tkinter as tk
+from functools import partial
+count = 0
+
+
+class chess(ABC):
+    
+    def __init__(self, x:int, y:int, color:bool, type:int)->None:
+        self.x = x
+        self.y = y
+        self.color = color
+        self.type = type
+
+    def move_able(self, map:map, x1:int, y1:int)->bool:
+        chess_map = map.chess_map
+        try:
+            chess_color = map.chess_map[x1][y1].color
+            color = self.color 
+            if chess_color < 2 and color != chess_color or chess_color == 2:
+                return True
+            else:
+                return False
+        except:
+            print((x1, y1))
+            print((len(chess_map), len(chess_map[0])))
+            return False
+
+    def if_blank(self, map:map, x1:int, y1:int)->bool:
+        chess_color = map.chess_map[x1][y1].color  
+        if chess_color == 2:
+            return True
+        else:
+            return False
+
+    def if_enemy(self, map:map, x1:int, y1:int)->bool:
+        chess_color = map.chess_map[x1][y1].color  
+        color = self.color
+        if chess_color < 2 and chess_color != color:
+            return True
+        else:
+            return False
+        
+    def within_range(self, map:map, x1:int, y1:int)->bool:
+        edge = map.edge
+        row = map.row
+        col = map.col
+        return edge <= x1 < edge + col and edge <= y1 < edge + row
+        
+    def not_pass_river(self, map:map, y1)->bool:
+        y = map.river[self.color]
+        return y[0] <= y1 <= y[1]
+
+    @abstractmethod
+    def get_all_moveable_position(self, map:map):
+        pass
+
+    @abstractmethod
+    def __repr__(self):
+        pass
+
+class chess_che(chess):
+
+    vector = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+    def get_all_moveable_position(self, map:map)->list:
+        x1 = self.x
+        y1 = self.y
+        vector = self.vector
+        ans = []
+        if_enemy = self.if_enemy
+        if_blank = self.if_blank
+        for i in vector:
+            delta_x = i[0]
+            delta_y = i[1]
+            x = x1 + delta_x
+            y = y1 + delta_y
+            while if_blank(map, x, y):
+                ans.append((x, y))
+                x += delta_x
+                y += delta_y
+            if if_enemy(map, x, y):
+                ans.append((x, y))
+        return ans
+
+    def __repr__(self):
+        return "车"
+
+class chess_ma(chess):
+    
+    vector = [(1, 2, 0, 1), (1, -2, 0, -1), (2, 1, 1, 0), (2, -1, 1, 0), (-2, 1, -1, 0), (-1, 2, 0, 1), (-1, -2, 0, -1), (-2, -1, -1, 0)]
+    def get_all_moveable_position(self, map:map)->list:
+        x = self.x
+        y = self.y
+        vector = self.vector
+        move_able = self.move_able
+        if_blank = self.if_blank
+        return [(x + i[0], y + i[1]) for i in vector if move_able(map, x + i[0], y + i[1]) and if_blank(map, x + i[2], y + i[3])]
+
+    def __repr__(self):
+        return "马"
+
+class chess_xiang(chess):
+    vector = [(2, 2), (2, -2), (-2, 2), (-2, -2)]
+    def get_all_moveable_position(self, map:map):
+        x = self.x
+        y = self.y
+        vector = self.vector
+        move_able = self.move_able
+        if_blank = self.if_blank
+        not_pass_river = self.not_pass_river
+        return [(x + i[0], y + i[1]) for i in vector if move_able(map, x + i[0], y + i[1]) and if_blank(map, x + i[0] // 2, y + i[1] // 2) and not_pass_river(map, y + i[1])]
+
+    def __repr__(self):
+        return "相"
+
+class chess_shi(chess):
+    vector = [(1, 1), (1, -1), (-1, 1), (-1, -1)]
+    def get_all_moveable_position(self, map:map):
+        x = self.x
+        y = self.y
+        vector = self.vector
+        pos = map.handsome[self.color]
+        if x == pos[0] and y == pos[1]:
+            move_able = self.move_able
+            return [(x + i[0], y + i[1]) for i in vector if move_able(map, x + i[0], y + i[1])]
+        
+        else:
+            if(self.move_able(map, pos[0], pos[1])):
+                return [pos]
+            else:
+                return []
+            
+    def __repr__(self):
+        return "仕"
+
+class chess_jiang(chess):
+    vector =  [(-1, 0), (0, -1), (1, 0), (0, 1)]
+    def within_range(self, map:map, x1:int, y1:int)->bool:
+        pos = map.handsome[self.color]
+        x = pos[0]
+        y = pos[1]
+        return x - 1 <= x1 <= x + 1 and y - 1 <= y1 <= y + 1
+    
+    def get_all_moveable_position(self, map:map):
+        x = self.x
+        y = self.y
+        vector = self.vector
+        move_able = self.move_able
+        within_range = self.within_range
+        return [(x + i[0], y + i[1]) for i in vector if move_able(map, x + i[0], y + i[1]) and within_range(map, x + i[0], y + i[1])]
+    
+    def __repr__(self):
+        return "将"
+
+class chess_pao(chess):
+
+    vector = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+    def get_all_moveable_position(self, map:map):
+        x = self.x
+        y = self.y
+        vector = self.vector
+        if_blank = self.if_blank
+        if_enemy = self.if_enemy
+        ans = []
+        for i in vector:
+            delta_x = i[0]
+            delta_y = i[1]
+            x1 = x + delta_x
+            y1 = y + delta_y
+            while if_blank(map, x1, y1):
+                ans.append((x1, y1))
+                x1 += delta_x
+                y1 += delta_y
+            x1 += delta_x
+            y1 += delta_y
+            while if_blank(map, x1, y1):
+                x1 += delta_x
+                y1 += delta_y
+            if if_enemy(map, x1, y1):
+                ans.append((x1, y1))
+        return ans
+
+    def __repr__(self):
+        return "炮"
+
+class chess_bing(chess):
+    vector = [[[(0, 1)], [(1, 0), (-1, 0), (0, 1)]], [[(0, -1)], [(1, 0), [-1, 0], (0, -1)]]]
+    def get_all_moveable_position(self, map:map):
+        move_able = self.move_able
+        color = self.color
+        x = self.x
+        y = self.y
+        vector = self.vector[color][1 - self.not_pass_river(map, y)]
+        return [(x + i[0], y + i[1]) for i in vector if move_able(map, x + i[0], y + i[1])]
+
+    def __repr__(self):
+        return "兵"
+
+class chess_blank(chess):
+    def __init__(self):
+        self.color = 2
+
+    def get_all_moveable_position(self, map:map):
+        pass
+
+    def __repr__(self):
+        return "  "
+
+class chess_block(chess):
+    def __init__(self):
+        self.color = 3
+
+    def get_all_moveable_position(self, map:map):
+        pass
+
+    def __repr__(self):
+        return "**"
+    
+
+
+class process:
+    def __init__(self, start:tuple, end:tuple, eaten_chess:chess)->None:
+        self.start = start
+        self.end = end
+        self.eaten_chess = eaten_chess
+
+class map:
+    chess_map = []
+    col = 9
+    row = 10
+    edge = 2
+    river = [(edge, edge + row // 2 - 1), (edge + row // 2, edge + row)]
+    handsome = [(edge + col // 2, edge + 1), (edge + col // 2, edge + row - 2)]
+    exist_chess = []
+    score = 0
+    score_standard = [100, 80, 40, 30, 10000, 80, 20]
+    level_score = [10000000 if i % 2 == 0 else -10000000 for i in range(100)]
+    lock = [0, 0, 0] #0: 未锁定 1:已锁定
+    def __init__(self):
+        col = self.col
+        row = self.row
+        edge = self.edge
+        chess_map = [[chess_blank() if edge <= i < edge + col and edge <= j < row + edge else chess_block() for j in range(row + edge * 2)] for i in range(col + edge * 2)]
+        with open("map_data.txt", "r") as fp:
+            map_data = fp.readlines()
+        for data in map_data:
+            data_list = data.split()
+            x = int(data_list[0]) + edge
+            y = int(data_list[1]) + edge
+            color = int(data_list[2])
+            type = int(data_list[3])
+            if type == 0:
+                chess_map[x][y] = chess_che(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_che(x, edge * 2 + row - 1 - y, 1 - color, type)
+            elif type == 1:
+                chess_map[x][y] = chess_ma(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_ma(x, edge * 2 + row - 1 - y, 1 - color, type)
+            elif type == 2:
+                chess_map[x][y] = chess_xiang(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_xiang(x, edge * 2 + row - 1 - y, 1 - color, type)
+            elif type == 3:
+                chess_map[x][y] = chess_shi(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_shi(x, edge * 2 + row - 1 - y, 1 - color, type)
+            elif type == 4:
+                chess_map[x][y] = chess_jiang(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_jiang(x, edge * 2 + row - 1 - y, 1 - color, type)
+            elif type == 5:
+                chess_map[x][y] = chess_pao(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_pao(x, edge * 2 + row - 1 - y, 1 - color, type)
+            elif type == 6:
+                chess_map[x][y] = chess_bing(x , y, color, type)
+                chess_map[x][edge * 2 + row - 1 - y] = chess_bing(x, edge * 2 + row - 1 - y, 1 - color, type)
+        self.chess_map = chess_map
+    
+    def show(self)->None:
+        row = self.row
+        col = self.col
+        edge = self.edge
+        chess_map = self.chess_map
+        for i in range(row + edge * 2):
+            for j in range(col + edge * 2):
+                print(chess_map[j][i], end = "")
+            print()
+    
+    def draw(self, root, canvas):
+        canvas.delete(tk.ALL)
+        canvas.create_rectangle(50, 50, 50 + 50 * 8, 50 + 50 * 9)
+        for i in range(100, 100 + 50 * 8, 50): #画横线
+            canvas.create_line(50, i, 50 + 50 * 8, i)
+        for i in range(100, 100 + 50 * 8, 50): #画竖线
+            canvas.create_line(i, 50, i, 50 + 4 * 50)
+            canvas.create_line(i, 50 + 50 * 5, i, 50 + 50 * 9)
+        chess_map = self.chess_map
+        for i in chess_map:
+            for j in i:
+                if j.color < 2:
+                    canvas.create_oval(50 * (j.x - 1) - 20, 50 * (j.y - 1) - 20, 50 * (j.x - 1) + 20, 50 * (j.y - 1) + 20, fill = "white") 
+                    canvas.create_text(50 * (j.x - 1), 50 * (j.y - 1), text = j.__repr__(), fill = "black" if j.color == 0 else "red", font=('Old English Text MT',20))
+
+    def get_ans(self, pro:process, cur_depth:int, max_depth:int, color:bool, primer_color:bool, cur_score):
+        global count
+        count += 1
+        x2, y2 = pro.end
+        chess_end = self.chess_map[x2][y2]
+        level_score = self.level_score
+        score_standard = self.score_standard
+        if cur_depth % 2 == 1 and cur_depth > 1: #如果是奇数
+            if level_score[cur_depth - 1] < cur_score - 200:
+                return cur_score + 100
+        elif cur_depth % 2 == 0 and cur_depth > 1:
+            if level_score[cur_depth - 1] > cur_score + 200:
+                return cur_score - 100
+        if cur_depth == max_depth:
+                return cur_score
+        get_ans = self.get_ans
+        chess_map = self.chess_map
+        x3, y3 = pro.start
+        chess_start = chess_map[x3][y3]
+        chess_map[x3][y3] = chess_blank()
+        chess_map[x2][y2] = chess_start
+        chess_start.x = x2
+        chess_start.y = y2
+        if cur_depth % 2 == 1: #奇数找最大值
+            score = -1000000
+            for i in chess_map:
+                for j in i:
+                    if j.color == color:
+                        x1 = j.x
+                        y1 = j.y
+                        for x, y in j.get_all_moveable_position(self):
+                            pro = process((x1, y1), (x, y), chess_map[x][y])
+                            if chess_map[x][y].color == 1 - primer_color:
+                                t = get_ans(pro, cur_depth + 1, max_depth, 1 - color, primer_color, cur_score + score_standard[chess_map[x][y].type])
+                            elif chess_map[x][y].color == primer_color: #被吃加10点debuff
+                                t = get_ans(pro, cur_depth + 1, max_depth, 1 - color, primer_color, cur_score - score_standard[chess_map[x][y].type] - 10)
+                            else:
+                                t = get_ans(pro, cur_depth + 1, max_depth, 1 - color, primer_color, cur_score)
+                            if t > score:
+                                score = t
+                                if score > level_score[cur_depth]:
+                                    level_score[cur_depth] = score
+                            
+                            
+        else:
+            score = 1000000
+            for i in chess_map:
+                for j in i:
+                    if j.color == color:
+                        x1 = j.x
+                        y1 = j.y
+                        for x, y in j.get_all_moveable_position(self):
+                            pro = process((x1, y1), (x, y), chess_map[x][y])
+                            if chess_map[x][y].color == 1 - primer_color:
+                                t = get_ans(pro, cur_depth + 1, max_depth, 1 - color, primer_color, cur_score + score_standard[chess_map[x][y].type])
+                            elif chess_map[x][y].color == primer_color: #同理
+                                t = get_ans(pro, cur_depth + 1, max_depth, 1 - color, primer_color, cur_score - score_standard[chess_map[x][y].type] - 10)
+                            else:
+                                t = get_ans(pro, cur_depth + 1, max_depth, 1 - color, primer_color, cur_score)
+                            if t < score:
+                                score = t
+                                if score < level_score[cur_depth]:
+                                    level_score[cur_depth] = score
+        chess_start.x = x3
+        chess_start.y = y3
+        chess_map[x3][y3] = chess_start
+        chess_map[x2][y2] = chess_end
+        return score
+    
+        
+    def next(self, pro):
+        chess_map = self.chess_map
+        x1 = pro.start[0]
+        y1 = pro.start[1]
+        x2 = pro.end[0]
+        y2 = pro.end[1]
+        chess_start = chess_map[x1][y1]
+        chess_start.x = x2
+        chess_start.y = y2
+        chess_map[x2][y2] = chess_start
+        chess_map[x1][y1] = chess_blank()
+    
+    def get_pro(self, depth):
+        score = -10000
+        get_ans = self.get_ans
+        chess_map = self.chess_map
+        score_standard = self.score_standard
+        for i in chess_map:
+            for j in i:
+                if j.color == 1:
+                    for x, y in j.get_all_moveable_position(self):
+                        pro = process((j.x, j.y), (x, y), chess_map[x][y])
+                        t = get_ans(pro, 2, depth, 0, 1, 0 if chess_map[x][y].color == 2 else score_standard[chess_map[x][y].type])
+                        if t > score:
+                            score = t
+                            p = pro
+        self.level_score = [10000000 if i % 2 == 0 else -10000000 for i in range(100)]
+        return p
+    
+    def call_back(self, root, canvas, depth, event):
+        print((self.lock[0], self.lock[1], self.lock[2]))
+        chess_map = self.chess_map
+        lock = self.lock
+        for i in range(50, 50 + 50 * 9, 50):
+            for j in range(50, 50 + 50 * 10, 50):
+                if (event.x - i) ** 2 + (event.y - j) ** 2 < 20 ** 2:
+                    x = i // 50 + 1
+                    y = j // 50 + 1
+                    if chess_map[x][y].color < 3:
+                        if lock[2] == 0: #如果未锁定
+                            if chess_map[x][y].color < 2:
+                                lock[2] = 1
+                                lock[0] = x
+                                lock[1] = y
+                        elif lock[0] == x and lock[1] == y: #如果锁定的是一样的棋子
+                            lock[2] = 0
+                        else:
+                            if chess_map[lock[0]][lock[1]].color == 0:
+                                if chess_map[x][y].color == 1 or chess_map[x][y].color == 2:
+                                    lock[2] = 0 #解锁
+                                    pro = process((lock[0], lock[1]), (x, y), chess_map[x][y])
+                                    self.next(pro)
+                                    self.draw(root, canvas)
+                                    root.update()
+                                    pro = self.get_pro(depth)
+                                    self.next(pro)
+                                    self.draw(root, canvas)
+                                    global count
+                                    print(count)
+                                    count = 0
+                                elif chess_map[x][y].color == 0: #不用解锁
+                                    lock[0] = x
+                                    lock[1] = y
+                    return
+        return
+
+    def run(self, depth)->None:
+        chess_map = self.chess_map
+        get_ans = self.get_ans
+        root = Tk()
+        canvas = Canvas(master = root, height = 550, width = 500)
+        canvas.bind("<Button-1>", partial(self.call_back, root, canvas, depth))
+        canvas.pack()
+        self.draw(root, canvas)
+        root.mainloop()
+
+
+
+
+
+if __name__ == "__main__":
+    test = map()
+    test.run(6)
\ No newline at end of file