import tkinter as tk
from tkinter import messagebox, font
import random
import time
import threading
import math
import json

class Game:
    def __init__(self, root):
        self.root = root
        self.root.title("彩虹六号：炸弹冲锋2D简化版")
        self.root.geometry("1024x768")
        self.root.resizable(False, False)
        
        # 设置中文字体
        self.font_family = "SimHei"
        
        # 游戏状态
        self.game_active = False
        self.defender_turn = False
        self.attacker_turn = False
        self.bomb_planted = False
        self.bomb_defused = False
        self.defender_wins = False
        self.attacker_wins = False
        
        # 计时器相关
        self.defense_timer = 60  # 1分钟防御准备时间
        self.game_timer = 300  # 5分钟游戏时间
        self.timer_running = False
        
        # 玩家和AI数量
        self.player_count = 1
        self.ai_count = 4
        self.total_players = self.player_count + self.ai_count
        
        # 游戏对象
        self.defenders = []
        self.attackers = []
        self.defense_objects = []
        self.bomb_site = {"x": 512, "y": 384, "radius": 50}
        self.defuser = None
        
        # 地图障碍物（银行内部结构）
        self.obstacles = [
            # 外墙
            (50, 50, 974, 100), (50, 618, 974, 668),
            (50, 50, 100, 618), (924, 50, 974, 618),
            
            # 大厅柱子
            (200, 200, 250, 250), (400, 200, 450, 250),
            (600, 200, 650, 250), (800, 200, 850, 250),
            (200, 400, 250, 450), (400, 400, 450, 450),
            (600, 400, 650, 450), (800, 400, 850, 450),
            
            # 金库外墙
            (450, 300, 574, 350), (450, 424, 574, 474),
            (450, 300, 500, 474), (524, 300, 574, 474),
            
            # 金库内室
            (475, 325, 550, 450),
            
            # 内部墙壁
            (300, 150, 350, 300), (650, 150, 700, 300),
            (300, 400, 350, 550), (650, 400, 700, 550),
            
            # 柜台
            (350, 250, 674, 300),
            
            # 可破坏障碍物
            (150, 150, 200, 200, "breakable"),
            (824, 150, 874, 200, "breakable"),
            (150, 450, 200, 500, "breakable"),
            (824, 450, 874, 500, "breakable"),
        ]
        
        # 银行内部结构
        self.bank_structure = {
            "floors": 2,  # 地面层和地下层
            "elevators": [
                {"x": 200, "y": 300, "width": 50, "height": 50},
                {"x": 800, "y": 300, "width": 50, "height": 50}
            ],
            "doors": [
                {"x": 100, "y": 300, "width": 50, "height": 50, "state": "closed"},
                {"x": 924, "y": 300, "width": 50, "height": 50, "state": "closed"},
                {"x": 500, "y": 300, "width": 24, "height": 50, "state": "locked"}  # 金库门
            ]
        }
        
        # 玩家控制变量
        self.player_speed = 5
        self.key_pressed = {"w": False, "a": False, "s": False, "d": False}
        self.mouse_x = 512  # 鼠标X坐标
        self.mouse_y = 384  # 鼠标Y坐标
        self.player_direction = 0  # 玩家朝向角度
        
        # 创建开始界面
        self.create_start_screen()
    
    def create_start_screen(self):
        # 清除现有界面
        for widget in self.root.winfo_children():
            widget.destroy()
        
        # 创建开始界面
        start_frame = tk.Frame(self.root, bg="#1a1a2e")
        start_frame.pack(fill=tk.BOTH, expand=True)
        
        # 游戏标题
        title_font = font.Font(family=self.font_family, size=36, weight="bold")
        title_label = tk.Label(start_frame, text="彩虹六号：炸弹冲锋2D简化版", font=title_font, fg="#e94560", bg="#1a1a2e")
        title_label.pack(pady=50)
        
        # 版权信息
        copyright_font = font.Font(family=self.font_family, size=12)
        copyright_label = tk.Label(start_frame, text="Ubisoft&BCZOZ70371", font=copyright_font, fg="#e94560", bg="#1a1a2e")
        copyright_label.pack(pady=10)
        
        # 操作说明
        controls_font = font.Font(family=self.font_family, size=14)
        controls_label = tk.Label(start_frame, text="WASD移动，鼠标瞄准，左键射击", font=controls_font, fg="white", bg="#1a1a2e")
        controls_label.pack(pady=20)
        
        # 阵营选择按钮
        button_frame = tk.Frame(start_frame, bg="#1a1a2e")
        button_frame.pack(pady=100)
        
        defender_btn = tk.Button(button_frame, text="选择防守方", command=self.select_defender,
                                font=(self.font_family, 16), bg="#4CAF50", fg="white",
                                width=15, height=2, cursor="hand2")
        defender_btn.pack(side=tk.LEFT, padx=20)
        
        attacker_btn = tk.Button(button_frame, text="选择进攻方", command=self.select_attacker,
                                font=(self.font_family, 16), bg="#F44336", fg="white",
                                width=15, height=2, cursor="hand2")
        attacker_btn.pack(side=tk.LEFT, padx=20)
    
    def select_defender(self):
        self.defender_turn = True
        self.create_game_screen()
        self.initialize_defenders()
        self.start_defense_prep_phase()
        self.setup_player_controls()
    
    def select_attacker(self):
        self.attacker_turn = True
        self.create_game_screen()
        self.initialize_attackers()
        self.initialize_defenders()  # AI防守方
        self.start_attack_phase()
        self.setup_player_controls()
    
    def create_game_screen(self):
        # 清除现有界面
        for widget in self.root.winfo_children():
            widget.destroy()
        
        # 创建游戏界面
        self.game_frame = tk.Frame(self.root, bg="#0f3460")
        self.game_frame.pack(fill=tk.BOTH, expand=True)
        
        # 创建游戏画布
        self.canvas = tk.Canvas(self.game_frame, bg="#16213e", width=1024, height=668)
        self.canvas.pack()
        
        # 绘制银行地图
        self.draw_realistic_bank()
        
        # 创建状态面板
        self.status_frame = tk.Frame(self.game_frame, bg="#0f3460", height=100)
        self.status_frame.pack(fill=tk.X)
        
        # 计时器
        self.timer_label = tk.Label(self.status_frame, text="01:00", font=(self.font_family, 24), fg="white", bg="#0f3460")
        self.timer_label.pack(side=tk.LEFT, padx=20)
        
        # 玩家状态
        self.player_status_label = tk.Label(self.status_frame, text="玩家状态", font=(self.font_family, 14), fg="white", bg="#0f3460")
        self.player_status_label.pack(side=tk.LEFT, padx=20)
        
        # 游戏状态
        self.game_status_label = tk.Label(self.status_frame, text="游戏状态", font=(self.font_family, 14), fg="white", bg="#0f3460")
        self.game_status_label.pack(side=tk.RIGHT, padx=20)
    
    def draw_realistic_bank(self):
        # 绘制银行外部轮廓
        self.canvas.create_rectangle(50, 50, 974, 618, fill="#2c497f", outline="#e94560", width=2)
        
        # 绘制玻璃幕墙
        self.canvas.create_rectangle(100, 100, 924, 568, fill="#16213e", outline="#2c497f", width=5)
        
        # 绘制大理石柱子
        for x in [200, 400, 600, 800]:
            for y in [200, 400]:
                # 柱子底部
                self.canvas.create_oval(x-20, y-20, x+20, y+20, fill="#d0d0d0", outline="#a0a0a0")
                # 柱子主体
                self.canvas.create_rectangle(x-15, y-20, x+15, y+100, fill="#e0e0e0", outline="#c0c0c0")
                # 柱子顶部
                self.canvas.create_oval(x-20, y+100, x+20, y+120, fill="#d0d0d0", outline="#a0a0a0")
        
        # 绘制银行标志
        self.canvas.create_text(512, 75, text="BANK OF RAINBOW", font=(self.font_family, 24, "bold"), fill="#e94560")
        
        # 绘制金库区域
        self.canvas.create_rectangle(self.bomb_site["x"] - self.bomb_site["radius"], 
                                    self.bomb_site["y"] - self.bomb_site["radius"],
                                    self.bomb_site["x"] + self.bomb_site["radius"], 
                                    self.bomb_site["y"] + self.bomb_site["radius"],
                                    fill="#1a1a2e", outline="#e94560", width=3)
        
        # 绘制金库门
        self.canvas.create_rectangle(500, 300, 524, 350, fill="#808080", outline="#404040", width=2)
        self.canvas.create_text(512, 325, text="金库", font=(self.font_family, 12), fill="white")
        
        # 绘制入口
        self.canvas.create_rectangle(100, 284, 150, 334, fill="#16213e", outline="#e94560", width=2)  # 左入口
        self.canvas.create_rectangle(874, 284, 924, 334, fill="#16213e", outline="#e94560", width=2)  # 右入口
        
        # 绘制银行柜台
        self.canvas.create_rectangle(350, 250, 674, 300, fill="#8b4513", outline="#a0522d", width=2)
        self.canvas.create_rectangle(360, 260, 664, 290, fill="#a0522d", width=0)
        
        # 绘制ATM机
        self.canvas.create_rectangle(200, 150, 250, 200, fill="#808080", outline="#a0a0a0", width=2)
        self.canvas.create_rectangle(800, 150, 850, 200, fill="#808080", outline="#a0a0a0", width=2)
        
        # 绘制障碍物
        for obs in self.obstacles:
            if len(obs) == 5 and obs[4] == "breakable":
                # 可破坏障碍物
                self.canvas.create_rectangle(obs[0], obs[1], obs[2], obs[3], fill="#8b4513", outline="#a0522d")
                self.canvas.create_rectangle(obs[0]+5, obs[1]+5, obs[2]-5, obs[3]-5, fill="#a0522d", width=0)
            else:
                # 普通障碍物
                self.canvas.create_rectangle(obs[0], obs[1], obs[2], obs[3], fill="#1a1a2e", outline="#e94560")
                self.canvas.create_rectangle(obs[0]+5, obs[1]+5, obs[2]-5, obs[3]-5, fill="#2d3748", width=0)
        
        # 绘制灯光效果
        self.draw_lighting_system()
    
    def draw_lighting_system(self):
        # 绘制天花板灯光
        for x in range(150, 900, 150):
            for y in range(150, 550, 150):
                # 主光源
                self.canvas.create_oval(x-10, y-10, x+10, y+10, fill="#f0e68c", outline="#fffacd", width=1)
                # 光晕效果
                self.canvas.create_oval(x-20, y-20, x+20, y+20, fill="#f0e68c", outline="", width=0, stipple="gray50")
        
        # 绘制应急灯
        self.canvas.create_oval(50, 300, 70, 320, fill="#ff0000", outline="#8b0000", width=1)
        self.canvas.create_oval(954, 300, 974, 320, fill="#ff0000", outline="#8b0000", width=1)
    
    def initialize_defenders(self):
        # 清空现有防守方
        self.defenders = []
        
        # 创建玩家控制的防守方
        if self.defender_turn:
            player_defender = {"id": 0, "x": 512, "y": 384, "health": 100, "is_player": True, "role": "defender",
                              "ai": None, "state": "patrol", "path": [], "target": None, "cover_points": self.generate_cover_points(),
                              "memory": {"visited_positions": [], "trap_positions": [], "enemy_positions": []}}
            self.defenders.append(player_defender)
            
            # 绘制玩家
            self.draw_unit(player_defender, "blue")
        
        # 创建AI控制的防守方
        for i in range(1, self.total_players):
            # 随机位置，确保不在障碍物内
            while True:
                x = random.randint(200, 800)
                y = random.randint(200, 500)
                if not self.is_in_obstacle(x, y):
                    break
                    
            ai_defender = {"id": i, "x": x, "y": y, 
                          "health": 100, "is_player": False, "role": "defender",
                          "ai": AdvancedAI(self), "state": "patrol", "path": [], 
                          "target": None, "cover_points": self.generate_cover_points(),
                          "difficulty": random.choice([1, 2, 3]),  # 1=简单，2=中等，3=困难
                          "behavior_pattern": random.choice(["aggressive", "defensive", "ambush", "support"]),
                          "memory": {"visited_positions": [], "trap_positions": [], "enemy_positions": []},
                          "behavior_timer": 0}
            self.defenders.append(ai_defender)
            
            # 绘制AI
            self.draw_unit(ai_defender, "blue")
    
    def initialize_attackers(self):
        # 清空现有进攻方
        self.attackers = []
        
        # 创建玩家控制的进攻方
        if self.attacker_turn:
            player_attacker = {"id": 0, "x": 100, "y": 334, "health": 100, "is_player": True, "role": "attacker",
                              "ai": None, "state": "patrol", "path": [], "target": None, "cover_points": self.generate_cover_points(),
                              "memory": {"visited_positions": [], "trap_positions": [], "enemy_positions": []}}
            self.attackers.append(player_attacker)
            
            # 绘制玩家
            self.draw_unit(player_attacker, "red")
        
        # 创建AI控制的进攻方
        for i in range(1, self.total_players):
            # 随机选择左侧或右侧入口
            if random.choice([True, False]):
                x = 100
                y = random.randint(284, 384)
            else:
                x = 924
                y = random.randint(284, 384)
                
            ai_attacker = {"id": i, "x": x, "y": y, "health": 100, "is_player": False, "role": "attacker",
                          "ai": AdvancedAI(self), "state": "patrol", "path": [], 
                          "target": None, "cover_points": self.generate_cover_points(),
                          "difficulty": random.choice([1, 2, 3]),  # 1=简单，2=中等，3=困难
                          "behavior_pattern": random.choice(["aggressive", "cautious", "flank", "support"]),
                          "memory": {"visited_positions": [], "trap_positions": [], "enemy_positions": []},
                          "behavior_timer": 0}
            self.attackers.append(ai_attacker)
            
            # 绘制AI
            self.draw_unit(ai_attacker, "red")
    
    def generate_cover_points(self):
        # 自动生成地图掩体点（障碍物边缘）
        cover = []
        for obs in self.obstacles:
            if len(obs) >= 4:  # 确保是有效的障碍物
                cover.append((obs[0]-10, obs[1]-10))  # 左上
                cover.append((obs[2]+10, obs[1]-10))  # 右上
                cover.append((obs[0]-10, obs[3]+10))  # 左下
                cover.append((obs[2]+10, obs[3]+10))  # 右下
        return cover
    
    def draw_unit(self, unit, color):
        size = 10  # 统一单位大小
        if unit["is_player"]:
            size = 15  # 玩家略大
            
        # 绘制单位
        unit["canvas_obj"] = self.canvas.create_oval(unit["x"] - size, unit["y"] - size,
                                                    unit["x"] + size, unit["y"] + size,
                                                    fill=color)
        
        # 绘制单位ID
        unit["canvas_text"] = self.canvas.create_text(unit["x"], unit["y"], 
                                                      text=str(unit["id"]), 
                                                      fill="white", 
                                                      font=(self.font_family, 10))
        
        # 绘制玩家朝向指示器
        if unit["is_player"]:
            unit["direction_line"] = self.canvas.create_line(
                unit["x"], unit["y"], 
                unit["x"] + math.cos(0) * 20, 
                unit["y"] + math.sin(0) * 20, 
                fill="yellow", width=2)
        
        # 绘制AI状态指示器
        if not unit["is_player"]:
            unit["state_indicator"] = self.canvas.create_text(
                unit["x"], unit["y"] - 20,
                text="P",  # P=巡逻，A=攻击，D=防御，R=撤退，B=埋伏，F=包抄
                fill="white",
                font=(self.font_family, 8)
            )
            
            # 绘制AI行为模式指示器
            behavior_colors = {
                "aggressive": "red",
                "defensive": "blue",
                "ambush": "purple",
                "support": "green",
                "cautious": "yellow",
                "flank": "orange"
            }
            
            unit["behavior_indicator"] = self.canvas.create_oval(
                unit["x"] - 3, unit["y"] - 3,
                unit["x"] + 3, unit["y"] + 3,
                fill=behavior_colors.get(unit["behavior_pattern"], "white"),
                outline=""
            )
    
    def start_defense_prep_phase(self):
        self.game_status_label.config(text="防守方准备阶段")
        self.timer_label.config(text="{:02d}:{:02d}".format(self.defense_timer//60, self.defense_timer%60))
        self.timer_running = True
        
        # 启动计时器线程
        timer_thread = threading.Thread(target=self.run_defense_timer)
        timer_thread.daemon = True
        timer_thread.start()
        
        # 启动AI防守准备
        if not self.defender_turn:  # 如果玩家是进攻方，AI需要准备防守
            self.run_ai_defense_prep()
    
    def run_defense_timer(self):
        while self.defense_timer > 0 and self.timer_running:
            time.sleep(1)
            self.defense_timer -= 1
            self.root.after(0, lambda: self.timer_label.config(
                text="{:02d}:{:02d}".format(self.defense_timer//60, self.defense_timer%60)))
            
            # 更新AI防御布置
            if not self.defender_turn:
                self.root.after(0, self.update_ai_defense_prep)
        
        if self.timer_running:
            self.root.after(0, self.start_attack_phase)
    
    def run_ai_defense_prep(self):
        # AI防守准备逻辑
        for defender in self.defenders:
            if not defender["is_player"]:
                # 在炸弹区域附近布置防御
                if random.random() < 0.8:  # 提高布置概率
                    # 放置摄像头
                    cam_x = self.bomb_site["x"] + random.randint(-150, 150)
                    cam_y = self.bomb_site["y"] + random.randint(-150, 150)
                    if not self.is_in_obstacle(cam_x, cam_y):
                        self.defense_objects.append({"type": "camera", "x": cam_x, "y": cam_y, "health": 100})
                        
                        # 绘制摄像头
                        cam_obj = self.canvas.create_oval(cam_x - 5, cam_y - 5, cam_x + 5, cam_y + 5, fill="yellow")
                        # 绘制摄像头视野
                        self.canvas.create_arc(cam_x - 50, cam_y - 50, cam_x + 50, cam_y + 50, 
                                              start=0, extent=120, fill="#32cd32", stipple="gray25")
                
                # 放置陷阱
                if random.random() < 0.8:  # 提高布置概率
                    trap_x = self.bomb_site["x"] + random.randint(-100, 100)
                    trap_y = self.bomb_site["y"] + random.randint(-100, 100)
                    if not self.is_in_obstacle(trap_x, trap_y):
                        trap_type = random.choice(["claymore", "tripwire", "impact"])
                        damage = 30 if trap_type == "claymore" else 15
                        self.defense_objects.append({
                            "type": "trap", 
                            "trap_type": trap_type,
                            "x": trap_x, 
                            "y": trap_y, 
                            "health": 100,
                            "damage": damage,
                            "triggered": False,
                            "trigger_radius": 20 if trap_type == "tripwire" else 30
                        })
                        
                        # 绘制陷阱
                        trap_color = "purple" if trap_type == "claymore" else "orange"
                        self.canvas.create_rectangle(trap_x - 5, trap_y - 5, trap_x + 5, trap_y + 5, fill=trap_color)
        
        # 分配防守区域
        self.assign_defense_positions()
    
    def assign_defense_positions(self):
        # 为防守方AI分配防守位置
        defense_positions = [
            (450, 300), (574, 300),  # 金库上方
            (450, 474), (574, 474),  # 金库下方
            (450, 384), (574, 384),  # 金库两侧
            (512, 250), (512, 518)   # 金库前后
        ]
        
        # 随机分配位置
        random.shuffle(defense_positions)
        
        for i, defender in enumerate(self.defenders):
            if not defender["is_player"] and i < len(defense_positions):
                pos = defense_positions[i]
                defender["defense_position"] = pos
                defender["path"] = self.astar((defender["x"], defender["y"]), pos)
    
    def update_ai_defense_prep(self):
        # 继续更新AI防御布置
        for defender in self.defenders:
            if not defender["is_player"]:
                # 如果有防御位置，移动到指定位置
                if "defense_position" in defender:
                    self.follow_path(defender)
                elif random.random() < 0.5:  # 提高行动概率
                    # 随机巡逻
                    target_x = self.bomb_site["x"] + random.randint(-150, 150)
                    target_y = self.bomb_site["y"] + random.randint(-150, 150)
                    
                    # 生成路径
                    defender["path"] = self.astar((defender["x"], defender["y"]), (target_x, target_y))
    
    def start_attack_phase(self):
        self.timer_running = False
        self.defense_timer = 60  # 重置防御计时器
        
        # 开始攻击阶段
        self.game_active = True
        self.game_status_label.config(text="战斗阶段")
        self.game_timer = 300  # 5分钟游戏时间
        self.timer_label.config(text="{:02d}:{:02d}".format(self.game_timer//60, self.game_timer%60))
        self.timer_running = True
        
        # 启动游戏计时器线程
        game_timer_thread = threading.Thread(target=self.run_game_timer)
        game_timer_thread.daemon = True
        game_timer_thread.start()
        
        # 启动AI行动
        if self.attacker_turn:
            # 玩家是进攻方，AI控制防守方
            self.start_ai_defense_actions()
        else:
            # 玩家是防守方，AI控制进攻方
            self.start_ai_attack_actions()
    
    def run_game_timer(self):
        while self.game_timer > 0 and self.timer_running and not self.defender_wins and not self.attacker_wins:
            time.sleep(1)
            self.game_timer -= 1
            self.root.after(0, lambda: self.timer_label.config(
                text="{:02d}:{:02d}".format(self.game_timer//60, self.game_timer%60)))
            
            # 更新AI行动
            if self.attacker_turn:
                self.root.after(0, self.update_ai_defense_actions)
            else:
                self.root.after(0, self.update_ai_attack_actions)
        
        if self.timer_running and not self.defender_wins and not self.attacker_wins:
            # 时间到，检查胜利条件
            self.root.after(0, self.check_win_conditions)
    
    def start_ai_defense_actions(self):
        # 防守AI初始行动
        pass
    
    def update_ai_defense_actions(self):
        # 更新防守AI行动
        for defender in self.defenders:
            if not defender["is_player"] and defender["health"] > 0:
                # 更新状态指示器
                self.canvas.itemconfig(defender["state_indicator"], text=defender["state"][0])
                
                # 根据AI难度调整行为
                difficulty_modifier = 1.0 + (defender["difficulty"] - 1) * 0.5
                
                # 检测进攻方
                nearest_attacker = self.find_nearest_enemy(defender, self.attackers)
                
                # 更新记忆
                self.update_ai_memory(defender)
                
                # 检查是否需要触发陷阱
                self.check_trap_trigger(defender)
                
                # 根据行为模式选择行动
                self.ai_behavior_pattern(defender)
                
                if nearest_attacker and self.distance(defender, nearest_attacker) < 300 * difficulty_modifier:
                    # 发现敌人
                    if self.has_line_of_sight(defender, nearest_attacker):
                        # 有视线，进入攻击状态
                        defender["state"] = "attack"
                        defender["target"] = nearest_attacker
                        
                        # 移动到有利位置
                        if random.random() < 0.7 * difficulty_modifier:
                            # 寻找掩体
                            cover = self.find_best_cover(defender, nearest_attacker)
                            if cover:
                                defender["path"] = self.astar((defender["x"], defender["y"]), cover)
                        
                        # 计算朝向角度
                        angle = math.atan2(nearest_attacker["y"] - defender["y"], nearest_attacker["x"] - defender["x"])
                        
                        # 根据难度调整命中率
                        hit_chance = 0.5 + (defender["difficulty"] - 1) * 0.15
                        
                        # 射击
                        if random.random() < 0.6 * difficulty_modifier:
                            self.shoot_at(defender, nearest_attacker, angle, hit_chance)
                    else:
                        # 没有视线，进入搜索状态
                        defender["state"] = "search"
                        
                        # 移动到最后看到敌人的位置
                        if defender["target"]:
                            last_seen = (defender["target"]["x"], defender["target"]["y"])
                            defender["path"] = self.astar((defender["x"], defender["y"]), last_seen)
                else:
                    # 没有发现敌人
                    if defender["state"] == "attack" or defender["state"] == "search":
                        # 从战斗状态恢复，回到防守位置
                        defender["state"] = "return"
                        if "defense_position" in defender:
                            defender["path"] = self.astar((defender["x"], defender["y"]), defender["defense_position"])
                    elif defender["state"] == "return" and not defender["path"]:
                        # 已回到防守位置，进入巡逻状态
                        defender["state"] = "patrol"
                    
                    # 巡逻或守卫
                    if defender["state"] == "patrol" and random.random() < 0.3 * difficulty_modifier:
                        # 随机巡逻或使用记忆中的位置
                        if random.random() < 0.7 and defender["memory"]["visited_positions"]:
                            # 使用记忆中的位置
                            target_pos = random.choice(defender["memory"]["visited_positions"])
                        else:
                            # 随机巡逻
                            target_x = self.bomb_site["x"] + random.randint(-150, 150)
                            target_y = self.bomb_site["y"] + random.randint(-150, 150)
                            target_pos = (target_x, target_y)
                        
                        defender["path"] = self.astar((defender["x"], defender["y"]), target_pos)
                
                # 跟随路径移动
                self.follow_path(defender)
                
                # 检查是否需要拆除拆弹器
                if self.bomb_planted and self.distance(defender, self.defuser) < 30:
                    self.root.after(0, self.defend_defuser)
    
    def start_ai_attack_actions(self):
        # 进攻AI初始行动
        pass
    
    def update_ai_attack_actions(self):
        # 更新进攻AI行动
        for attacker in self.attackers:
            if not attacker["is_player"] and attacker["health"] > 0:
                # 更新状态指示器
                self.canvas.itemconfig(attacker["state_indicator"], text=attacker["state"][0])
                
                # 根据AI难度调整行为
                difficulty_modifier = 1.0 + (attacker["difficulty"] - 1) * 0.5
                
                # 检测防守方
                nearest_defender = self.find_nearest_enemy(attacker, self.defenders)
                
                # 更新记忆
                self.update_ai_memory(attacker)
                
                # 检查陷阱并躲避
                self.avoid_traps(attacker)
                
                # 根据行为模式选择行动
                self.ai_behavior_pattern(attacker)
                
                if nearest_defender and self.distance(attacker, nearest_defender) < 300 * difficulty_modifier:
                    # 发现敌人
                    if self.has_line_of_sight(attacker, nearest_defender):
                        # 有视线，进入攻击状态
                        attacker["state"] = "attack"
                        attacker["target"] = nearest_defender
                        
                        # 移动到有利位置
                        if random.random() < 0.7 * difficulty_modifier:
                            # 寻找掩体
                            cover = self.find_best_cover(attacker, nearest_defender)
                            if cover:
                                attacker["path"] = self.astar((attacker["x"], attacker["y"]), cover)
                        
                        # 计算朝向角度
                        angle = math.atan2(nearest_defender["y"] - attacker["y"], nearest_defender["x"] - attacker["x"])
                        
                        # 根据难度调整命中率
                        hit_chance = 0.5 + (attacker["difficulty"] - 1) * 0.15
                        
                        # 射击
                        if random.random() < 0.6 * difficulty_modifier:
                            self.shoot_at(attacker, nearest_defender, angle, hit_chance)
                    else:
                        # 没有视线，进入搜索状态
                        attacker["state"] = "search"
                        
                        # 移动到最后看到敌人的位置
                        if attacker["target"]:
                            last_seen = (attacker["target"]["x"], attacker["target"]["y"])
                            attacker["path"] = self.astar((attacker["x"], attacker["y"]), last_seen)
                else:
                    # 没有发现敌人
                    if attacker["state"] == "attack" or attacker["state"] == "search":
                        # 从战斗状态恢复，继续前往炸弹点
                        attacker["state"] = "advance"
                        attacker["path"] = self.astar((attacker["x"], attacker["y"]), 
                                                   (self.bomb_site["x"], self.bomb_site["y"]))
                    elif not self.bomb_planted:
                        # 没有炸弹，前往炸弹点
                        attacker["state"] = "advance"
                        attacker["path"] = self.astar((attacker["x"], attacker["y"]), 
                                                   (self.bomb_site["x"], self.bomb_site["y"]))
                    elif self.bomb_planted and self.distance(attacker, self.defuser) < 50:
                        # 已经在炸弹点附近，防守炸弹
                        attacker["state"] = "defend"
                    else:
                        # 炸弹已放置，前往防守炸弹
                        attacker["state"] = "defend"
                        attacker["path"] = self.astar((attacker["x"], attacker["y"]), 
                                                   (self.defuser["x"], self.defuser["y"]))
                
                # 跟随路径移动
                self.follow_path(attacker)
                
                # 检查是否可以放置炸弹
                if not self.bomb_planted and attacker["state"] == "advance" and \
                   self.distance(attacker, self.bomb_site) < self.bomb_site["radius"]:
                    self.root.after(0, lambda a=attacker: self.plant_defuser(a))
    
    def setup_player_controls(self):
        # 设置键盘和鼠标控制
        self.root.bind("<KeyPress>", self.on_key_press)
        self.root.bind("<KeyRelease>", self.on_key_release)
        self.canvas.bind("<Motion>", self.on_mouse_move)
        self.canvas.bind("<Button-1>", self.on_mouse_click)
    
    def on_key_press(self, event):
        if event.keysym.lower() in self.key_pressed:
            self.key_pressed[event.keysym.lower()] = True
    
    def on_key_release(self, event):
        if event.keysym.lower() in self.key_pressed:
            self.key_pressed[event.keysym.lower()] = False
    
    def on_mouse_move(self, event):
        self.mouse_x = event.x
        self.mouse_y = event.y
        
        # 更新玩家朝向
        if self.player_count > 0:
            player = self.defenders[0] if self.defender_turn else self.attackers[0]
            if player["is_player"]:
                angle = math.atan2(self.mouse_y - player["y"], self.mouse_x - player["x"])
                player["direction"] = angle
                
                # 更新朝向指示器
                self.canvas.coords(
                    player["direction_line"],
                    player["x"], player["y"],
                    player["x"] + math.cos(angle) * 20,
                    player["y"] + math.sin(angle) * 20
                )
    
    def on_mouse_click(self, event):
        if not self.game_active:
            return
            
        # 获取玩家
        player = self.defenders[0] if self.defender_turn else self.attackers[0]
        
        # 计算射击角度
        angle = math.atan2(self.mouse_y - player["y"], self.mouse_x - player["x"])
        
        # 射击
        if self.defender_turn:
            # 防守方射击进攻方
            for attacker in self.attackers:
                if self.has_line_of_sight(player, attacker):
                    hit = random.random() < 0.7  # 玩家命中率70%
                    self.shoot_at(player, attacker, angle, 0.7)
        else:
            # 进攻方射击防守方
            for defender in self.defenders:
                if self.has_line_of_sight(player, defender):
                    hit = random.random() < 0.7  # 玩家命中率70%
                    self.shoot_at(player, defender, angle, 0.7)
        
        # 检查是否击中防御设施
        for obj in self.defense_objects[:]:
            if self.distance(player, obj) < 50 and self.has_line_of_sight(player, obj):
                hit = random.random() < 0.7  # 玩家命中率70%
                if hit:
                    obj["health"] -= 25
                    if obj["health"] <= 0:
                        self.defense_objects.remove(obj)
                        # 从画布上删除
                        if "canvas_obj" in obj:
                            self.canvas.delete(obj["canvas_obj"])
                        if "canvas_arc" in obj:
                            self.canvas.delete(obj["canvas_arc"])
        
        # 检查是否可以放置炸弹（进攻方）
        if not self.defender_turn and not self.bomb_planted:
            if self.distance(player, self.bomb_site) < self.bomb_site["radius"]:
                self.plant_defuser(player)
    
    def plant_defuser(self, attacker):
        if not self.bomb_planted:
            self.bomb_planted = True
            self.defuser = {"x": attacker["x"], "y": attacker["y"], "defuse_time": 30}
            
            # 绘制拆弹器
            self.defuser["canvas_obj"] = self.canvas.create_rectangle(
                self.defuser["x"] - 10, self.defuser["y"] - 10,
                self.defuser["x"] + 10, self.defuser["y"] + 10,
                fill="orange")
            
            # 更新游戏状态
            self.game_status_label.config(text="拆弹器已放置！防守方需要阻止拆除")
            
            # 启动拆弹计时器
            defuse_thread = threading.Thread(target=self.run_defuse_timer)
            defuse_thread.daemon = True
            defuse_thread.start()
    
    def run_defuse_timer(self):
        while self.bomb_planted and self.defuser["defuse_time"] > 0 and not self.defender_wins:
            time.sleep(1)
            self.defuser["defuse_time"] -= 1
            self.root.after(0, lambda: self.game_status_label.config(
                text=f"拆弹器已放置！剩余时间: {self.defuser['defuse_time']}秒"))
        
        if self.bomb_planted and not self.defender_wins:
            # 炸弹爆炸，进攻方胜利
            self.root.after(0, self.attacker_victory)
    
    def defend_defuser(self):
        # 防守方拆除拆弹器
        self.bomb_planted = False
        self.canvas.delete(self.defuser["canvas_obj"])
        self.game_status_label.config(text="拆弹器已被防守方拆除！")
        
        # 延迟后检查胜利条件
        self.root.after(2000, self.check_win_conditions)
    
    def check_win_conditions(self):
        # 检查进攻方是否全部死亡
        all_attackers_dead = all(attacker["health"] <= 0 for attacker in self.attackers)
        
        # 检查防守方是否全部死亡
        all_defenders_dead = all(defender["health"] <= 0 for defender in self.defenders)
        
        # 检查炸弹状态
        bomb_exploded = self.bomb_planted and self.defuser["defuse_time"] <= 0
        bomb_defused = not self.bomb_planted and hasattr(self, 'defuser') and self.defuser is not None
        
        # 确定胜利方
        if all_attackers_dead or bomb_defused:
            self.defender_victory()
        elif all_defenders_dead or bomb_exploded:
            self.attacker_victory()
        elif self.game_timer <= 0 and self.bomb_planted:
            # 时间到，炸弹已放置，进攻方胜利
            self.attacker_victory()
        elif self.game_timer <= 0 and not self.bomb_planted:
            # 时间到，炸弹未放置，防守方胜利
            self.defender_victory()
    
    def attacker_victory(self):
        self.attacker_wins = True
        self.game_active = False
        self.timer_running = False
        self.game_status_label.config(text="进攻方胜利！")
        messagebox.showinfo("游戏结束", "进攻方胜利！")
        self.root.after(3000, self.create_start_screen)
    
    def defender_victory(self):
        self.defender_wins = True
        self.game_active = False
        self.timer_running = False
        self.game_status_label.config(text="防守方胜利！")
        messagebox.showinfo("游戏结束", "防守方胜利！")
        self.root.after(3000, self.create_start_screen)
    
    def shoot_at(self, shooter, target, angle, hit_chance):
        # 检查是否命中
        hit = random.random() < hit_chance
        
        # 绘制子弹轨迹
        bullet_end_x = shooter["x"] + math.cos(angle) * 300
        bullet_end_y = shooter["y"] + math.sin(angle) * 300
        
        # 检查子弹是否击中障碍物
        for obs in self.obstacles:
            if self.line_intersects_rect(shooter["x"], shooter["y"], bullet_end_x, bullet_end_y, 
                                         obs[0], obs[1], obs[2], obs[3]):
                # 计算交点
                intersection = self.line_rect_intersection(shooter["x"], shooter["y"], bullet_end_x, bullet_end_y, 
                                                         obs[0], obs[1], obs[2], obs[3])
                if intersection:
                    bullet_end_x, bullet_end_y = intersection
        
        # 绘制子弹
        bullet = self.canvas.create_line(
            shooter["x"], shooter["y"],
            bullet_end_x, bullet_end_y,
            fill="yellow", width=2
        )
        
        # 短暂显示子弹后删除
        self.root.after(100, lambda: self.canvas.delete(bullet))
        
        # 如果命中，减少目标生命值
        if hit and self.distance(shooter, target) < 300:
            # 检查是否有视线
            if self.has_line_of_sight(shooter, target):
                damage = 25
                target["health"] -= damage
                
                # 显示伤害数字
                damage_text = self.canvas.create_text(
                    target["x"], target["y"] - 20,
                    text=f"-{damage}",
                    fill="red",
                    font=(self.font_family, 12, "bold")
                )
                
                # 短暂显示伤害数字后删除
                self.root.after(1000, lambda t=damage_text: self.canvas.delete(t))
                
                # 检查目标是否死亡
                if target["health"] <= 0:
                    # 从画布上删除目标
                    self.canvas.delete(target["canvas_obj"])
                    self.canvas.delete(target["canvas_text"])
                    
                    if not target["is_player"]:
                        self.canvas.delete(target["state_indicator"])
                        self.canvas.delete(target["behavior_indicator"])
                    else:
                        self.canvas.delete(target["direction_line"])
    
    def has_line_of_sight(self, unit1, unit2):
        # 检查两点之间是否有障碍物
        x1, y1 = unit1["x"], unit1["y"]
        x2, y2 = unit2["x"], unit2["y"]
        
        for obs in self.obstacles:
            if self.line_intersects_rect(x1, y1, x2, y2, obs[0], obs[1], obs[2], obs[3]):
                return False
        return True
    
    def distance(self, obj1, obj2):
        # 计算两点之间的距离
        return math.sqrt((obj2["x"] - obj1["x"])**2 + (obj2["y"] - obj1["y"])**2)
    
    def is_in_obstacle(self, x, y):
        # 检查点是否在障碍物内
        for obs in self.obstacles:
            if obs[0] <= x <= obs[2] and obs[1] <= y <= obs[3]:
                return True
        return False