坦克競技場手冊

01總覽

每人各自寫一個規則策略（strategy.py）、錄下示範、訓練神經網路，一人繳交一份；比賽時上場的只有神經網路，規則策略不會執行。

1. 寫規則：用 if-else 寫規則策略。規則策略看得到完整狀態（所有坦克、子彈的位置與速度）。函數庫見第 7 節，範例見第 8 節。
2. 錄資料：在繳交網站的「策略與錄製」上傳 strategy.py，看試跑重播確認沒問題，再讓它打上千局，記下每一步「91 維觀測 → 策略的 5 個動作」（第 9 節）。
3. 訓練與匯出：用分類模型學規則策略的決定，5 個動作就是 5 個分類頭；訓練完匯出成 model.pt（第 10 節）。
4. 繳交、上場：上傳 model.pt 和期中報告（第 11 節）。天梯上只有模型在打，只拿得到 91 維觀測，沒有完整狀態。

手冊分三部分：規則（第 1～4 節）、坦克的輸入與輸出（第 5～6 節）、動手做（第 7～11 節，照做事的順序排）。

02計分方式

兩部分最後都由老師依全班分佈換算成學期成績。

每場得分 ＝ 擊殺數 ＋ 時間加成 ＋ 生命加成

競技分 ＝ 10 × 你的平均每場得分 ÷ 2，平均每場 2 分以上就拿滿 10 分，取到小數一位。排行榜會把它拆成擊殺、時間、生命三部分，讓你看出分數從哪裡來。

• 天梯每場 5 台，從所有同學的上場版本中隨機抽；人數不足時由範例 bot 補位，bot 不列入排名。每人至少打 200 場。
• 打到同一台的最後一發才算擊殺。
• 排行榜上的分數有 95% 區間，每人 200 場時大約 ±0.5 分：區間重疊的同學，差距可能只是運氣。
• 對手是同學的模型，全班的程度會影響你能拿到幾個擊殺，所以競技分最後會由老師依全班分佈換算。
• 三個部分的權重可能在公告後微調，排行榜下方永遠顯示目前用的算法。
• 報告用 Word 範本的 4 個表格寫：靠什麼贏、為什麼這樣設計、訓練結果、心得，詳見第 11 節。天梯名次與分數由系統統整，報告不用寫。

稱號與加分

天梯依整體數據頒發稱號，每個稱號只給一人，要先達到門檻，每個稱號 +0.3 分、最多 +0.6 分。總分 ＝ 競技分＋稱號加分，最高 10。排行榜依總分排名。

門檻是為了避免用極端打法刷稱號，例如只在貼臉時才開槍來衝命中率。專攻某個稱號是可以的策略，但要在報告裡說明你怎麼取捨。每場比賽結束時，觀戰頁也會頒發「本場稱號」，那些只是好玩、不加分。

03場地與縮圈

場地 800 × 800 像素，原點在左上角、y 軸朝下。牆擋住坦克、子彈與視線；地形射線只量牆和場邊。每局地圖由伺服器從兩張地圖中隨機選一張，連線時也可以用 map 指定。

縮圈

安全區圈心每局隨機，落在場地中心 ±80 的方形內（上圖虛線框）。第 10 秒開始縮，第 50 秒縮到半徑 90 後不再變小。

在圈外每秒扣 10 HP（每步 0.5）；裝了抗毒塗層每秒 5 HP。死在圈外的不算任何人的擊殺。

04坦克與模組

第一次登入繳交網站時，每人自選一種機體與一種模組，選定後整學期不能更換；練習、錄資料、訓練、比賽都用同一台，所有人用同一套數值。速度單位是「每步移動的像素」，每秒 20 步。

標準standard重裝heavy輕裝scout速射gunner長砲lancer

• 射程＝彈速 × 子彈存在的步數（速射 55 步，其餘 70 步）。
• 砲塔轉向所有機體相同：每秒 126°（每步 0.11 弧度），和車身各自獨立，可以一邊後退一邊往後開火。
• 後退速度是前進的 0.6 倍。開局有 1 秒射擊冷卻、3 秒技能冷卻。
• 平衡測試：2,500 場隨機配裝，各機體、模組的平均名次都在 3.00 ±10% 內。

模組

主動模組要自己決定「什麼時候按」（動作第 5 個值設成 1），這也是神經網路要學的一個決定；被動模組一直有效，按了也會被忽略。

冷卻從按下的那一刻開始算。冷卻中或作用中按下都會被忽略，不扣分。觀測第 89 維是剩餘冷卻比例（0＝就緒），第 90 維是否作用中。

05觀測：91 個數字

比賽時模型每一步只拿到這 91 個數字。方向都以自己的車頭為準：不論坦克在地圖哪裡，「右前方有敵人」看起來都一樣。數值大致落在 −1 到 1。

06動作：5 個分類頭

每一步送出 5 個整數，就是 Class 2 的分類問題一次做 5 個。超出範圍的值會被當成「不動、不開火」。

例：[0, 2, 1, 1, 0]＝前進、車身右轉、砲塔不動、開火、不用技能。冷卻中按開火無效，不扣分。

07寫規則策略：函數庫 strategy_lib

strategy.py 要定義 class Strategy，有 reset()（每局開始呼叫一次）和 act(state)（每一步呼叫，回傳 5 個整數）。可以 import strategy_lib、math、random、numpy、collections 等；不能讀寫檔案、連網路。state 是完整狀態，欄位見規格書第 3 節；一般用下面的 Me 整理過再用就好。

完整說明書（PDF）可以在繳交網站「① 我的坦克」下載，學生套件裡也有 client/docs/規則策略函數說明書.pdf。下面是同一份內容。

