1. 系統概述與設計目標
系統定位與作用
AI與行為系統是《矮人要塞》中控制所有生物（主要是矮人）自主行為的核心繫統。與其他遊戲不同，矮人要塞的AI系統強調"自主性優先"的設計理念，玩家無法直接控制矮人，只能通過設定工作優先級、建造設施、管理資源等方式間接引導矮人的行為。
這個系統創造了一個獨特的遊戲體驗：玩家不是指揮官，而是世界的觀察者和引導者。矮人根據自身需求、情緒、技能、關係等因素自主做出決策，產生大量涌現性行為和意外事件，這正是遊戲的核心樂趣所在。
設計目標
- 自主性優先：矮人具有高度自主性，玩家無法直接控制，只能間接引導
- 需求驅動：行為基於需求層次系統，需求未滿足會影響行為選擇
- 情緒即玩法：情緒系統不是裝飾，而是核心玩法機制，管理情緒是重要挑戰
- 真實感：通過複雜的AI系統創造真實的模擬體驗
- 涌現性：通過系統交互產生意外和有趣的遊戲體驗
核心價值
- 真實感：複雜的AI系統讓矮人感覺像真實存在的個體
- 策略深度：玩家需要通過間接方式管理矮人，增加策略選擇
- 敍事價值：矮人的自主行為創造獨特的敍事體驗
- 重玩價值：不同的AI行為創造不同的遊戲體驗
系統架構概覽
AI與行為系統可以分為以下幾個核心模塊：
AI與行為系統
├── 需求層次模塊
│ ├── 需求類型定義
│ ├── 需求優先級
│ ├── 需求滿足度計算
│ └── 需求對行為的影響
├── 工作分配模塊
│ ├── 工作優先級系統
│ ├── 工作選擇算法
│ ├── 工作隊列管理
│ └── 工作分配優化
├── 情緒系統模塊
│ ├── 情緒狀態管理
│ ├── 情緒影響因素
│ ├── 情緒計算機制
│ └── 極端情緒處理
├── 社交關係模塊
│ ├── 關係網絡管理
│ ├── 關係形成機制
│ ├── 關係強度計算
│ └── 關係對行為的影響
├── 決策樹模塊
│ ├── 決策因素評估
│ ├── 決策算法
│ ├── 決策優先級計算
│ └── 決策衝突處理
├── 行為執行模塊
│ ├── 行為類型定義
│ ├── 行為執行流程
│ ├── 行為中斷機制
│ └── 行為完成檢測
└── 特殊行為模塊
├── 緊急行為處理
├── 社交行為生成
├── 創造性行為
└── 異常行為處理自主性優先的設計理念
傳統遊戲AI：
- 玩家直接控制單位
- AI執行玩家指令
- AI行為可預測
矮人要塞AI：
- 玩家無法直接控制
- AI自主做出決策
- AI行為有不確定性
設計優勢：
- 創造更真實的模擬體驗
- 產生涌現性玩法
- 增加遊戲挑戰性
- 創造獨特的敍事體驗
2. 需求層次系統
需求層次理論的應用
馬斯洛需求層次理論：
- 生理需求：食物、水、睡眠、温度
- 安全需求：安全、穩定、保護
- 社交需求：友誼、愛情、歸屬感
- 尊重需求：成就、認可、地位
- 自我實現需求：創造力、藝術、個人成長
在遊戲中的應用：
- 矮人的需求按照層次組織
- 低層次需求未滿足時，高層次需求優先級降低
- 需求滿足度影響情緒和行為
需求類型詳解
生存需求（Survival Needs）：
飢餓（Hunger）：
- 需求值：0-100，0為極度飢餓，100為飽腹
- 消耗速度：隨時間自然消耗
- 滿足方式：進食
- 未滿足後果：工作效率降低、可能餓死
口渴（Thirst）：
- 需求值：0-100
- 消耗速度：比飢餓更快
- 滿足方式：飲水
- 未滿足後果：工作效率降低、可能渴死
睡眠（Sleep）：
- 需求值：0-100，0為極度疲勞，100為充分休息
- 消耗速度：活動時消耗
- 滿足方式：睡覺
- 未滿足後果：工作效率降低、可能昏倒
温度（Temperature）：
- 需求值：舒適温度範圍
- 影響因素：環境温度、衣物
- 滿足方式：調節環境、穿脱衣物
- 未滿足後果：不適、可能凍傷或中暑
安全需求（Safety Needs）：
安全感（Security）：
- 需求值：0-100
- 影響因素：威脅、危險、防禦工事
- 滿足方式：建造防禦、消除威脅
- 未滿足後果：恐懼、壓力、可能逃跑
舒適需求（Comfort Needs）：
住所質量（Housing Quality）：
- 需求值：基於房間價值
- 影響因素：房間大小、裝飾、傢俱
- 滿足方式：改善住所
- 未滿足後果：不滿、壓力
娛樂（Entertainment）：
- 需求值：0-100
- 消耗速度：隨時間消耗
- 滿足方式：娛樂設施、社交活動
- 未滿足後果：無聊、不滿
社交需求（Social Needs）：
友誼（Friendship）：
- 需求值：基於朋友數量和質量
- 影響因素：社交活動、共同經歷
- 滿足方式：社交、交談
- 未滿足後果：孤獨、不滿
家庭（Family）：
- 需求值：基於家庭成員關係
- 影響因素：家庭成員存在、關係質量
- 滿足方式：與家人互動
- 未滿足後果：思念、悲傷
尊重需求（Esteem Needs）：
成就（Achievement）：
- 需求值：基於工作成就
- 影響因素：工作質量、技能提升
- 滿足方式：完成高質量工作
- 未滿足後果：挫敗感
認可（Recognition）：
- 需求值：基於他人認可
- 影響因素：工作被認可、獲得榮譽
- 滿足方式：獲得他人認可
- 未滿足後果：不被重視的感覺
自我實現需求（Self-Actualization Needs）：
創造力（Creativity）：
- 需求值：基於創造性活動
- 影響因素：藝術創作、創新工作
- 滿足方式：進行創造性工作
- 未滿足後果：創造力受限的感覺
數據結構：
class Need:
need_type: NeedType
current_value: float # 0-100
max_value: float # 100
decay_rate: float # 消耗速度
priority: float # 優先級（基於需求層次和當前值）
# 滿足方式
satisfaction_methods: list # 可以滿足該需求的方式
# 未滿足後果
unmet_effects: list # 未滿足時的效果
class NeedHierarchy:
survival_needs: list # 生存需求列表
safety_needs: list # 安全需求列表
comfort_needs: list # 舒適需求列表
social_needs: list # 社交需求列表
esteem_needs: list # 尊重需求列表
self_actualization_needs: list # 自我實現需求列表
def get_priority_needs(self):
# 獲取當前優先級最高的需求
all_needs = (self.survival_needs +
self.safety_needs +
self.comfort_needs +
self.social_needs +
self.esteem_needs +
self.self_actualization_needs)
# 按優先級排序
sorted_needs = sorted(all_needs,
key=lambda n: n.priority,
reverse=True)
return sorted_needs需求優先級機制
優先級計算：
def calculate_need_priority(need):
# 基礎優先級（基於需求層次）
base_priority = get_base_priority(need.need_type)
# 生存需求 > 安全需求 > 舒適需求 > 社交需求 > 尊重需求 > 自我實現需求
# 當前值影響（值越低，優先級越高）
value_factor = 1.0 - (need.current_value / need.max_value)
# 未滿足後果嚴重性
consequence_severity = get_consequence_severity(need)
# 計算最終優先級
priority = base_priority * (1.0 + value_factor * 2.0) * (1.0 + consequence_severity)
return priority優先級層次：
- 緊急（Critical）：生存需求嚴重未滿足
- 高（High）：生存需求部分未滿足或安全需求未滿足
- 中（Medium）：舒適需求未滿足
- 低（Low）：社交或尊重需求未滿足
- 極低（Very Low）：自我實現需求未滿足
需求滿足度計算
滿足度計算：
def calculate_need_satisfaction(need, action):
# 檢查行動是否滿足需求
if action.type not in need.satisfaction_methods:
return 0.0
# 計算滿足量
satisfaction_amount = action.satisfaction_value
# 應用滿足
need.current_value = min(need.max_value,
need.current_value + satisfaction_amount)
# 返回滿足度（0-1）
return need.current_value / need.max_value滿足度影響：
- 高滿足度：提升情緒、提高工作效率
- 低滿足度：降低情緒、降低工作效率
- 極低滿足度：可能導致異常行為
需求對行為的影響
行為選擇影響：
def select_behavior_based_on_needs(dwarf):
# 獲取優先級最高的需求
priority_needs = dwarf.need_hierarchy.get_priority_needs()
# 選擇滿足最高優先級需求的行為
for need in priority_needs:
# 查找可以滿足該需求的行為
available_behaviors = find_behaviors_for_need(need)
if available_behaviors:
# 選擇最優行為
best_behavior = select_best_behavior(available_behaviors, dwarf)
return best_behavior
# 如果沒有緊急需求，選擇工作或其他行為
return select_default_behavior(dwarf)工作效率影響：
def calculate_work_efficiency(dwarf, work):
base_efficiency = 1.0
# 需求滿足度影響效率
for need in dwarf.need_hierarchy.survival_needs:
if need.current_value < 50: # 未充分滿足
efficiency_penalty = (50 - need.current_value) / 50.0 * 0.3
base_efficiency -= efficiency_penalty
return max(0.1, base_efficiency) # 最低10%效率需求未滿足的後果
短期後果：
- 工作效率降低
- 情緒下降
- 行為異常
長期後果：
- 情緒崩潰
- 健康問題
- 可能死亡
後果處理：
def process_unmet_needs(dwarf):
for need in dwarf.need_hierarchy.get_all_needs():
if need.current_value < need.critical_threshold:
# 應用未滿足後果
for effect in need.unmet_effects:
apply_effect(dwarf, effect)
# 觸發緊急行為
if need.need_type in SURVIVAL_NEEDS:
trigger_emergency_behavior(dwarf, need)3. 工作分配機制
工作優先級系統
優先級層級：
- 禁止（Forbidden）：-1，禁止執行
- 低（Low）：1-2，低優先級
- 正常（Normal）：3-5，正常優先級
- 高（High）：6-8，高優先級
- 緊急（Urgent）：9-10，緊急優先級
優先級設置：
- 玩家可以設置全局工作優先級
- 玩家可以設置特定工作類型的優先級
- 玩家可以設置特定矮人的工作優先級
- 系統會根據需求自動調整優先級
優先級數據結構：
class WorkPriority:
work_type: WorkType
priority_level: int # 1-10，-1為禁止
conditions: dict # 優先級條件
# 自動調整
auto_adjust: bool # 是否自動調整
adjustment_factors: dict # 調整因素工作選擇算法
選擇因素：
技能匹配度：
def calculate_skill_match(dwarf, work):
required_skill = work.required_skill
dwarf_skill_level = dwarf.skills.get(required_skill, 0)
# 技能等級越高，匹配度越高
match_score = dwarf_skill_level / 20.0 # 0-1
return match_score距離因素：
def calculate_distance_factor(dwarf_location, work_location):
distance = calculate_distance(dwarf_location, work_location)
# 距離越近，因子越高
max_distance = 100 # 假設最大距離
factor = 1.0 - (distance / max_distance) * 0.5 # 最多減少50%
return max(0.5, factor) # 最低0.5需求因素：
def calculate_need_factor(dwarf, work):
# 檢查工作是否滿足矮人的需求
need_satisfaction = 0.0
for need in dwarf.need_hierarchy.get_priority_needs():
if work.can_satisfy_need(need):
need_satisfaction += need.priority
# 歸一化
max_possible_satisfaction = 10.0 # 假設最大優先級
factor = min(1.0, need_satisfaction / max_possible_satisfaction)
return factor危險因素：
def calculate_danger_factor(dwarf, work):
# 檢查工作的危險程度
danger_level = work.danger_level
# 矮人的勇氣影響
courage = dwarf.attributes.willpower / 1000.0
# 危險因子（危險越高，因子越低，但勇氣可以抵消）
factor = 1.0 - danger_level * (1.0 - courage) * 0.5
return max(0.1, factor) # 最低0.1綜合選擇算法：
def select_work_for_dwarf(dwarf, available_works):
scored_works = []
for work in available_works:
# 檢查是否可以執行
if not can_perform_work(dwarf, work):
continue
# 計算各項得分
skill_score = calculate_skill_match(dwarf, work) * 0.4
distance_score = calculate_distance_factor(dwarf.location, work.location) * 0.2
need_score = calculate_need_factor(dwarf, work) * 0.3
danger_score = calculate_danger_factor(dwarf, work) * 0.1
# 優先級加成
priority_bonus = work.priority / 10.0 * 0.2
# 綜合得分
total_score = (skill_score + distance_score + need_score +
danger_score + priority_bonus)
scored_works.append((work, total_score))
# 選擇得分最高的工作
if scored_works:
scored_works.sort(key=lambda x: x[1], reverse=True)
return scored_works[0][0]
return None工作隊列管理
隊列結構：
class WorkQueue:
works: list # 工作列表
priority_queue: PriorityQueue # 優先級隊列
def add_work(self, work):
# 添加到隊列
self.works.append(work)
# 添加到優先級隊列
priority = work.priority
self.priority_queue.put((-priority, work.id, work)) # 負數因為優先級越高越小
def get_next_work(self):
# 獲取下一個工作
if not self.priority_queue.empty():
_, _, work = self.priority_queue.get()
return work
return None
def remove_work(self, work_id):
# 移除工作
self.works = [w for w in self.works if w.id != work_id]隊列優化：
- 合併相似工作
- 批量處理相同類型工作
- 優化工作順序
工作分配優化
全局優化：
def optimize_work_assignment(dwarves, works):
# 構建分配矩陣
assignment_matrix = []
for dwarf in dwarves:
row = []
for work in works:
# 計算分配成本（成本越低越好）
cost = calculate_assignment_cost(dwarf, work)
row.append(cost)
assignment_matrix.append(row)
# 使用匈牙利算法或其他優化算法找到最優分配
optimal_assignment = hungarian_algorithm(assignment_matrix)
return optimal_assignment動態調整：
- 根據情況動態調整工作分配
- 處理緊急情況
- 優化長期效率
玩家優先級設置的影響
玩家設置：
- 玩家設置的工作優先級直接影響工作選擇
- 高優先級工作會被優先選擇
- 禁止的工作不會被選擇
系統自動調整：
- 系統會根據需求自動調整優先級
- 緊急需求會提升相關工作的優先級
- 資源稀缺會提升相關工作的優先級
平衡機制：
def calculate_final_priority(player_priority, auto_adjustment):
# 玩家優先級為基礎
base_priority = player_priority
# 自動調整
adjusted_priority = base_priority + auto_adjustment
# 限制在合理範圍
final_priority = max(1, min(10, adjusted_priority))
return final_priority4. 情緒系統
情緒狀態類型
情緒等級：
- 狂喜（Ecstatic）：90-100，極度快樂
- 快樂（Happy）：70-89，快樂
- 滿足（Content）：50-69，滿足
- 中性（Neutral）：40-59，中性
- 不滿（Unhappy）：20-39，不滿
- 痛苦（Miserable）：10-19，痛苦
- 崩潰（Stressed）：0-9，精神崩潰
情緒數據結構：
class EmotionState:
current_value: float # 0-100
emotion_type: EmotionType
# 情緒影響因素
factors: dict # 因素 -> 影響值
# 情緒歷史
history: list # 情緒變化歷史
# 極端情緒狀態
is_stressed: bool # 是否精神崩潰
stress_level: float # 壓力等級情緒影響因素
工作滿意度：
def calculate_work_satisfaction(dwarf, work):
satisfaction = 0.0
# 工作質量影響
if work.quality > 3.0: # 高質量工作
satisfaction += 10.0
elif work.quality < 2.0: # 低質量工作
satisfaction -= 5.0
# 工作類型影響（某些矮人喜歡某些工作）
if dwarf.preferences.likes_work_type(work.type):
satisfaction += 5.0
elif dwarf.preferences.dislikes_work_type(work.type):
satisfaction -= 5.0
# 工作環境影響
if work.environment.is_comfortable():
satisfaction += 3.0
return satisfaction居住環境：
def calculate_housing_satisfaction(dwarf):
room = dwarf.assigned_room
if not room:
return -10.0 # 沒有房間
satisfaction = 0.0
# 房間價值
room_value = room.calculate_value()
satisfaction += room_value / 100.0 # 每100價值+1滿意度
# 房間大小
room_size = room.size
if room_size < 4: # 太小
satisfaction -= 5.0
elif room_size > 20: # 太大（可能浪費）
satisfaction += 2.0
# 房間裝飾
decoration_value = room.decoration_value
satisfaction += decoration_value / 50.0
return satisfaction社交關係：
def calculate_social_satisfaction(dwarf):
satisfaction = 0.0
# 朋友數量
friends = dwarf.relationships.get_friends()
satisfaction += len(friends) * 2.0
# 朋友質量（關係強度）
for friend in friends:
relationship_strength = dwarf.relationships.get_strength(friend)
satisfaction += relationship_strength * 1.0
# 家庭成員
family = dwarf.relationships.get_family()
satisfaction += len(family) * 3.0
# 敵人數量（負面影響）
enemies = dwarf.relationships.get_enemies()
satisfaction -= len(enemies) * 5.0
return satisfaction創傷經歷：
def calculate_trauma_impact(dwarf):
impact = 0.0
# 遍歷所有創傷經歷
for trauma in dwarf.trauma_history:
# 創傷嚴重性
severity = trauma.severity
# 時間衰減（越久遠影響越小）
age = current_time - trauma.time
decay_factor = 1.0 / (1.0 + age / 365.0) # 每年衰減
impact -= severity * decay_factor
return impact情緒計算機制
綜合情緒計算：
def calculate_emotion(dwarf):
base_emotion = 50.0 # 中性值
# 工作滿意度
work_satisfaction = calculate_work_satisfaction(dwarf, dwarf.current_work)
base_emotion += work_satisfaction * 0.3
# 居住環境
housing_satisfaction = calculate_housing_satisfaction(dwarf)
base_emotion += housing_satisfaction * 0.2
# 社交關係
social_satisfaction = calculate_social_satisfaction(dwarf)
base_emotion += social_satisfaction * 0.2
# 需求滿足度
need_satisfaction = calculate_overall_need_satisfaction(dwarf)
base_emotion += need_satisfaction * 0.2
# 創傷經歷
trauma_impact = calculate_trauma_impact(dwarf)
base_emotion += trauma_impact * 0.1
# 限制在合理範圍
final_emotion = max(0, min(100, base_emotion))
# 更新情緒狀態
dwarf.emotion_state.current_value = final_emotion
dwarf.emotion_state.emotion_type = determine_emotion_type(final_emotion)
return final_emotion情緒類型確定：
def determine_emotion_type(emotion_value):
if emotion_value >= 90:
return EmotionType.ECSTATIC
elif emotion_value >= 70:
return EmotionType.HAPPY
elif emotion_value >= 50:
return EmotionType.CONTENT
elif emotion_value >= 40:
return EmotionType.NEUTRAL
elif emotion_value >= 20:
return EmotionType.UNHAPPY
elif emotion_value >= 10:
return EmotionType.MISERABLE
else:
return EmotionType.STRESSED情緒對行為的影響
工作效率影響：
def calculate_emotion_work_modifier(emotion_value):
if emotion_value >= 70:
# 快樂提升效率
modifier = 1.0 + (emotion_value - 70) / 30.0 * 0.2 # 最多20%加成
elif emotion_value >= 50:
# 滿足正常效率
modifier = 1.0
elif emotion_value >= 20:
# 不滿降低效率
modifier = 1.0 - (50 - emotion_value) / 30.0 * 0.3 # 最多30%懲罰
else:
# 痛苦大幅降低效率
modifier = 0.5 - (20 - emotion_value) / 20.0 * 0.3 # 最低20%效率
return modifier行為選擇影響：
def adjust_behavior_for_emotion(dwarf, behavior):
emotion = dwarf.emotion_state.current_value
if emotion < 20: # 痛苦
# 可能選擇逃避行為
if random.random() < 0.3:
return select_escape_behavior(dwarf)
elif emotion < 40: # 不滿
# 可能選擇消極行為
if random.random() < 0.2:
return select_negative_behavior(dwarf)
elif emotion > 80: # 快樂
# 可能選擇創造性行為
if random.random() < 0.2:
return select_creative_behavior(dwarf)
return behavior極端情緒的處理
精神崩潰（Stress）：
def handle_stress_breakdown(dwarf):
if dwarf.emotion_state.current_value < 10:
# 觸發精神崩潰
dwarf.emotion_state.is_stressed = True
dwarf.emotion_state.stress_level = 1.0
# 隨機選擇崩潰類型
breakdown_type = random.choice([
"tantrum", # 發脾氣
"violence", # 暴力傾向
"withdrawal", # 退縮
"destruction" # 破壞
])
# 應用崩潰效果
apply_breakdown_effect(dwarf, breakdown_type)崩潰類型：
發脾氣（Tantrum）：
- 隨機破壞物品
- 拒絕工作
- 攻擊他人
暴力傾向（Violence）：
- 攻擊其他矮人
- 使用武器
- 可能致命
退縮（Withdrawal）：
- 停止所有活動
- 躲藏
- 拒絕交流
破壞（Destruction）：
- 破壞建築
- 破壞物品
- 可能造成重大損失
崩潰處理：
def apply_breakdown_effect(dwarf, breakdown_type):
if breakdown_type == "tantrum":
# 隨機破壞附近物品
nearby_items = get_nearby_items(dwarf.location, radius=5)
for item in random.sample(nearby_items, min(3, len(nearby_items))):
destroy_item(item)
# 拒絕工作
dwarf.refuse_work = True
dwarf.refuse_duration = random.randint(100, 300) # 時間單位
elif breakdown_type == "violence":
# 攻擊附近矮人
nearby_dwarves = get_nearby_dwarves(dwarf.location, radius=5)
if nearby_dwarves:
target = random.choice(nearby_dwarves)
attack_dwarf(dwarf, target)
elif breakdown_type == "withdrawal":
# 停止活動
dwarf.current_behavior = None
dwarf.refuse_all_work = True
# 尋找隱藏地點
hide_location = find_hiding_spot(dwarf)
if hide_location:
move_to(dwarf, hide_location)
elif breakdown_type == "destruction":
# 破壞附近建築
nearby_buildings = get_nearby_buildings(dwarf.location, radius=5)
for building in random.sample(nearby_buildings, min(2, len(nearby_buildings))):
damage_building(building, random.randint(10, 50))情緒恢復機制
自然恢復：
def process_emotion_recovery(dwarf):
current_emotion = dwarf.emotion_state.current_value
# 如果情緒很低，自然恢復很慢
if current_emotion < 20:
recovery_rate = 0.1 # 每天恢復0.1
elif current_emotion < 50:
recovery_rate = 0.5 # 每天恢復0.5
else:
recovery_rate = 1.0 # 每天恢復1.0
# 應用恢復
new_emotion = min(100, current_emotion + recovery_rate)
dwarf.emotion_state.current_value = new_emotion
# 如果恢復到一定程度，解除崩潰狀態
if new_emotion > 20 and dwarf.emotion_state.is_stressed:
dwarf.emotion_state.is_stressed = False
dwarf.emotion_state.stress_level = 0.0
dwarf.refuse_work = False
dwarf.refuse_all_work = False積極事件恢復：
def apply_positive_event(dwarf, event):
emotion_boost = 0.0
if event.type == "good_work":
emotion_boost = 5.0
elif event.type == "social_interaction":
emotion_boost = 3.0
elif event.type == "entertainment":
emotion_boost = 4.0
elif event.type == "comfort":
emotion_boost = 2.0
# 應用情緒提升
dwarf.emotion_state.current_value = min(100,
dwarf.emotion_state.current_value + emotion_boost)5. 社交關係網絡
關係類型
關係分類：
積極關係：
- 友誼（Friendship）：朋友關係
- 愛情（Love）：戀愛關係
- 家庭（Family）：家庭成員關係
- 尊重（Respect）：尊重關係
消極關係：
- 敵對（Hostility）：敵對關係
- 仇恨（Hatred）：仇恨關係
- 恐懼（Fear）：恐懼關係
中性關係：
- 熟悉（Acquaintance）：認識但不熟悉
- 陌生（Stranger）：不認識
關係數據結構：
class Relationship:
dwarf_a: Dwarf
dwarf_b: Dwarf
relationship_type: RelationshipType
strength: float # 0-100，關係強度
# 關係歷史
history: list # 關係變化歷史
# 關係影響因素
factors: dict # 因素 -> 影響值關係形成機制
初次接觸：
def form_initial_relationship(dwarf_a, dwarf_b):
# 創建初始關係
relationship = Relationship(
dwarf_a=dwarf_a,
dwarf_b=dwarf_b,
relationship_type=RelationshipType.ACQUAINTANCE,
strength=10.0 # 初始強度
)
# 性格兼容性影響
compatibility = calculate_personality_compatibility(dwarf_a, dwarf_b)
relationship.strength += compatibility * 5.0
# 添加到關係網絡
add_relationship(dwarf_a, dwarf_b, relationship)
return relationship關係發展：
def develop_relationship(dwarf_a, dwarf_b, interaction):
relationship = get_relationship(dwarf_a, dwarf_b)
if not relationship:
relationship = form_initial_relationship(dwarf_a, dwarf_b)
# 交互類型影響
interaction_impact = get_interaction_impact(interaction.type)
# 應用影響
relationship.strength += interaction_impact
# 更新關係類型
update_relationship_type(relationship)
# 記錄歷史
relationship.history.append({
"time": current_time,
"interaction": interaction,
"strength_change": interaction_impact
})關係強度計算
強度影響因素：
共同經歷：
def calculate_shared_experience_bonus(dwarf_a, dwarf_b):
bonus = 0.0
# 共同工作
shared_work = get_shared_work_experiences(dwarf_a, dwarf_b)
bonus += len(shared_work) * 2.0
# 共同戰鬥
shared_combat = get_shared_combat_experiences(dwarf_a, dwarf_b)
bonus += len(shared_combat) * 5.0
# 共同社交活動
shared_social = get_shared_social_activities(dwarf_a, dwarf_b)
bonus += len(shared_social) * 3.0
return bonus性格兼容性：
def calculate_personality_compatibility(dwarf_a, dwarf_b):
compatibility = 0.0
# 性格相似度
personality_similarity = calculate_personality_similarity(
dwarf_a.personality,
dwarf_b.personality
)
compatibility += personality_similarity * 0.5
# 興趣相似度
interest_similarity = calculate_interest_similarity(
dwarf_a.interests,
dwarf_b.interests
)
compatibility += interest_similarity * 0.5
return compatibility綜合強度計算：
def calculate_relationship_strength(relationship):
base_strength = relationship.strength
# 共同經歷加成
shared_experience_bonus = calculate_shared_experience_bonus(
relationship.dwarf_a,
relationship.dwarf_b
)
# 性格兼容性加成
compatibility_bonus = calculate_personality_compatibility(
relationship.dwarf_a,
relationship.dwarf_b
) * 10.0
# 時間衰減（關係需要維護）
age = current_time - relationship.formation_time
decay_factor = 1.0 / (1.0 + age / 365.0) # 每年衰減
final_strength = (base_strength + shared_experience_bonus + compatibility_bonus) * decay_factor
# 限制在合理範圍
return max(0, min(100, final_strength))關係對行為的影響
行為選擇影響：
def adjust_behavior_for_relationships(dwarf, behavior):
# 檢查行為是否涉及其他矮人
if behavior.involves_other_dwarves():
target_dwarves = behavior.get_target_dwarves()
for target in target_dwarves:
relationship = get_relationship(dwarf, target)
if relationship:
# 積極關係：更願意合作
if relationship.relationship_type in POSITIVE_RELATIONSHIPS:
if relationship.strength > 50:
behavior.cooperation_bonus = 0.2 # 20%合作加成
# 消極關係：可能拒絕或對抗
elif relationship.relationship_type in NEGATIVE_RELATIONSHIPS:
if relationship.strength > 50:
if random.random() < 0.3:
return None # 拒絕行為
else:
behavior.cooperation_penalty = 0.3 # 30%合作懲罰
return behavior工作效率影響：
def calculate_relationship_work_modifier(dwarf, work):
modifier = 1.0
# 檢查工作是否涉及朋友
if work.involves_other_dwarves():
involved_dwarves = work.get_involved_dwarves()
for other_dwarf in involved_dwarves:
relationship = get_relationship(dwarf, other_dwarf)
if relationship and relationship.relationship_type == RelationshipType.FRIENDSHIP:
if relationship.strength > 70:
modifier += 0.1 # 10%效率加成
return modifier關係網絡的數據結構
網絡結構：
class RelationshipNetwork:
relationships: dict # (dwarf_a_id, dwarf_b_id) -> Relationship
# 索引
dwarf_relationships: dict # dwarf_id -> [Relationship]
def add_relationship(self, dwarf_a, dwarf_b, relationship):
key = (min(dwarf_a.id, dwarf_b.id), max(dwarf_a.id, dwarf_b.id))
self.relationships[key] = relationship
# 更新索引
if dwarf_a.id not in self.dwarf_relationships:
self.dwarf_relationships[dwarf_a.id] = []
if dwarf_b.id not in self.dwarf_relationships:
self.dwarf_relationships[dwarf_b.id] = []
self.dwarf_relationships[dwarf_a.id].append(relationship)
self.dwarf_relationships[dwarf_b.id].append(relationship)
def get_relationships(self, dwarf):
return self.dwarf_relationships.get(dwarf.id, [])
def get_relationship(self, dwarf_a, dwarf_b):
key = (min(dwarf_a.id, dwarf_b.id), max(dwarf_a.id, dwarf_b.id))
return self.relationships.get(key)社交活動的生成
活動類型：
- 交談（Conversation）：日常交談
- 聚會（Gathering）：多人聚會
- 合作（Cooperation）：共同工作
- 衝突（Conflict）：爭吵或衝突
活動生成：
def generate_social_activity(dwarves):
# 選擇參與者
participants = select_participants(dwarves, min_count=2, max_count=5)
if len(participants) < 2:
return None
# 根據關係選擇活動類型
relationship_strength = calculate_average_relationship_strength(participants)
if relationship_strength > 60:
# 積極關係：聚會或合作
activity_type = random.choice(["gathering", "cooperation"])
elif relationship_strength < 30:
# 消極關係：可能衝突
if random.random() < 0.3:
activity_type = "conflict"
else:
activity_type = "conversation"
else:
# 中性關係：交談
activity_type = "conversation"
# 創建活動
activity = SocialActivity(
type=activity_type,
participants=participants,
location=select_activity_location(participants),
duration=calculate_activity_duration(activity_type)
)
return activity6. AI決策樹系統
決策樹結構設計
決策節點類型：
條件節點：
- 檢查條件（需求、情緒、關係等）
- 根據條件選擇分支
行為節點：
- 執行具體行為
- 返回行為結果
優先級節點：
- 評估多個選項的優先級
- 選擇最優選項
決策樹結構：
class DecisionNode:
node_type: NodeType # CONDITION, BEHAVIOR, PRIORITY
condition: Condition # 條件（如果是條件節點）
behavior: Behavior # 行為（如果是行為節點）
children: list # 子節點
priority: float # 優先級（如果是優先級節點）
class DecisionTree:
root: DecisionNode
def evaluate(self, dwarf, context):
return self._evaluate_node(self.root, dwarf, context)
def _evaluate_node(self, node, dwarf, context):
if node.node_type == NodeType.CONDITION:
# 評估條件
condition_result = evaluate_condition(node.condition, dwarf, context)
# 選擇分支
if condition_result:
return self._evaluate_node(node.children[0], dwarf, context)
else:
return self._evaluate_node(node.children[1], dwarf, context)
elif node.node_type == NodeType.BEHAVIOR:
# 執行行為
return node.behavior
elif node.node_type == NodeType.PRIORITY:
# 評估所有子節點，選擇優先級最高的
best_node = None
best_priority = -1
for child in node.children:
priority = evaluate_priority(child, dwarf, context)
if priority > best_priority:
best_priority = priority
best_node = child
return self._evaluate_node(best_node, dwarf, context)決策因素
需求因素：
def evaluate_need_factor(dwarf, behavior):
# 檢查行為是否滿足需求
satisfied_needs = behavior.get_satisfied_needs()
if not satisfied_needs:
return 0.0
# 計算滿足的需求優先級總和
total_priority = sum(need.priority for need in satisfied_needs)
return total_priority技能因素：
def evaluate_skill_factor(dwarf, behavior):
# 檢查行為所需的技能
required_skills = behavior.get_required_skills()
if not required_skills:
return 1.0 # 不需要技能，中性
# 計算技能匹配度
total_match = 0.0
for skill_type, required_level in required_skills.items():
dwarf_skill = dwarf.skills.get(skill_type, 0)
match = min(1.0, dwarf_skill / required_level)
total_match += match
average_match = total_match / len(required_skills)
return average_match距離因素：
def evaluate_distance_factor(dwarf, behavior):
behavior_location = behavior.get_location()
dwarf_location = dwarf.location
distance = calculate_distance(dwarf_location, behavior_location)
# 距離越近，因子越高
max_distance = 100
factor = 1.0 - (distance / max_distance) * 0.5
return max(0.5, factor)危險因素：
def evaluate_danger_factor(dwarf, behavior):
danger_level = behavior.get_danger_level()
# 矮人的勇氣影響
courage = dwarf.attributes.willpower / 1000.0
# 危險因子（危險越高，因子越低）
factor = 1.0 - danger_level * (1.0 - courage) * 0.5
return max(0.1, factor)情緒因素：
def evaluate_emotion_factor(dwarf, behavior):
emotion = dwarf.emotion_state.current_value
# 行為類型與情緒的匹配度
behavior_emotion_match = behavior.get_emotion_match()
# 如果行為需要積極情緒，但矮人情緒低落
if behavior_emotion_match > 0 and emotion < 30:
return 0.3 # 低匹配度
# 如果行為需要消極情緒，但矮人情緒高漲
elif behavior_emotion_match < 0 and emotion > 70:
return 0.5 # 中等匹配度
return 1.0 # 正常匹配度關係因素：
def evaluate_relationship_factor(dwarf, behavior):
if not behavior.involves_other_dwarves():
return 1.0 # 不涉及他人，中性
involved_dwarves = behavior.get_involved_dwarves()
total_factor = 0.0
for other_dwarf in involved_dwarves:
relationship = get_relationship(dwarf, other_dwarf)
if relationship:
if relationship.relationship_type in POSITIVE_RELATIONSHIPS:
factor = 1.0 + relationship.strength / 100.0 * 0.3 # 最多30%加成
elif relationship.relationship_type in NEGATIVE_RELATIONSHIPS:
factor = 1.0 - relationship.strength / 100.0 * 0.5 # 最多50%懲罰
else:
factor = 1.0
else:
factor = 1.0
total_factor += factor
average_factor = total_factor / len(involved_dwarves)
return average_factor決策算法
綜合決策算法：
def make_decision(dwarf, available_behaviors, context):
scored_behaviors = []
for behavior in available_behaviors:
# 評估各項因素
need_score = evaluate_need_factor(dwarf, behavior) * 0.3
skill_score = evaluate_skill_factor(dwarf, behavior) * 0.2
distance_score = evaluate_distance_factor(dwarf, behavior) * 0.15
danger_score = evaluate_danger_factor(dwarf, behavior) * 0.1
emotion_score = evaluate_emotion_factor(dwarf, behavior) * 0.15
relationship_score = evaluate_relationship_factor(dwarf, behavior) * 0.1
# 綜合得分
total_score = (need_score + skill_score + distance_score +
danger_score + emotion_score + relationship_score)
scored_behaviors.append((behavior, total_score))
# 選擇得分最高的行為
if scored_behaviors:
scored_behaviors.sort(key=lambda x: x[1], reverse=True)
return scored_behaviors[0][0]
return None決策優先級計算
優先級計算：
def calculate_decision_priority(dwarf, behavior):
# 基礎優先級
base_priority = behavior.base_priority
# 需求緊急度
need_urgency = calculate_need_urgency(dwarf, behavior)
# 情緒影響
emotion_modifier = calculate_emotion_modifier(dwarf.emotion_state)
# 綜合優先級
final_priority = base_priority * (1.0 + need_urgency) * emotion_modifier
return final_priority決策衝突處理
衝突類型：
- 需求衝突：多個需求同時需要滿足
- 行為衝突：多個行為不能同時執行
- 資源衝突：多個行為需要同一資源
衝突解決：
def resolve_decision_conflicts(dwarf, behaviors):
# 按優先級排序
sorted_behaviors = sorted(behaviors,
key=lambda b: calculate_decision_priority(dwarf, b),
reverse=True)
selected_behaviors = []
used_resources = set()
for behavior in sorted_behaviors:
# 檢查資源衝突
required_resources = behavior.get_required_resources()
if not required_resources.intersection(used_resources):
# 無衝突，可以執行
selected_behaviors.append(behavior)
used_resources.update(required_resources)
else:
# 有衝突，跳過或延遲
if behavior.can_be_delayed():
delay_behavior(behavior)
else:
# 不能延遲，選擇更高優先級的行為
pass
return selected_behaviors決策優化
優化策略：
- 緩存決策結果
- 批量處理決策
- 使用啓發式算法
優化算法：
class DecisionCache:
cache: dict
def get_cached_decision(self, dwarf, context):
cache_key = (dwarf.id, hash_context(context))
if cache_key in self.cache:
cached_decision, timestamp = self.cache[cache_key]
# 檢查緩存是否過期
if current_time - timestamp < CACHE_TTL:
return cached_decision
return None
def cache_decision(self, dwarf, context, decision):
cache_key = (dwarf.id, hash_context(context))
self.cache[cache_key] = (decision, current_time)7. 行為執行系統
行為類型分類
行為分類：
生存行為：
- 進食
- 飲水
- 睡眠
- 尋找安全
工作行為：
- 採礦
- 鍛造
- 建造
- 農業
社交行為：
- 交談
- 聚會
- 合作
娛樂行為：
- 娛樂
- 藝術創作
- 閲讀
緊急行為：
- 戰鬥
- 醫療
- 逃跑
數據結構：
class Behavior:
behavior_type: BehaviorType
target: object # 行為目標
location: Location # 行為位置
duration: int # 預計持續時間
required_resources: set # 所需資源
required_skills: dict # 所需技能
# 行為狀態
status: BehaviorStatus # PENDING, EXECUTING, COMPLETED, FAILED, INTERRUPTED
progress: float # 0-1，完成進度
# 行為效果
effects: list # 行為效果列表行為執行流程
執行流程：
def execute_behavior(dwarf, behavior):
# 1. 檢查前置條件
if not check_prerequisites(dwarf, behavior):
behavior.status = BehaviorStatus.FAILED
return False
# 2. 移動到行為位置
if not move_to_location(dwarf, behavior.location):
behavior.status = BehaviorStatus.FAILED
return False
# 3. 開始執行
behavior.status = BehaviorStatus.EXECUTING
behavior.start_time = current_time
# 4. 執行循環
while behavior.status == BehaviorStatus.EXECUTING:
# 檢查中斷條件
if check_interrupt_conditions(dwarf, behavior):
interrupt_behavior(dwarf, behavior)
break
# 執行行為步驟
execute_behavior_step(dwarf, behavior)
# 更新進度
update_behavior_progress(behavior)
# 檢查完成條件
if check_completion_conditions(behavior):
complete_behavior(dwarf, behavior)
break
# 等待下一幀
yield
return behavior.status == BehaviorStatus.COMPLETED行為中斷機制
中斷條件：
- 緊急需求（如生命危險）
- 更高優先級行為
- 資源不足
- 目標消失
中斷處理：
def interrupt_behavior(dwarf, behavior):
# 設置中斷狀態
behavior.status = BehaviorStatus.INTERRUPTED
behavior.interrupt_time = current_time
behavior.interrupt_reason = determine_interrupt_reason(dwarf, behavior)
# 保存進度（某些行為可以恢復）
if behavior.can_resume():
behavior.saved_progress = behavior.progress
# 清理資源
release_behavior_resources(behavior)
# 觸發中斷事件
trigger_interrupt_event(dwarf, behavior)行為完成檢測
完成條件：
def check_completion_conditions(behavior):
# 檢查進度
if behavior.progress >= 1.0:
return True
# 檢查時間
if behavior.duration > 0:
elapsed_time = current_time - behavior.start_time
if elapsed_time >= behavior.duration:
return True
# 檢查目標狀態
if behavior.target and behavior.target.is_completed():
return True
return False完成處理：
def complete_behavior(dwarf, behavior):
# 設置完成狀態
behavior.status = BehaviorStatus.COMPLETED
behavior.completion_time = current_time
# 應用行為效果
apply_behavior_effects(dwarf, behavior)
# 更新需求
update_needs_from_behavior(dwarf, behavior)
# 更新情緒
update_emotion_from_behavior(dwarf, behavior)
# 更新技能經驗
update_skill_experience(dwarf, behavior)
# 觸發完成事件
trigger_completion_event(dwarf, behavior)行為失敗處理
失敗原因：
- 前置條件不滿足
- 資源不足
- 技能不足
- 目標不可達
失敗處理：
def handle_behavior_failure(dwarf, behavior, reason):
# 設置失敗狀態
behavior.status = BehaviorStatus.FAILED
behavior.failure_reason = reason
# 應用失敗效果
apply_failure_effects(dwarf, behavior)
# 降低情緒
dwarf.emotion_state.current_value -= 2.0
# 觸發失敗事件
trigger_failure_event(dwarf, behavior)
# 選擇替代行為
alternative_behavior = find_alternative_behavior(dwarf, behavior)
if alternative_behavior:
schedule_behavior(dwarf, alternative_behavior)8. 特殊行為系統
緊急行為
戰鬥行為：
def execute_combat_behavior(dwarf, enemy):
# 戰鬥是最高優先級行為
behavior = CombatBehavior(
target=enemy,
priority=10 # 最高優先級
)
# 立即中斷當前行為
interrupt_current_behavior(dwarf)
# 執行戰鬥
execute_behavior(dwarf, behavior)醫療行為：
def execute_medical_behavior(dwarf, patient):
# 檢查醫療技能
if dwarf.skills.get("medical", 0) < 1:
return False # 無醫療技能
behavior = MedicalBehavior(
target=patient,
priority=9 # 高優先級
)
# 中斷當前行為（如果不是緊急）
if dwarf.current_behavior.priority < 9:
interrupt_current_behavior(dwarf)
execute_behavior(dwarf, behavior)逃跑行為：
def execute_escape_behavior(dwarf, threat):
behavior = EscapeBehavior(
threat=threat,
priority=8 # 高優先級
)
# 中斷當前行為
interrupt_current_behavior(dwarf)
# 尋找安全地點
safe_location = find_safe_location(dwarf, threat)
behavior.target_location = safe_location
execute_behavior(dwarf, behavior)社交行為
交談行為：
def execute_conversation_behavior(dwarf_a, dwarf_b):
behavior = ConversationBehavior(
participants=[dwarf_a, dwarf_b],
duration=random.randint(50, 150),
priority=3 # 中等優先級
)
# 雙方都執行交談行為
schedule_behavior(dwarf_a, behavior)
schedule_behavior(dwarf_b, behavior)
# 更新關係
develop_relationship(dwarf_a, dwarf_b, interaction={
"type": "conversation",
"quality": calculate_conversation_quality(dwarf_a, dwarf_b)
})聚會行為：
def execute_gathering_behavior(participants):
behavior = GatheringBehavior(
participants=participants,
location=select_gathering_location(participants),
duration=random.randint(100, 300),
priority=4 # 中等偏高優先級
)
# 所有參與者執行聚會行為
for participant in participants:
schedule_behavior(participant, behavior)
# 更新所有參與者之間的關係
for i, dwarf_a in enumerate(participants):
for dwarf_b in participants[i+1:]:
develop_relationship(dwarf_a, dwarf_b, interaction={
"type": "gathering",
"quality": calculate_gathering_quality(participants)
})創造性行為
藝術創作行為：
def execute_art_creation_behavior(dwarf, art_type):
# 檢查創造需求
if not dwarf.need_hierarchy.has_need("creativity"):
return False
behavior = ArtCreationBehavior(
art_type=art_type,
priority=5 # 中等優先級
)
# 需要材料和工具
behavior.required_resources = get_art_resources(art_type)
behavior.required_tools = get_art_tools(art_type)
execute_behavior(dwarf, behavior)
# 完成後創建藝術品
if behavior.status == BehaviorStatus.COMPLETED:
artwork = create_artwork(dwarf, art_type, behavior.quality)
add_item_to_world(artwork)異常行為
精神崩潰行為：
def execute_stress_breakdown_behavior(dwarf):
breakdown_type = determine_breakdown_type(dwarf)
if breakdown_type == "tantrum":
behavior = TantrumBehavior(
priority=7 # 高優先級（會中斷其他行為）
)
elif breakdown_type == "violence":
behavior = ViolenceBehavior(
priority=8 # 高優先級
)
elif breakdown_type == "withdrawal":
behavior = WithdrawalBehavior(
priority=6 # 中等高優先級
)
elif breakdown_type == "destruction":
behavior = DestructionBehavior(
priority=7 # 高優先級
)
# 中斷所有當前行為
interrupt_all_behaviors(dwarf)
execute_behavior(dwarf, behavior)9. 系統交互與影響
AI系統與其他系統的交互
與經濟系統的交互：
- 需求驅動生產
- 工作選擇影響生產效率
- 情緒影響工作效率
與數值系統的交互：
- 技能影響行為選擇
- 屬性影響行為執行
- 行為影響技能經驗
與文明演進系統的交互：
- 矮人行為成為歷史事件
- 歷史事件影響矮人情緒
- 關係網絡影響派系關係
行為對遊戲世界的影響
直接影響：
- 改變世界狀態（建造、挖掘、破壞）
- 創造物品（製作、藝術創作）
- 影響其他生物（戰鬥、醫療、社交）
間接影響：
- 影響資源分佈
- 影響建築佈局
- 影響社會關係
玩家干預機制
間接控制：
- 設置工作優先級
- 建造設施
- 管理資源
- 分配任務
直接干預：
- 緊急情況下可以強制行為
- 可以禁止特定行為
- 可以指定特定矮人執行任務
干預限制：
- 不能直接控制矮人移動
- 不能強制違反需求的行為
- 干預有成本（如降低情緒）
系統平衡設計
平衡原則：
- 需求與滿足的平衡
- 工作與休息的平衡
- 個人與集體的平衡
- 自主性與控制的平衡
平衡機制：
def maintain_system_balance():
# 檢查系統狀態
system_health = calculate_system_health()
if system_health < 0.5:
# 系統不平衡，進行調整
adjust_priorities()
adjust_resource_allocation()
trigger_balancing_events()10. 設計思路總結
自主性優先的設計原理
核心思想：
- 矮人具有高度自主性
- 玩家通過間接方式引導
- 創造真實的模擬體驗
實現方式：
- 需求驅動行為選擇
- 情緒影響決策
- 關係影響合作
- 技能影響能力
設計優勢：
- 創造真實感
- 產生涌現性玩法
- 增加遊戲挑戰
- 創造獨特敍事
情緒即玩法的設計創新
創新點：
- 情緒不是裝飾，而是核心機制
- 情緒影響所有方面
- 管理情緒是重要挑戰
設計意義：
- 創造獨特的遊戲體驗
- 增加策略深度
- 產生豐富敍事
可借鑑性：
- 適用於需要角色管理的遊戲
- 適用於需要敍事深度的遊戲
- 適用於需要策略選擇的遊戲
需求驅動的行為系統
核心思想：
- 行為基於需求層次
- 需求未滿足影響行為
- 創造自然的遊戲節奏
實現方式：
- 馬斯洛需求層次理論的應用
- 需求優先級機制
- 需求滿足度計算
- 需求對行為的影響
設計優勢：
- 創造真實感
- 減少玩家負擔
- 產生自然行為
- 支持涌現性玩法
可借鑑的設計模式
狀態機模式：
- 行為狀態使用狀態機管理
- 情緒狀態使用狀態機管理
- 簡化複雜狀態管理
觀察者模式：
- 需求變化通知行為系統
- 情緒變化通知相關係統
- 支持解耦的事件處理
策略模式：
- 不同行為使用不同策略
- 不同決策使用不同算法
- 支持靈活的策略切換
命令模式：
- 行為使用命令模式
- 支持行為撤銷和重做
- 支持行為隊列管理
技術實現建議
數據結構：
- 使用高效的數據結構存儲關係網絡
- 使用優先級隊列管理工作
- 使用索引優化查詢
算法優化：
- 使用緩存優化決策計算
- 使用批量處理減少開銷
- 使用空間分區優化地理查詢
性能優化：
- 延遲計算非關鍵數據
- 批量更新減少開銷
- 使用對象池減少內存分配
可擴展性：
- 使用插件系統支持擴展
- 使用配置系統支持定製
- 預留擴展點支持未來功能
總結
AI與行為系統是《矮人要塞》最核心的創新之一，它通過需求驅動、情緒系統、社交關係網絡等設計，創造了一個真實而複雜的AI系統。特別是"自主性優先"和"情緒即玩法"的設計理念，為遊戲設計提供了寶貴的參考。
通過深入分析這個系統的設計原理和實現思路，我們可以學習到：
- 如何通過需求驅動創造自然的遊戲節奏
- 如何設計情緒系統作為核心玩法機制
- 如何實現複雜的AI決策系統
- 如何管理大量AI實體的行為
- 如何平衡自主性和玩家控制
這些設計思路不僅適用於類似遊戲，也可以應用於其他需要複雜AI系統的遊戲類型。通過學習和借鑑這些設計理念，我們可以創造出更加豐富和有趣的遊戲體驗。
