Python | OpenCV 專案：天堂私服遊戲輔助（四）目標優先序選擇

# target_selector.py
import math
from typing import Callable, Dict, List, Optional


class TargetSelector:
    def __init__(self,
                 priority_classes: Optional[List[str]] = None,
                 min_conf: float = 0.0,
                 log_fn: Optional[Callable[[str], None]] = None):
        # detector.conf 已先做過一道信心度過濾；這裡 min_conf 預設 0 不重複過濾，
        # 想只鎖定高信心目標時才拉高
        self.priority  = list(priority_classes or [])
        self.min_conf  = min_conf
        self._log      = log_fn or (lambda msg: None)
        self._last_key = None   # (name, center) — 只在目標切換時寫日誌

    def select(self, detections: List[Dict],
               frame_center: Optional[tuple] = None) -> Optional[Dict]:
        """從偵測結果中選出最優先目標；無可選目標則回傳 None"""
        valid = [d for d in detections if d["conf"] >= self.min_conf]
        if not valid:
            if self._last_key is not None:
                self._log("目標：無")
                self._last_key = None
            return None

        def sort_key(d):
            name = d["name"]
            try:
                prio = self.priority.index(name)
            except ValueError:
                prio = len(self.priority)     # 未列出的類別排最後
            dist = 0.0
            if frame_center:
                cx, cy = d["center"]
                dist = math.hypot(cx - frame_center[0], cy - frame_center[1])
            return (prio, dist)

        valid.sort(key=sort_key)
        target = valid[0]

        key = (target["name"], target["center"])
        if key != self._last_key:
            self._log(
                f"🎯 鎖定目標：{target['name']} "
                f"({target['conf']:.2f}) @ {target['center']}"
            )
            self._last_key = key
        return target

# detector.py
from typing import Dict, List, Literal, Optional

import cv2
import numpy as np
from ultralytics import YOLO

from window_capture import (get_game_roi, get_tile_px,
                            TILES_PER_HALF_WIDTH, TILES_PER_HALF_HEIGHT)

# 菱形視野邊界（把螢幕上「左右 ±8 / 上下 ±10」換算回 iso 世界座標）
VIEW_EW    = 2 * TILES_PER_HALF_WIDTH    # 東西邊界：|wx + wy| ≤ 16
VIEW_NS    = 2 * TILES_PER_HALF_HEIGHT   # 南北邊界：|wy - wx| ≤ 20
GRID_HALF  = (VIEW_EW + VIEW_NS) // 2    # 迴圈迭代半徑（菱形 4 角 |wx|/|wy| 最大 = 18）

CANVAS_W   = 200                         # 小地圖畫布寬（視野寬 16·DW = 192，加一點邊距）
CANVAS_H   = 130                         # 小地圖畫布高（視野高 20·DH = 120，加一點邊距）


class Detector:
    def __init__(self, model_path: str, conf: float = 0.5):
        self.model   = YOLO(model_path)
        self.conf    = conf
        self.enabled = True
        self.mode: Literal["live", "grid"] = "live"

    def detect(self, frame) -> List[Dict]:
        """回傳偵測結果，每筆為：
        {"name": str, "conf": float,
         "box": (x1, y1, x2, y2), "center": (cx, cy)}
        """
        results = self.model(frame, conf=self.conf, verbose=False)
        detections = []
        for r in results:
            for box in r.boxes:
                name = self.model.names[int(box.cls)]
                c    = float(box.conf)
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
                detections.append({
                    "name": name, "conf": c,
                    "box": (x1, y1, x2, y2), "center": (cx, cy)
                })
        return detections

    def render(self, frame, detections: List[Dict],
               target: Optional[Dict] = None):      # ← 本篇新增 target 參數
        """主執行緒呼叫入口：依 mode 派發到 annotate / render_grid，並把 target 傳下去"""
        if self.mode == "grid":
            return self.render_grid(frame, detections, target=target)   # ← 本篇新增
        return self.annotate(frame, detections, target=target)

    def annotate(self, frame, detections: List[Dict],
                 target: Optional[Dict] = None):
        """live 模式：在原畫面上繪製偵測框（鎖定目標畫紅色，其他畫綠色）"""
        out = frame.copy()
        for d in detections:
            x1, y1, x2, y2 = d["box"]
            color = (0, 0, 220) if (target and d is target) else (0, 220, 0)
            cv2.rectangle(out, (x1, y1), (x2, y2), color, 2)
            label = f"{d['name']} {d['conf']:.2f}"
            cv2.putText(out, label, (x1, y1 - 6),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
        return out

    def render_grid(self, frame, detections: List[Dict],
                    target: Optional[Dict] = None):  # ← 本篇新增 target 參數
        """grid 模式：以扁平等角菱形格呈現怪物相對方位；鎖定目標格填紅"""
        fh, fw = frame.shape[:2]
        rx, ry, rw, rh = get_game_roi(fw, fh)
        px, py = rx + rw / 2, ry + rh / 2    # 玩家像素座標（ROI 中心）
        tw, th = get_tile_px(fw, fh)          # 一格地磚像素：roi_w/16, roi_h/20（分母不同！）

        # 偵測中心 → 世界格座標；同時記錄 target 落在哪一格（本篇新增）
        monsters    = set()
        target_cell = None                                      # ← 本篇新增
        for d in detections:
            cx, cy = d["center"]
            dx, dy = cx - px, cy - py
            wx = round(dx / tw - dy / th)
            wy = round(dx / tw + dy / th)
            if abs(wx + wy) <= VIEW_EW and abs(wy - wx) <= VIEW_NS:
                monsters.add((wx, wy))
                if target is not None and d is target:          # ← 本篇新增
                    target_cell = (wx, wy)

        canvas = np.full((CANVAS_H, CANVAS_W, 3), 26, dtype=np.uint8)
        ccx, ccy = CANVAS_W // 2, CANVAS_H // 2
        DW, DH   = 12, 6

        WHITE, BLACK  = (240, 240, 240), (16, 16, 16)
        YELLOW, EDGE  = (0, 220, 255), (95, 95, 115)
        RED           = (0, 0, 220)                             # ← 本篇新增：鎖定目標色

        def diamond(wx, wy, fill, edge):
            cx = ccx + (wx + wy) * DW / 2
            cy = ccy + (wy - wx) * DH / 2
            pts = np.array([
                [cx,          cy - DH / 2],
                [cx + DW / 2, cy         ],
                [cx,          cy + DH / 2],
                [cx - DW / 2, cy         ],
            ], dtype=np.int32)
            if fill is not None:
                cv2.fillConvexPoly(canvas, pts, fill)
            cv2.polylines(canvas, [pts], True, edge, 1, cv2.LINE_AA)

        for wx in range(-GRID_HALF, GRID_HALF + 1):
            for wy in range(-GRID_HALF, GRID_HALF + 1):
                if abs(wx + wy) > VIEW_EW: continue
                if abs(wy - wx) > VIEW_NS: continue
                if wx == 0 and wy == 0:
                    diamond(wx, wy, BLACK, WHITE)               # 玩家
                elif (wx, wy) == target_cell:                   # ← 本篇新增分支
                    diamond(wx, wy, RED, WHITE)                 #    鎖定目標：紅底 + 白邊
                elif (wx, wy) in monsters:
                    diamond(wx, wy, YELLOW, EDGE)               # 其他怪物
                else:
                    diamond(wx, wy, None, EDGE)                 # 空格
        return canvas