這份說明書教你用 strategy_lib 寫規則策略 strategy.py。第一次讀：先看 A（觀念）和 B（常見任務），照著改範例就能動；要查某個函數的參數，再翻 D（函數說明卡）。說明書裡的每個範例都實際跑過。

A　先懂的觀念

A1　座標與角度

場地 800×800 像素，原點在左上角，x 往右變大、y 往下變大。角度用弧度（π＝180°）：0 朝右、π/2 朝下、±π 朝左、−π/2 朝上；往右轉＝角度變大。程式裡通常不用自己算角度，用 me.direction_to(目標) 就好。

A2　坦克每一步要給 5 個數字

每 1/20 秒呼叫一次 act(state)，要回傳 5 個整數。通常不用自己寫數字，用 Action、Behavior 的函數加上 combine() 產生。

例：[0, 2, 1, 1, 0]＝前進、車身右轉、砲塔不動、開火、不按技能。車身和砲塔各自轉，所以可以一邊往前開、一邊往旁邊開火。每一步車身最多轉約 4°、砲塔約 6.3°；前進速度每步 2.5～3.8 像素（依機體），倒車是前進的 0.6 倍。

A3　combine：把幾張「小紙條」合成 5 個數字

每個 Action、Behavior 函數只負責其中幾格，回傳一張只寫了那幾格的小紙條（dict）。combine 從「什麼都不做」的預設值開始，照順序一張一張貼上去，最後變成 5 個數字：

move  = Behavior.keep_distance(me, e, 230)   # 例如 {"move": 0, "body": 2}   只管移動、車身
aim   = Action.aim_turret_at(me, e)          # 例如 {"turret": 0}            只管砲塔
fire  = Action.fire_when_aimed(me, e)        # 例如 {"fire": 1}              只管開火
skill = Action.use_skill_if(me, False)       # 例如 {"skill": 0}             只管技能
return combine(move, aim, fire, skill)

沒給的格子不是 0，而是「什麼都不做」的預設值（combine 一定回傳 5 個數字）：

所以 combine() 什麼都不給＝[2, 1, 1, 0, 0]（原地不動）；傳進去的是 None（例如自訂行為這一步沒事做）會直接跳過。

同一格貼兩次，後面的蓋掉前面的：combine(move, aim, fire, Action.hold_fire()) 裡，fire 先填「開火 1」，最後的 hold_fire 又填「開火 0」，所以一定不開火。想讓某個決定「最後說了算」，就放在最後面。

不用 combine 也可以：直接 return [0, 2, 0, 1, 0] 效果一樣。combine 只是讓你把「移動」交給 Behavior、「瞄準」交給 Action，各自決定好再合起來，不用記哪一格是第幾個。

A4　strategy.py 的骨架（每一行在做什麼）

from strategy_lib import Me, Memory, P, Action, Behavior, combine

# ① 常數與可調參數：寫在檔案最上面，名字用大寫，整場都不變
CHASSIS, MODULE = "standard", "boost"     # 你的配裝（網站下載的範本會自動填好）
KEEP_DIST = 230                           # 和敵人保持的距離（像素）
LOW_HP = 0.4                              # 血量低於多少就躲

class Strategy:                           # 類別名稱一定要叫 Strategy
    def reset(self):                      # ② 每局開始呼叫一次：在這裡建立「這局要記住」的變數
        self.memory = Memory()            #    Me 會用它記最後看到敵人的位置
        self.shots = 0                    #    自己的計數器：這局開了幾槍

    def act(self, state):                 # ③ 每一步（1/20 秒）呼叫一次，回傳 5 個整數
        me = Me(state, memory=self.memory)    # 把完整狀態整理成 me
        e = me.nearest_visible_enemy()        # 最近看得到的敵人，沒有就是 None

        # ④ 決定移動（這一步才用的變數，寫在 act() 裡就好）
        if me.outside_safe_zone(50):
            move = Behavior.go_to_safe_zone(me)
        elif e is None:
            move = Behavior.patrol(me)
        elif me.hp < LOW_HP:
            move = Behavior.hide_behind_wall(me, e)
        else:
            move = Behavior.keep_distance(me, e, KEEP_DIST)

        # ⑤ 瞄準、開火、技能
        aim = Action.aim_turret_at(me, e)
        fire = Action.fire_when_aimed(me, e)
        skill = Action.use_skill_if(me, me.bullet_coming())
        if fire["fire"]:
            self.shots += 1

        # ⑥ 合成 5 個整數回傳
        return combine(move, aim, fire, skill)

A5　變數要宣告在哪裡

不要用檔案最上面的變數記「會變的東西」（例如上一步的血量）：它不會在每局開始時清空。self.xxx 一定要先在 reset() 給初始值，否則第一次在 act() 讀它會出錯（AttributeError）。

A6　資料長什麼樣子

A7　清單怎麼用：visible、enemies、bullets、walls

清單（list）就是「很多個 dict 排在一起」：用 for 一個一個取出來，用 [0] 取第一個，用 len() 數有幾個。清單可能是空的（[]），用 [0] 之前先 if 清單: 檢查。 下面 A7～A11 的例子，都是從一場真的比賽（十字堡壘，第 28 步：看得到 2 台敵人、場上有 3 顆敵方子彈）抓下來的同一個瞬間，執行結果也是真的。

print(me.view)                           # 我的視線距離（雷達 450、其他 340）
print(len(me.visible), "台看得到、", len(me.enemies), "台還活著")

for e in me.visible:                       # 一台一台看：看得到的敵人，由近到遠
    print("敵人", round(e["x"]), round(e["y"]), "距離", round(me.distance_to(e)),
          "血", e["hp_frac"], e["chassis"], e["module"])

hidden = [e for e in me.enemies if e not in me.visible]     # 還活著但看不到的（牆後、太遠、隱身）
print("看不到的", len(hidden), "台")

if me.bullets:                             # 子彈清單可能是空的，先檢查
    b = min(me.bullets, key=me.distance_to)                # 最近的一顆敵方子彈
    print("最近的子彈", round(me.distance_to(b)), "像素，速度", round(b["vx"], 1), round(b["vy"], 1))

w = me.walls[0]                            # 第一面牆：左上角 (x, y)、寬 w、高 h
print("牆", w["x"], w["y"], w["w"], w["h"], "共", len(me.walls), "面")

執行結果：

340
2 台看得到、 4 台還活著
敵人 421 130 距離 324 血 1 gunner boost
敵人 519 646 距離 340 血 1 scout stealth
看不到的 2 台
最近的子彈 401 像素，速度 -11.0 -0.7
牆 370 260 60 280 共 8 面

A8　敵人資訊卡（me.visible、me.enemies 裡的每一個）

每一台敵人是一個 dict，用 e["欄位"] 取值。me.nearest_visible_enemy() 回傳的也是同樣的資訊卡（或 None）。

import math
from strategy_lib import wrap

e = me.visible[0]                                    # 最近的一台看得到的敵人
print("位置", round(e["x"]), round(e["y"]), "距離", round(me.distance_to(e)), "像素")
speed = math.hypot(e["vx"], e["vy"])                  # 上一步移動了幾像素（停著或被擋住＝0）
print("速度", round(speed, 2), "像素/步")
side = wrap(me.direction_to(e) - me.heading)          # 相對我的車頭：正＝在右邊、負＝在左邊
print("在我的", "右邊" if side > 0 else "左邊", abs(round(math.degrees(side))), "度")
back = math.atan2(me.y - e["y"], me.x - e["x"])       # 從敵人看向我的方向
print("它的砲口離對準我還差", abs(round(math.degrees(wrap(back - e["turret"])))), "度")
print("10 步後大約在", round(e["x"] + e["vx"] * 10), round(e["y"] + e["vy"] * 10))
print("血", round(e["hp_frac"] * 100), "%｜配裝", e["chassis"], e["module"], "｜隱身中" if e["stealthed"] else "｜沒有隱身")

執行結果：

位置 421 130 距離 324 像素
速度 3.0 像素/步
在我的 右邊 51 度
它的砲口離對準我還差 87 度
10 步後大約在 415 159
血 100 %｜配裝 gunner boost ｜沒有隱身

A9　子彈資訊卡（me.bullets 裡的每一顆）

子彈的規則：從砲口前方 24 像素射出；每步飛 11 像素（長砲 12.5），最多飛 70 步（速射 55），所以射程約 770（速射 605、長砲 875）；碰到牆或場邊就消失；離某台坦克中心不到 16 像素就算打中，扣 12 點（護盾作用中會先擋掉）。打不到自己。

import math

for b in me.bullets:                                  # 每一顆敵方子彈
    d = me.distance_to(b)
    speed = math.hypot(b["vx"], b["vy"])              # 11 像素/步（長砲 12.5）
    toward = (me.x - b["x"]) * b["vx"] + (me.y - b["y"]) * b["vy"] > 0    # 往我這邊飛嗎
    if toward:
        print("距離", round(d), "速度", round(speed, 1), "往我飛｜約", round(d / speed), "步後飛到我附近")
    else:
        print("距離", round(d), "速度", round(speed, 1), "遠離我｜不用理它")
print("會不會打到我（bullet_coming）：", me.bullet_coming())

執行結果：

距離 426 速度 11.0 往我飛｜約 39 步後飛到我附近
距離 401 速度 11.0 遠離我｜不用理它
距離 459 速度 11.0 往我飛｜約 42 步後飛到我附近
會不會打到我（bullet_coming）： False

A10　牆資訊卡（me.walls 裡的每一面）

牆是長方形，整局都不會變（十字堡壘 8 面、城區巷戰 9 面）。坦克開不過去、子彈打到就消失、視線會被擋住（me.can_see 就是在檢查有沒有牆擋）。

import math

w = me.walls[0]
print("左上角", (w["x"], w["y"]), "右下角", (w["x"] + w["w"], w["y"] + w["h"]), "中心", (w["x"] + w["w"] / 2, w["y"] + w["h"] / 2))

def inside(x, y, w):                                  # 點 (x, y) 在不在這面牆裡
    return w["x"] <= x <= w["x"] + w["w"] and w["y"] <= y <= w["y"] + w["h"]
print("點 (400, 400) 在第一面牆裡嗎：", inside(400, 400, w))

def gap(w):                                           # 我到這面牆最近的距離（0＝貼著牆）
    dx = max(w["x"] - me.x, 0, me.x - (w["x"] + w["w"]))
    dy = max(w["y"] - me.y, 0, me.y - (w["y"] + w["h"]))
    return math.hypot(dx, dy)
near = min(me.walls, key=gap)
print("離我最近的牆", near, "距離", round(gap(near)), "像素")

執行結果：

左上角 (370, 260) 右下角 (430, 540) 中心 (400.0, 400.0)
點 (400, 400) 在第一面牆裡嗎： True
離我最近的牆 {'x': 670, 'y': 370, 'w': 40, 'h': 60} 距離 30 像素

A11　安全區（me.zone_center、me.zone_r）

在圈外每秒扣 10 血（抗毒模組減半）。

c, r = me.zone_center, me.zone_r
edge = r - me.distance_to(c)                         # 正＝在圈內，離邊界還有多遠；負＝已經在圈外
print("圈心", round(c.x), round(c.y), "半徑", round(r), "｜我離邊界", round(edge), "像素，", "在圈內" if edge > 0 else "在圈外，每秒扣 10 血")

執行結果：

圈心 420 320 半徑 620 ｜我離邊界 372 像素， 在圈內

B　常見任務怎麼寫

下面的片段放在 act() 裡，假設前面已經有 me、e = me.nearest_visible_enemy()、move、aim、fire（見 A4 的骨架）。

B1　砲口轉向敵人、對準了就開火

最基本的攻擊：轉砲口和開火是兩件事，兩個都要寫。

aim = Action.aim_turret_at(me, e)          # 砲口轉向敵人（打提前量）
fire = Action.fire_when_aimed(me, e)       # 對準、裝填好、沒有牆擋，才開火
return combine(move, aim, fire)

B2　開到地圖上某個位置

目的地用 P(x, y)，x、y 是像素（0～800，左上角是原點）。

move = Action.drive_to(me, P(400, 400))              # 開到地圖中央
move = Action.drive_to(me, P(100, 700), arrive=30)    # 開到左下角附近，差 30 像素就算到

B3　往某個方向開（例如遠離敵人）

方向是角度（弧度）。敵人的方向加 π（180°）就是反方向。

import math
away = me.direction_to(e) + math.pi        # 敵人的反方向
move = Action.drive_in_direction(me, away)

B4　邊退邊打

倒車時車頭仍對著敵人，砲口另外瞄準。

move = Action.back_away_from(me, e)        # 車頭對著敵人往後退
return combine(move, Action.aim_turret_at(me, e), Action.fire_when_aimed(me, e))

B5　子彈飛來就開護盾（護盾模組）

護盾 2 秒內擋一發子彈，冷卻 20 秒，所以只在真的有子彈飛來時才開。

skill = Action.use_skill_if(me, me.bullet_coming())
return combine(move, aim, fire, skill)

B6　血少時隱身，隱身中不開火（隱身模組）

隱身中一開火就解除，所以隱身時要用 hold_fire 蓋掉開火。

skill = Action.use_skill_if(me, me.hp < 0.4 and e is not None)
if me.skill_active:
    fire = Action.hold_fire()                  # 隱身中不開火
return combine(move, aim, fire, skill)

B7　在圈外時衝刺回安全區（衝刺模組）

衝刺 1 秒內速度 ×2，期間不能開火，冷卻只有 6 秒。

if me.outside_safe_zone(0):
    move = Behavior.go_to_safe_zone(me)
    skill = Action.use_skill_if(me, True)      # 就緒就按
else:
    skill = Action.use_skill_if(me, False)

B8　記住上一步的血量，判斷是不是剛被打

每一步都會重新建立 me，要跨步記住的東西放在 self.memory。先在 reset() 裡給初始值：self.memory.prev_hp = 1.0

hurt = me.hp < self.memory.prev_hp           # 血比上一步少 → 剛被打
self.memory.prev_hp = me.hp                  # 記下來給下一步用
if hurt and e is not None:
    move = Behavior.hide_behind_wall(me, e)

B9　敵人躲起來時去找他

最近看過敵人但現在看不到，就開到最後看到的位置。

if e is None and me.saw_enemy_recently(80):
    move = Behavior.go_to_last_seen(me)
elif e is None:
    move = Behavior.patrol(me)

B10　只打血少的敵人

me.visible 是所有看得到的敵人（由近到遠），可以自己挑目標。

weak = [x for x in me.visible if x["hp_frac"] < 0.5]
target = weak[0] if weak else e              # 有血少的就打它，否則打最近的
aim = Action.aim_turret_at(me, target)
fire = Action.fire_when_aimed(me, target)

C　技能

主動技能用 Action.use_skill_if(me, 條件)：條件成立而且 me.skill_ready 才會真的按。每局開始有 3 秒不能按。me.skill_active 表示技能正在作用中。範例見 B5～B7。

D　函數說明卡

D0　函數總覽（先看這張表找函數，再看下面的說明卡）

me = Me(state, memory=self.memory)
if me.hp < 0.3 and me.skill_ready: ...

if e is not None and me.distance_to(e) < 200: ...   # 敵人在 200 像素內

ang = me.direction_to(e)
move = Action.drive_in_direction(me, ang + math.pi)   # 往敵人的反方向開

if me.can_see(me, e): ...                 # 我和敵人之間沒有牆

if me.clearance(me.heading) < 30:      # 車頭前面 30 像素內就是牆
    ...

if me.wall_gap() < 6 and me.speed < 0.3: ...   # 貼著牆、幾乎沒在動

e = me.nearest_visible_enemy()
if e is None:
    move = Behavior.patrol(me)

if me.outside_safe_zone(60):
    move = Behavior.go_to_safe_zone(me)

if e is None and me.saw_enemy_recently(60):
    move = Behavior.go_to_last_seen(me)

skill = Action.use_skill_if(me, me.bullet_coming())   # 護盾：子彈飛來才開

ang = me.direction_to(e) + math.pi          # 敵人的反方向
move = Action.drive_in_direction(me, ang)

move = Action.drive_to(me, P(400, 400))     # 開到地圖中央

aim = Action.aim_turret_at(me, e)               # 瞄準最近的敵人
aim = Action.aim_turret_at(me, e, lead=False)   # 不打提前量

1. 裝填完成（me.cooldown == 0；裝填 0.9 秒，速射 0.6、長砲 1.3）
2. 砲口和敵人（含提前量）的角度誤差小於 tol
3. 中間沒有牆擋住（check_walls=True 時）

fire = Action.fire_when_aimed(me, e, tol=0.08)

Action.use_skill_if(me, me.bullet_coming())                  # 護盾：子彈飛來
Action.use_skill_if(me, me.hp < 0.4 and e is not None)       # 隱身：快死時躲
Action.use_skill_if(me, me.outside_safe_zone(0))             # 衝刺：在圈外時衝回去

return combine(move, Action.aim_turret_at(me, e), Action.fire_when_aimed(me, e))
return combine(move, aim, fire, Action.hold_fire())   # 最後一個蓋掉開火 → 一定不開火

距離 < d − near：倒車（車頭仍對著敵人）
距離 > d + far ：斜斜地靠近
中間：側移繞圈（不容易被打中）

move = Behavior.keep_distance(me, e, 230)
move = Behavior.keep_distance(me, e, 300, near=20, far=100)   # 長砲：拉遠一點

unstick = Behavior.unstick(me)                                   # 放在戰術的最前面，每一步都呼叫
unstick = Behavior.unstick(me, toward=me.zone_center, pull=0.8)  # 脫困時盡量往圈內
if unstick:
    move = unstick
elif ...:

if me.hp < 0.4:
    move = Behavior.hide_behind_wall(me, e)

def reset(self):
    self.memory = Memory()
    self.memory.prev_hp = 1.0             # 自己加的：上一步的血量

center = P(400, 400)                      # 地圖正中央
move = Action.drive_to(me, center)

diff = wrap(me.direction_to(e) - me.turret)   # 砲口還差多少才對準敵人
if diff > 0: print("要往右轉")

E　自己寫基本動作與行為

在自己寫的函數上一行加 @Action.custom 或 @Behavior.custom，之後就能和內建函數一樣用 Action.名字(me, …)、Behavior.名字(me, …) 呼叫。基本動作只控制想控制的部位；行為通常決定移動與車身，這一步沒事做就回傳 None。名稱不能和內建的重複。

from strategy_lib import Me, Memory, Action, Behavior, combine

@Action.custom                                   # 自己寫的基本動作：加進 Action
def fire_if_close(me, e, max_dist=250):
    """只在敵人夠近、對準了才開火（遠距離子彈容易被閃掉）"""
    if e is None or me.distance_to(e) > max_dist:
        return {"fire": 0}
    return Action.fire_when_aimed(me, e)

@Behavior.custom                                 # 自己寫的行為：加進 Behavior
def careful_fight(me, e, d=230):
    """血多就保持距離繞圈，血少就躲到牆後"""
    if me.hp < 0.4:
        return Behavior.hide_behind_wall(me, e)
    return Behavior.keep_distance(me, e, d, near=20, far=100)

class Strategy:
    def reset(self):
        self.memory = Memory()

    def act(self, state):
        me = Me(state, memory=self.memory)
        e = me.nearest_visible_enemy()
        if e is None:
            move = Behavior.patrol(me, radius=200)      # 內建行為也可以調參數
        else:
            move = Behavior.careful_fight(me, e, 250)   # 和內建行為一樣呼叫
        return combine(move, Action.aim_turret_at(me, e), Action.fire_if_close(me, e, 300))

E2　自己寫脫困規則（卡在牆邊時怎麼辦）

函數庫有內建的 Behavior.unstick(me, …)（見 D3），參數可以調。想用自己的想法，可以自己寫一個（名字要不一樣，例如 my_unstick）。寫法分四步：

1. 判斷「卡住」只用模型也看得到的線索（第 2 段）
2. 連續卡幾步才算（第 4 段）
3. 脫困要一次做完：倒車並轉向比較空的一側，再往那個方向開一段（第 3、4 段）
4. 放在戰術最前面、每一步都呼叫（第 5 段）

下面分 5 段寫出一個完整的 strategy.py，由上往下接起來就是整個檔案（《脫困練習》notebook 的 B 部分是同一份程式，可以直接執行）。例子故意用「直接朝圈心開、不避牆」的移動，圈心在牆後就會頂住。

第 1 段　檔頭和參數

MY_UNSTICK：脫困的 4 個參數放在最上面，方便實驗。wait＝連續卡幾步才算、back＝倒車幾步、go＝再往前開幾步、near＝車頭前面多近有牆算擋住（像素）。改成 None 就是不脫困。

import math
from strategy_lib import Me, Memory, Action, Behavior, combine

MY_UNSTICK = dict(wait=6, back=15, go=40, near=25)   # 脫困的參數；改成 None＝不脫困

第 2 段　① 判斷「卡住」

is_stuck() 回傳 True／False，三個條件都成立才算卡住。

• me.clearance(me.heading)：從車子中心往車頭方向，多遠會碰到牆或場邊。模型的觀測裡有 32 條地形射線，第 1 條就是車頭正前方，所以模型也看得到。
• me.speed：這一步實際移動了幾像素。全速是 2.5～3.8，撞牆停住時是 0。觀測裡有自身速度。
• e is None：看不到敵人。看得到敵人時多半是在交戰或躲牆，不該打斷。
• 不要用模型看不到的東西當條件（例如記憶裡的目標點、牆後敵人的位置），否則模型學不到「什麼時候該脫困」。

def is_stuck(me, e, near):
    """① 判斷這一步是不是「卡住」：只用模型也看得到的線索"""
    wall_ahead = me.clearance(me.heading) < near     # 車頭前面 near 像素內有牆（觀測：地形射線）
    not_moving = me.speed < 0.3                      # 這一步幾乎沒動（觀測：自身速度）
    no_enemy = e is None                             # 看不到敵人（觀測：敵人欄位）
    return wall_ahead and not_moving and no_enemy

第 3 段　往哪一側繞

pick_side() 回傳車身要怎麼轉（動作的第 2 個值：0＝左轉、1＝不轉、2＝右轉）。

• me.heading - math.pi / 2、me.heading + math.pi / 2：車頭往左、往右各轉 90° 的方向。畫面的 y 軸朝下，所以角度變大是往右轉。
• 比較左右兩邊多遠有牆，往比較空的那邊轉。
• 結果存在 me.mem.esc_body，之後都用同一側：每次重新挑的話，可能這次往左、下次往右，在牆前來回打轉。

def pick_side(me):
    """往哪一側繞：0＝左轉、2＝右轉。第一次卡住時挑比較空的一側，之後都用同一側（不會左右來回）"""
    if me.mem.esc_body is None:                      # 還沒決定過
        left = me.clearance(me.heading - math.pi / 2)    # 左手邊多遠有牆
        right = me.clearance(me.heading + math.pi / 2)   # 右手邊多遠有牆
        me.mem.esc_body = 0 if left > right else 2
    return me.mem.esc_body

第 4 段　② 數步數、③ 訂計畫並做完

my_unstick() 是脫困的本體，每一步都會被呼叫，依序檢查三件事：

• 正在脫困嗎？（esc_left > 0）：照計畫做完。計畫分兩段，剩下的步數 ≥ go 時是第一段（倒車＋轉向），之後是第二段（往前直開）。回傳的 dict 只寫移動和車身：{"move": 1, "body": …}＝倒車＋轉向、{"move": 0, "body": 1}＝前進、車身不轉。
• 卡了幾步？：stuck_steps 是「連續」卡住的步數，有一步沒卡就歸零。還不到 wait 步就回傳 None，交給後面的戰術決定。
• 卡住了：先 pick_side() 決定方向，把 esc_left 設成 back + go（計畫總共幾步），這一步就開始倒車。
• 為什麼要第二段？只倒車的話，退開以後原本的移動又直直開回同一面牆（見下面的實測）。
• @Behavior.custom：把這個函數加進 Behavior，之後就能像內建行為一樣用 Behavior.my_unstick(me, e, …) 呼叫。

@Behavior.custom                                     # 加進 Behavior，之後用 Behavior.my_unstick(...) 呼叫
def my_unstick(me, e, wait=6, back=15, go=40, near=25):
    """自己寫的脫困：連續卡住 wait 步 → 倒車 back 步（同時轉向）→ 直直往前開 go 步"""
    m = me.mem
    # ③ 正在脫困：照計畫做完（esc_left＝計畫還剩幾步）
    if m.esc_left > 0:
        m.esc_left -= 1
        if m.esc_left >= go:
            return {"move": 1, "body": m.esc_body}   # 第一段：倒車（move 1）＋轉向
        return {"move": 0, "body": 1}                # 第二段：往前開（move 0）、車身不轉（body 1）
    # ② 數「連續」卡了幾步：有一步沒卡就歸零
    if is_stuck(me, e, near):
        m.stuck_steps += 1
    else:
        m.stuck_steps = 0
    if m.stuck_steps < wait:
        return None                                  # 還不算卡住：回傳 None，交給後面的戰術
    # 卡住了：訂計畫，這一步就開始倒車
    pick_side(me)
    m.esc_left = back + go
    m.stuck_steps = 0
    return {"move": 1, "body": m.esc_body}

第 5 段　④ 放進戰術

• reset()：每局開始呼叫一次。my_unstick 用到的 3 個記憶（stuck_steps、esc_left、esc_body）都要在這裡給初始值，否則第一步就會出現 AttributeError。
• act() 的第一件事就是呼叫 my_unstick：它要每一步都被呼叫，才數得到連續卡了幾步。回傳 None 表示沒卡住，交給後面的 if-elif。
• **MY_UNSTICK：把第 1 段的參數 dict 拆開傳進去，等於 my_unstick(me, e, wait=6, back=15, go=40, near=25)。
• 後面的移動故意不避牆：turn_body_toward 只轉車身，再把 move 設成 0（前進）。

class Strategy:
    def reset(self):                                 # 每局開始：自己加的記憶都要給初始值
        self.memory = Memory()
        self.memory.stuck_steps = 0                  # 連續卡了幾步
        self.memory.esc_left = 0                     # 脫困計畫還剩幾步（0＝沒在脫困）
        self.memory.esc_body = None                  # 往哪一側繞（第一次卡住時決定）

    def act(self, state):
        me = Me(state, memory=self.memory)
        e = me.nearest_visible_enemy()
        # ④ 脫困放在戰術最前面，每一步都呼叫（它要數步數）
        unstick = Behavior.my_unstick(me, e, **MY_UNSTICK) if MY_UNSTICK is not None else None
        if unstick:
            move = unstick
        elif e is None:
            # 自己寫的移動：直接朝圈心開、不避牆（圈心在牆後就會頂住）
            move = Action.turn_body_toward(me, me.direction_to(me.zone_center))
            move["move"] = 0
        else:
            move = Behavior.keep_distance(me, e, 230)
        return combine(move, Action.aim_turret_at(me, e), Action.fire_when_aimed(me, e))

實測

用離線小場地測（一面牆擋在我和圈心中間、沒有假想坦克，走 15 秒）：

動手改：go 改 20、near 改 15、wait 改 40，什麼時候繞不過去？把 pick_side 改成每次重新挑，會不會在牆前來回？拿掉 no_enemy，看得到敵人時也脫困好不好？想放進自己的策略：把第 1～4 段的函數和 MY_UNSTICK 貼到 strategy.py 上面，reset() 加 3 個記憶，act() 最前面加呼叫。

注意：函數庫的 drive_to、drive_in_direction、go_to_safe_zone 本來就會避牆、繞牆，用它們移動時很少卡住；自己寫的脫困最常派上用場的是自己寫的移動，或是故意貼著牆等待的戰術。規則策略不卡住，不代表模型不卡住：開與不開各錄一次、各訓練一次，看天梯轉播比較。

F　常見錯誤

08範例 C「教學版」

範例 A、B 是可以參考的成績；範例 C 是讓你知道可以怎麼寫。它把每一種寫法都放進來，但數值刻意調得不好，分數偏低，請從這裡開始改。位置：client/examples/C_tutorial/（標準＋推進衝刺）。

實測（平均名次，越小越好）

2026-10-25 用現行規則（子彈傷害 12）、現行函數庫與現行範例 bot 實測，配裝標準＋推進衝刺。規則策略各 600 局、模型各 400 局（附的 model.pt 是用舊版函數庫的資料訓練的小模型，比完全不動還差，正好拿來比較）。只改三項在 5 台幾乎沒差、10 台才看得出進步：同一個改動在不同模式效果不同，兩種都要評估。300 局的平均名次大約有 ±0.08 的誤差：差 0.1 以內的改動要打更多局才分得出來，報告裡請寫局數。

在自己電腦上先試：離線小場地

上傳之前，可以先在自己電腦上看策略怎麼動、怎麼打（不用連網站）：把 strategy.py，和學生套件的 strategy_lib.py、sandbox.py、try_sandbox.py 放在同一個資料夾，執行：

python try_sandbox.py          # Windows 可能要打 py try_sandbox.py

它會擺一面牆和一台每 1.5 秒朝你開一槍的假想坦克，讓你的策略走 20 秒，印出開火、打中、被打中、護盾擋下幾發，並把動畫存成網頁檔（用瀏覽器打開）。配裝直接用 strategy.py 開頭的 CHASSIS、MODULE，所以那兩行要和你在網站選的一樣（網站下載的範本已經填好）。想改場地，打開 try_sandbox.py 改牆和假想坦克的位置；更多玩法見課堂 notebook 第 1 節。

建議的練習順序

1. 原樣評估規則策略與模型，記下名次。
2. 一次改一個策略參數，每次至少 300 局，記錄前後差異（錄製工作台每批都有平均名次，可以直接比較）。
3. 策略變強後重新錄資料（至少 1,500 局），再訓練。
4. 改 agent.py：STACK = 4、HIDDEN = 256，或 MODEL = "lstm"，比較驗證指標和上場名次。
5. 5 台、10 台兩種模式都評估。

09錄資料：策略與錄製工作台

錄資料在繳交網站的「② 策略與錄製」分頁完成，不用自己架伺服器。還沒有自己的策略，可以先在「① 我的坦克」下載 strategy.py 範本（範例 C，已填好你的配裝）、函數說明書和你的個人規格書。

1. 上傳 strategy.py：網站先檢查程式（只能 import strategy_lib、math、random、numpy、collections 等；不能讀寫檔案、連網路），再用你的配裝試跑一局，自動播放重播。錯誤會指出是 strategy.py 第幾行。
2. 看重播、檢視樣本：確認坦克真的照你的邏輯在動。「檢視樣本」會列出動作比例（開火、技能佔幾成），並隨機抽 12 步畫出「模型會看到的觀測 → 策略做了什麼」，這就是神經網路要學的輸入與答案。
3. 選情境錄製：地圖（隨機、十字堡壘、城區巷戰）、台數（5 或 10）、對手配裝（隨機或全部指定一種）、局數（50、200、500 或 1,000）。可以換不同情境多錄幾批，每批都存在暫存資料集。
4. 整理資料集：每批顯示平均名次與筆數，不要的批次可以刪掉。每人資料總量上限 2,000 局。
5. 下載：勾選要的批次，下載成一個 zip，直接拿去訓練（第 10 節）。

試跑、錄製都在隔離的伺服器執行。改了 strategy.py 就重新上傳一次；舊版本與它錄的資料都會保留，報告可以比較不同版本。

5 台與 10 台

錄製時可以選 5 台或 10 台：比賽是 5 台；10 台的場面更亂，可以錄到更多種狀況。你的坦克一台，其餘是範例 bot。觀測、動作完全相同，同一個模型兩種模式都能上場。

10訓練與匯出

在自己的電腦（Python 3.10 以上，裝好 numpy、torch）訓練，CPU 就夠了。網路的結構和訓練設定都寫在 agent.py：從繳交網站下載「agent.py 範本」開始改（和課堂 notebook 6-3 同一份：MLP、疊 4 步、HIDDEN=128、EPOCHS=8）。學生套件裡範例 C 的 agent.py 刻意設得比較小（只看當下、HIDDEN=64），是讓你比較用的。

1　訓練：train.py

# 在 client/ 底下；資料可以是網站下載的 zip，或用逗號接多個檔案
python train.py dataset_B11201001_1020-1430.zip agent.py
python train.py 第一批.zip,第二批.zip agent.py
python train.py dataset.zip agent.py --epochs 3      # 臨時覆蓋 agent.py 的設定（快速試跑）

• 訓練完在 agent.py 同一個資料夾產生 model.pt（權重＋正規化參數）和 metrics.json（各分類頭的準確率等驗證指標）。
• 驗證集自動按局切（同一局不會同時出現在訓練和驗證）。開火、技能這兩個分類頭的正例很少，已經用類別權重補償。
• 網路設定和訓練設定都寫在 agent.py 開頭（見下表），train.py 不用改。改了任何設定，都要重新訓練、重新匯出。
• 每一輪會印出 loss，以及驗證集的移動準確率、開火召回率；驗證準確率不升反降，就是過擬合的訊號。
• 每次的亂數種子會印出來，想重現同一次結果就把 SEED 填成那個數字。資料來源（哪幾批資料、種子、訓練設定）會記錄在模型裡。
• LSTM（MODEL = "lstm"）會把每局切成序列訓練，可以用 --seq-len、--burn 調整。

沒寫的訓練設定用預設值；執行時加 --epochs、--lr、--batch、--seed、--fire-weight 可以臨時覆蓋。

2　匯出：export_model.py

python export_model.py agent.py          # → 同一個資料夾裡的 submit/model.pt（要上傳的就是這個）

• 匯出後會自動比對：同樣的觀測，匯出前後選的動作必須完全相同。
• 你的 strategy.py 和 agent.py 會一起打包進 model.pt，老師會看它評「方法設計」（比賽時不會執行）。規則策略不在同一個資料夾時，加 --strategy 路徑。
• 比賽時由老師的程式統一處理正規化、疊加觀測、LSTM 記憶與抽樣（設定存在 model.pt 裡），你在 agent.py 裡自己寫的 act() 不會被執行。

3　模型在牆邊停住、原地打轉

常見情況：規則策略打得好好的，訓練出來的模型卻常在牆邊停住，車身左右轉個不停，甚至整局不動。原因是模型只看得到 91 維觀測：規則策略在牆邊停下來的理由（在等敵人、要去的地方在牆後、記憶裡的目標點）模型看不到，它只學到「牆很近、沒看到敵人 → 停下來轉」，卻不知道該往哪邊轉、什麼時候走。

• 少用 Action.stop()，移動交給 drive_to、drive_in_direction。它們會邊開邊轉，車頭前面是牆時改成倒車轉向，不會停下來原地轉。
• 脫困 Behavior.unstick(me, …)：貼著牆、幾乎沒在動時，往空曠的方向離開。觸發條件在觀測裡都看得到（地形射線、自身速度、敵人欄位），模型學得到。可以調的地方： wait（貼牆不動幾步才算卡住）、back（離開時開幾步）、gap（多近算貼牆）、still（多慢算沒在動）、with_enemy（看得到敵人時要不要也脫困）、toward＋pull（脫困時偏向圈內或最後看到敵人的地方）、look（量空曠時看多遠）、cooldown（脫困完幾步內不再觸發）。範例 C 開頭有 UNSTICK、UNSTICK_WAIT、UNSTICK_BACK、UNSTICK_TOWARD、UNSTICK_ENEMY 可以直接改。
• 自己寫脫困規則：用 @Behavior.custom 寫一個新名字的行為（例如 my_unstick），四步：① 用模型看得到的線索判斷卡住（me.clearance(me.heading)、me.speed、看不看得到敵人）② 在 me.mem 數連續卡了幾步 ③ 脫困動作一次做完（倒車、轉向、再往旁邊開一段，只倒車會開回同一面牆）④ 放在戰術最前面、每一步呼叫。完整程式與實測見第 7 節的 E2　自己寫脫困規則（《規則策略函數說明書》E2）。
• 脫困不是穩賺的開關：老師實測（範例 C 改三項、錄 3,000 局、HIDDEN 256）開脫困往圈內的模型，對 bot 平均名次 2.62–2.69（不開 2.87–3.04），但牆邊停住的時間反而比較多（3–5%，不開 1.5–1.9%）。開或不開、參數怎麼設，要自己錄、自己訓練、自己比較，這正是報告「方法設計」「訓練結果」的好題材。
• 判斷方法：看天梯轉播或試跑重播，或到訓練資料裡找「牆很近、速度 0、沒看到敵人」的那些步，看規則策略在做什麼。如果多半是「停」，模型就會學成停。

實測（範例 C，600 局資料，4 個種子各打 100 場，2026-10-25）：用舊版函數庫（停下來原地轉）的資料訓練，模型在牆邊停住的時間佔存活時間 16%、最長一次 48 秒，縮圈時只有 15–33% 的時間在移動，平均名次 3.37；用現行函數庫降到 1.6%、最長 8 秒，縮圈時 97% 以上的時間在移動，平均名次 3.05、擊殺 0.34 → 0.55。

11繳交與期中報告

每人繳交兩樣東西：上場的模型（競技分）和期中報告（創意與報告 10 分）。報告的重點不是「做了什麼」，而是為什麼這樣設計、怎麼證明有用。

繳交模型

1. 照第 10 節訓練、匯出，得到 submit/model.pt。
2. 登入繳交網站（申請金鑰：輸入學號、姓名、台科大信箱；第一次登入後學號綁定這個信箱）。第一次登入先選配裝（選定後不能改），也可以替坦克取名，會顯示在排行榜與轉播上。
3. 在「③ 繳交模型與報告」上傳 submit/model.pt（不是 train.py 存的權重檔）。系統會檢查格式與推論速度。上傳紀錄會列出每一份的版本編號，頁首也會顯示目前的上場版本，報告封面要填。
4. 第一個通過的版本自動成為上場版本；截止前可以換成其他通過的版本，截止後凍結。

報告格式

• PDF，A4，內文 12 pt。不限頁數，4 個表格寫清楚即可。
• 存成 PDF：Word 用「檔案 → 另存新檔 → PDF」；Mac 的 Pages 用「檔案 → 輸出為 → PDF」。
• 報告範本：繳交網站「① 我的坦克」下載「期中報告範本（Word）」，封面已填好姓名、學號、配裝，章節和表格都排好了，照著填，寫完另存 PDF 上傳。
• 每個成績數字都要寫局數與模式（5 台或 10 台），例如「平均名次 2.51（5 台，600 局）」。
• 封面：姓名、學號、配裝、坦克名稱（範本已填好）、上場版本編號。天梯名次與分數由系統統整，報告不用寫。

報告就是 4 個表格，照表格裡的提示填寫：

評分重點

報告繳交：登入繳交網站，在「③ 繳交模型與報告」頁的「期中報告」上傳 PDF（20 MB 內），截止前可以重新上傳，以最後一次為準。