diff --git a/PROJECT_ANALYSIS.md b/PROJECT_ANALYSIS.md
deleted file mode 100644
index ba7604e..0000000
--- a/PROJECT_ANALYSIS.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# 斗地主AI项目完整性分析报告
-
-**分析时间:** 2025-02-21 04:57:32 UTC
-**分析人:** SisMaker
-**项目版本:** 2.0.0
-
-## 核心功能完整性评估
-
-### 1. 基础游戏系统 (完成度：95%)
-✅ 游戏规则引擎
-✅ 牌型判断系统
-✅ 玩家管理
-✅ 游戏流程控制
-
-### 2. AI决策系统 (完成度：90%)
-✅ 基础决策逻辑
-✅ 深度学习模型
-✅ 对手建模
-✅ 策略优化器
-
-### 3. 学习系统 (完成度：85%)
-✅ 经验积累机制
-✅ 模型训练系统
-✅ 在线学习能力
-❌ 分布式学习支持
-
-### 4. 性能优化 (完成度：80%)
-✅ 基础性能优化
-✅ 内存管理
-❌ 完整的性能测试
-❌ 负载均衡
\ No newline at end of file
diff --git a/README.md b/README.md
index 49ef6a0..8c0b264 100644
--- a/README.md
+++ b/README.md
@@ -16,162 +16,5 @@ Build
 
 ## 系统架构
 
-### 核心模块
 
-1. **游戏核心模块**
-    - cards.erl: 牌类操作
-    - card_rules.erl: 游戏规则
-    - game_server.erl: 游戏服务器
-    - player.erl: 玩家管理
-
-2. **AI系统模块**
-    - deep_learning.erl: 深度学习引擎
-    - advanced_ai_player.erl: 高级AI玩家
-    - matrix.erl: 矩阵运算
-    - optimizer.erl: 优化器
-
-3. **系统支持模块**
-    - parallel_compute.erl: 并行计算
-    - performance_monitor.erl: 性能监控
-
-## 功能特性
-
-### 1. 基础游戏功能
-- 完整的斗地主规则实现
-- 多人游戏支持
-- 房间管理系统
-- 积分系统
-
-### 2. AI系统
-#### 2.1 深度学习功能
-- 多层神经网络
-- 多种优化器（Adam, SGD）
-- 实时学习能力
-- 策略适应
-
-#### 2.2 AI玩家特性
-- 多种性格特征（激进、保守、平衡、自适应）
-- 动态决策系统
-- 对手模式识别
-- 自适应学习
-
-### 3. 系统性能
-#### 3.1 并行计算
-- 工作进程池管理
-- 负载均衡
-- 异步处理
-- 结果聚合
-
-#### 3.2 性能监控
-- 实时性能指标收集
-- 自动化性能分析
-- 告警系统
-- 性能报告生成
-
-### 4. 可视化分析
-- 多种图表类型支持
-- 实时数据更新
-- 多格式导出
-- 自定义显示选项
-
-## 技术实现
-
-### 1. 深度学习实现
-```erlang
-% 示例：创建神经网络
-NetworkConfig = [64, 128, 64, 32],
-{ok, Network} = deep_learning:create_network(NetworkConfig).
-```
-
-### 2. 并行处理
-```erlang
-% 示例：并行预测
-Inputs = [Input1, Input2, Input3],
-{ok, Results} = parallel_compute:parallel_predict(Inputs, Network).
-```
-
-### 3. 性能监控
-```erlang
-% 示例：启动监控
-{ok, MonitorId} = performance_monitor:start_monitoring(Network).
-```
-
-## 系统要求
-
-- Erlang/OTP 21+
-- 支持并行计算的多核系统
-- 足够的内存支持深度学习运算
-- 图形库支持（用于可视化）
-
-## 性能指标
-
-- 支持同时运行多个游戏房间
-- AI决策响应时间 < 1秒
-- 支持实时性能监控和分析
-- 可扩展到分布式系统
-
-## 已实现功能列表
-
-### 游戏核心功能
-- [x] 完整的斗地主规则实现
-- [x] 多玩家支持
-- [x] 房间管理
-- [x] 积分系统
-
-### AI功能
-- [x] 深度学习引擎
-- [x] 多种AI性格
-- [x] 自适应学习
-- [x] 策略优化
-
-### 系统功能
-- [x] 并行计算
-- [x] 性能监控
-- [x] 可视化分析
-- [x] 实时数据处理
-
-## 待优化功能
-
-1. 分布式系统支持
-2. 数据持久化
-3. 更多AI算法
-4. Web界面
-5. 移动端支持
-6. 安全性增强
-7. 容错机制
-8. 日志系统
-
-## 使用说明
-
-### 1. 启动系统
-```erlang
-
-% 运行测试
-ai_test:run_test().
-```
-
-### 2. 创建游戏房间
-```erlang
-{ok, RoomId} = room_manager:create_room("新手房", PlayerPid).
-```
-
-### 3. 添加AI玩家
-```erlang
-{ok, AiPlayer} = advanced_ai_player:start_link("AI_Player", aggressive).
-```
-
-## 错误处理
-
-系统实现了基本的错误处理机制：
-- 游戏异常处理
-- AI系统容错
-- 并行计算错误恢复
-- 性能监控告警
-
-## 维护建议
-
-1. 定期检查性能监控报告
-2. 更新AI模型训练数据
-3. 优化并行计算配置
-4. 备份系统数据
 
diff --git a/src/xx.erl1 b/src/xx.erl1
index 4055f6c..9a8c19e 100644
--- a/src/xx.erl1
+++ b/src/xx.erl1
@@ -1,658 +1,658 @@
--module(xx).
+-module(ai_core).
 
 -export([
-	init/1,
-	make_decision/2,
-	evaluate_hand/1,
-	predict_plays/2,
-	update_knowledge/2,
-	calculate_win_rate/1
+    init/1,
+    make_decision/2,
+    evaluate_hand/1,
+    predict_plays/2,
+    update_knowledge/2,
+    calculate_win_rate/1
 ]).
 
 -include("card_types.hrl").
--import(game_logic, [validate_play/2, analyze_card_pattern/1, calculate_card_value/1, evaluate_hand_strength/1,find_singles/1]).
+-import(game_logic, [validate_play/2, analyze_card_pattern/1, calculate_card_value/1, evaluate_hand_strength/1, find_singles/1]).
 
 -record(ai_state, {
-	role,                % dizhu | nongmin
-	hand_cards = [],     % 当前手牌
-	known_cards = [],    % 已知的牌
-	played_cards = [],   % 已打出的牌
-	player_history = [], % 玩家出牌历史
-	game_stage,         % early_game | mid_game | end_game
-	strategy_cache = #{} % 策略缓存
+    role,                % dizhu | nongmin
+    hand_cards = [],     % 当前手牌
+    known_cards = [],    % 已知的牌
+    played_cards = [],   % 已打出的牌
+    player_history = [], % 玩家出牌历史
+    game_stage,         % early_game | mid_game | end_game
+    strategy_cache = #{} % 策略缓存
 }).
 
 -record(play_context, {
-	last_play,          % 上一手牌
-	cards_remaining,    % 剩余手牌数
-	num_greater_cards,  % 比上家大的牌数量
-	control_factor,     % 控制因子
-	must_play = false   % 是否必须出牌
+    last_play,          % 上一手牌
+    cards_remaining,    % 剩余手牌数
+    num_greater_cards,  % 比上家大的牌数量
+    control_factor,     % 控制因子
+    must_play = false   % 是否必须出牌
 }).
 
 %% 初始化AI状态
 init(Role) ->
-	#ai_state{
-		role = Role,
-		game_stage = early_game
-	}.
+    #ai_state{
+        role = Role,
+        game_stage = early_game
+    }.
 
 %% 做出决策
 make_decision(AIState, GameState) ->
-	Context = analyze_context(AIState, GameState),
-	case should_play(Context, AIState) of
-		true ->
-			select_best_play(Context, AIState);
-		false ->
-			{pass, AIState}
-	end.
+    Context = analyze_context(AIState, GameState),
+    case should_play(Context, AIState) of
+        true ->
+            select_best_play(Context, AIState);
+        false ->
+            {pass, AIState}
+    end.
 
 %% 评估手牌
 evaluate_hand(Cards) ->
-	Components = analyze_components(Cards),
-	calculate_hand_value(Components).
+    Components = analyze_components(Cards),
+    calculate_hand_value(Components).
 
 %% 预测可能的出牌
 predict_plays(Cards, LastPlay) ->
-	ValidPlays = generate_valid_plays(Cards, LastPlay),
-	score_potential_plays(ValidPlays, LastPlay).
+    ValidPlays = generate_valid_plays(Cards, LastPlay),
+    score_potential_plays(ValidPlays, LastPlay).
 
 %% 更新知识库
 update_knowledge(AIState, Event) ->
-	update_state_with_event(AIState, Event).
+    update_state_with_event(AIState, Event).
 
 %% 计算胜率
 calculate_win_rate(AIState) ->
-	HandStrength = evaluate_hand(AIState#ai_state.hand_cards),
-	PositionValue = evaluate_position(AIState),
-	ControlValue = evaluate_control(AIState),
+    HandStrength = evaluate_hand(AIState#ai_state.hand_cards),
+    PositionValue = evaluate_position(AIState),
+    ControlValue = evaluate_control(AIState),
 
-	calculate_probability(HandStrength, PositionValue, ControlValue).
+    calculate_probability(HandStrength, PositionValue, ControlValue).
 
 %% 内部函数
 
 %% 分析上下文
 analyze_context(AIState, GameState) ->
-	LastPlay = get_last_play(GameState),
-	CardsRemaining = length(AIState#ai_state.hand_cards),
-	GreaterCards = count_greater_cards(AIState#ai_state.hand_cards, LastPlay),
-	ControlFactor = calculate_control_factor(AIState, GameState),
-
-	#play_context{
-		last_play = LastPlay,
-		cards_remaining = CardsRemaining,
-		num_greater_cards = GreaterCards,
-		control_factor = ControlFactor,
-		must_play = must_play(AIState, GameState)
-	}.
+    LastPlay = get_last_play(GameState),
+    CardsRemaining = length(AIState#ai_state.hand_cards),
+    GreaterCards = count_greater_cards(AIState#ai_state.hand_cards, LastPlay),
+    ControlFactor = calculate_control_factor(AIState, GameState),
+
+    #play_context{
+        last_play = LastPlay,
+        cards_remaining = CardsRemaining,
+        num_greater_cards = GreaterCards,
+        control_factor = ControlFactor,
+        must_play = must_play(AIState, GameState)
+    }.
 
 %% 判断是否应该出牌
 should_play(Context, AIState) ->
-	case Context#play_context.must_play of
-		true -> true;
-		false ->
-			case Context#play_context.last_play of
-				none -> true;
-				_ ->
-					should_beat_last_play(Context, AIState)
-			end
-	end.
+    case Context#play_context.must_play of
+        true -> true;
+        false ->
+            case Context#play_context.last_play of
+                none -> true;
+                _ ->
+                    should_beat_last_play(Context, AIState)
+            end
+    end.
 
 %% 选择最佳出牌
 select_best_play(Context, AIState) ->
-	Candidates = generate_candidates(AIState#ai_state.hand_cards, Context),
-	ScoredPlays = [
-		{score_play(Play, Context, AIState), Play}
-		|| Play <- Candidates
-	],
-	select_highest_scored_play(ScoredPlays, AIState).
+    Candidates = generate_candidates(AIState#ai_state.hand_cards, Context),
+    ScoredPlays = [
+        {score_play(Play, Context, AIState), Play}
+        || Play <- Candidates
+    ],
+    select_highest_scored_play(ScoredPlays, AIState).
 
 %% 分析牌型组件
 analyze_components(Cards) ->
-	GroupedCards = group_cards_by_value(Cards),
-	#{
-		singles => find_singles(GroupedCards),
-		pairs => find_pairs(GroupedCards),
-		triples => find_triples(GroupedCards),
-		sequences => find_sequences(GroupedCards),
-		bombs => find_bombs(GroupedCards)
-	}.
+    GroupedCards = group_cards_by_value(Cards),
+    #{
+        singles => find_singles(GroupedCards),
+        pairs => find_pairs(GroupedCards),
+        triples => find_triples(GroupedCards),
+        sequences => find_sequences(GroupedCards),
+        bombs => find_bombs(GroupedCards)
+    }.
 
 %% 计算手牌价值
 calculate_hand_value(Components) ->
-	SinglesValue = calculate_singles_value(maps:get(singles, Components, [])),
-	PairsValue = calculate_pairs_value(maps:get(pairs, Components, [])),
-	TriplesValue = calculate_triples_value(maps:get(triples, Components, [])),
-	SequencesValue = calculate_sequences_value(maps:get(sequences, Components, [])),
-	BombsValue = calculate_bombs_value(maps:get(bombs, Components, [])),
+    SinglesValue = calculate_singles_value(maps:get(singles, Components, [])),
+    PairsValue = calculate_pairs_value(maps:get(pairs, Components, [])),
+    TriplesValue = calculate_triples_value(maps:get(triples, Components, [])),
+    SequencesValue = calculate_sequences_value(maps:get(sequences, Components, [])),
+    BombsValue = calculate_bombs_value(maps:get(bombs, Components, [])),
 
-	SinglesValue + PairsValue + TriplesValue + SequencesValue + BombsValue.
+    SinglesValue + PairsValue + TriplesValue + SequencesValue + BombsValue.
 
 %% 生成有效出牌选择
 generate_valid_plays(Cards, LastPlay) ->
-	case LastPlay of
-		none ->
-			generate_leading_plays(Cards);
-		Play ->
-			generate_following_plays(Cards, Play)
-	end.
+    case LastPlay of
+        none ->
+            generate_leading_plays(Cards);
+        Play ->
+            generate_following_plays(Cards, Play)
+    end.
 
 %% 评分潜在出牌
 score_potential_plays(Plays, LastPlay) ->
-	[{Play, score_play_potential(Play, LastPlay)} || Play <- Plays].
+    [{Play, score_play_potential(Play, LastPlay)} || Play <- Plays].
 
 %% 更新状态
 update_state_with_event(AIState, {play_cards, Player, Cards}) ->
-	NewPlayed = AIState#ai_state.played_cards ++ Cards,
-	NewHistory = [{Player, Cards} | AIState#ai_state.player_history],
-	AIState#ai_state{
-		played_cards = NewPlayed,
-		player_history = NewHistory
-	};
+    NewPlayed = AIState#ai_state.played_cards ++ Cards,
+    NewHistory = [{Player, Cards} | AIState#ai_state.player_history],
+    AIState#ai_state{
+        played_cards = NewPlayed,
+        player_history = NewHistory
+    };
 update_state_with_event(AIState, {game_stage, NewStage}) ->
-	AIState#ai_state{game_stage = NewStage};
+    AIState#ai_state{game_stage = NewStage};
 update_state_with_event(AIState, _) ->
-	AIState.
+    AIState.
 
 %% 计算胜率概率
 calculate_probability(HandStrength, PositionValue, ControlValue) ->
-	BaseProb = HandStrength * 0.5 + PositionValue * 0.3 + ControlValue * 0.2,
-	normalize_probability(BaseProb).
+    BaseProb = HandStrength * 0.5 + PositionValue * 0.3 + ControlValue * 0.2,
+    normalize_probability(BaseProb).
 
 %% 计算控制因子
 calculate_control_factor(AIState, GameState) ->
-	ControlCards = count_control_cards(AIState#ai_state.hand_cards),
-	TotalCards = count_total_remaining_cards(GameState),
-	RemainingCards = length(AIState#ai_state.hand_cards),
+    ControlCards = count_control_cards(AIState#ai_state.hand_cards),
+    TotalCards = count_total_remaining_cards(GameState),
+    RemainingCards = length(AIState#ai_state.hand_cards),
 
-	ControlRatio = ControlCards / max(1, RemainingCards),
-	PositionBonus = calculate_position_bonus(AIState, GameState),
+    ControlRatio = ControlCards / max(1, RemainingCards),
+    PositionBonus = calculate_position_bonus(AIState, GameState),
 
-	ControlRatio * PositionBonus.
+    ControlRatio * PositionBonus.
 
 %% 判断是否必须出牌
 must_play(AIState, GameState) ->
-	is_current_player(AIState, GameState) andalso
-		not has_active_play(GameState).
+    is_current_player(AIState, GameState) andalso
+        not has_active_play(GameState).
 
 %% 评估是否应该大过上家
 should_beat_last_play(Context, AIState) ->
-	case Context#play_context.last_play of
-		none -> true;
-		LastPlay ->
-			HandStrength = evaluate_hand(AIState#ai_state.hand_cards),
-			ControlLevel = Context#play_context.control_factor,
-			CardsLeft = Context#play_context.cards_remaining,
+    case Context#play_context.last_play of
+        none -> true;
+        LastPlay ->
+            HandStrength = evaluate_hand(AIState#ai_state.hand_cards),
+            ControlLevel = Context#play_context.control_factor,
+            CardsLeft = Context#play_context.cards_remaining,
 
-			should_beat(HandStrength, ControlLevel, CardsLeft, LastPlay)
-	end.
+            should_beat(HandStrength, ControlLevel, CardsLeft, LastPlay)
+    end.
 
 %% 生成候选出牌
 generate_candidates(Cards, Context) ->
-	BasePlays = case Context#play_context.last_play of
-		none -> generate_leading_plays(Cards);
-		LastPlay -> generate_following_plays(Cards, LastPlay)
-	end,
+    BasePlays = case Context#play_context.last_play of
+        none -> generate_leading_plays(Cards);
+        LastPlay -> generate_following_plays(Cards, LastPlay)
+    end,
 
-	filter_candidates(BasePlays, Context).
+    filter_candidates(BasePlays, Context).
 
 %% 对出牌进行评分
 score_play(Play, Context, AIState) ->
-	BaseScore = calculate_base_score(Play),
-	TempoScore = calculate_tempo_score(Play, Context),
-	ControlScore = calculate_control_score(Play, Context, AIState),
-	EfficiencyScore = calculate_efficiency_score(Play, Context),
+    BaseScore = calculate_base_score(Play),
+    TempoScore = calculate_tempo_score(Play, Context),
+    ControlScore = calculate_control_score(Play, Context, AIState),
+    EfficiencyScore = calculate_efficiency_score(Play, Context),
 
-	FinalScore = BaseScore * 0.4 +
-		TempoScore * 0.2 +
-		ControlScore * 0.3 +
-		EfficiencyScore * 0.1,
+    FinalScore = BaseScore * 0.4 +
+        TempoScore * 0.2 +
+        ControlScore * 0.3 +
+        EfficiencyScore * 0.1,
 
-	adjust_score_for_context(FinalScore, Play, Context, AIState).
+    adjust_score_for_context(FinalScore, Play, Context, AIState).
 
 %% 选择得分最高的出牌
 select_highest_scored_play(ScoredPlays, AIState) ->
-	case lists:sort(fun({Score1, _}, {Score2, _}) ->
-		Score1 >= Score2
-	end, ScoredPlays) of
-		[{Score, Play}|_] when Score > 0 ->
-			{play, Play, update_after_play(Play, AIState)};
-		_ ->
-			{pass, AIState}
-	end.
+    case lists:sort(fun({Score1, _}, {Score2, _}) ->
+        Score1 >= Score2
+    end, ScoredPlays) of
+        [{Score, Play}|_] when Score > 0 ->
+            {play, Play, update_after_play(Play, AIState)};
+        _ ->
+            {pass, AIState}
+    end.
 
 %% 计算单牌价值
 calculate_singles_value(Singles) ->
-	lists:sum([
-		case Value of
-			V when V >= ?CARD_2 -> Value * 1.5;
-			_ -> Value
-		end || {Value, _} <- Singles
-	]).
+    lists:sum([
+        case Value of
+            V when V >= ?CARD_VALUE_2 -> Value * 1.5;
+            _ -> Value
+        end || {Value, _} <- Singles
+    ]).
 
 %% 计算对子价值
 calculate_pairs_value(Pairs) ->
-	lists:sum([Value * 2.2 || {Value, _} <- Pairs]).
+    lists:sum([Value * 2.2 || {Value, _} <- Pairs]).
 
 %% 计算三张价值
 calculate_triples_value(Triples) ->
-	lists:sum([Value * 3.5 || {Value, _} <- Triples]).
+    lists:sum([Value * 3.5 || {Value, _} <- Triples]).
 
 %% 计算顺子价值
 calculate_sequences_value(Sequences) ->
-	lists:sum([
-		Value * length(Cards) * 1.8
-		|| {Value, Cards} <- Sequences
-	]).
+    lists:sum([
+        Value * length(Cards) * 1.8
+        || {Value, Cards} <- Sequences
+    ]).
 
 %% 计算炸弹价值
 calculate_bombs_value(Bombs) ->
-	lists:sum([Value * 10.0 || {Value, _} <- Bombs]).
+    lists:sum([Value * 10.0 || {Value, _} <- Bombs]).
 
 %% 生成首出牌型
 generate_leading_plays(Cards) ->
-	Components = analyze_components(Cards),
-	Singles = generate_single_plays(Components),
-	Pairs = generate_pair_plays(Components),
-	Triples = generate_triple_plays(Components),
-	Sequences = generate_sequence_plays(Components),
-	Bombs = generate_bomb_plays(Components),
+    Components = analyze_components(Cards),
+    Singles = generate_single_plays(Components),
+    Pairs = generate_pair_plays(Components),
+    Triples = generate_triple_plays(Components),
+    Sequences = generate_sequence_plays(Components),
+    Bombs = generate_bomb_plays(Components),
 
-	Singles ++ Pairs ++ Triples ++ Sequences ++ Bombs.
+    Singles ++ Pairs ++ Triples ++ Sequences ++ Bombs.
 
 %% 生成跟牌选择
 generate_following_plays(Cards, {Type, Value, _} = LastPlay) ->
-	ValidPlays = find_greater_plays(Cards, Type, Value),
-	BombPlays = find_bomb_plays(Cards),
-	RocketPlay = find_rocket_play(Cards),
+    ValidPlays = find_greater_plays(Cards, Type, Value),
+    BombPlays = find_bomb_plays(Cards),
+    RocketPlay = find_rocket_play(Cards),
 
-	ValidPlays ++ BombPlays ++ RocketPlay.
+    ValidPlays ++ BombPlays ++ RocketPlay.
 
 %% 计算基础分数
 calculate_base_score({Type, Value, Cards}) ->
-	BaseValue = Value * length(Cards),
-	TypeMultiplier = case Type of
-		?CARD_TYPE_ROCKET -> 100.0;
-		?CARD_TYPE_BOMB -> 80.0;
-		?CARD_TYPE_STRAIGHT -> 40.0;
-		?CARD_TYPE_STRAIGHT_PAIR -> 35.0;
-		?CARD_TYPE_PLANE -> 30.0;
-		?CARD_TYPE_THREE_TWO -> 25.0;
-		?CARD_TYPE_THREE_ONE -> 20.0;
-		?CARD_TYPE_THREE -> 15.0;
-		?CARD_TYPE_PAIR -> 10.0;
-		?CARD_TYPE_SINGLE -> 5.0
-	end,
-	BaseValue * TypeMultiplier / 100.0.
+    BaseValue = Value * length(Cards),
+    TypeMultiplier = case Type of
+        ?CARD_TYPE_ROCKET -> 100.0;
+        ?CARD_TYPE_BOMB -> 80.0;
+        ?CARD_TYPE_STRAIGHT -> 40.0;
+        ?CARD_TYPE_STRAIGHT_PAIR -> 35.0;
+        ?CARD_TYPE_PLANE -> 30.0;
+        ?CARD_TYPE_THREE_TWO -> 25.0;
+        ?CARD_TYPE_THREE_ONE -> 20.0;
+        ?CARD_TYPE_THREE -> 15.0;
+        ?CARD_TYPE_PAIR -> 10.0;
+        ?CARD_TYPE_SINGLE -> 5.0
+    end,
+    BaseValue * TypeMultiplier / 100.0.
 
 %% 计算节奏分数
 calculate_tempo_score(Play, Context) ->
-	case Context#play_context.game_stage of
-		early_game -> calculate_early_tempo(Play, Context);
-		mid_game -> calculate_mid_tempo(Play, Context);
-		end_game -> calculate_end_tempo(Play, Context)
-	end.
+    case Context#play_context.game_stage of
+        early_game -> calculate_early_tempo(Play, Context);
+        mid_game -> calculate_mid_tempo(Play, Context);
+        end_game -> calculate_end_tempo(Play, Context)
+    end.
 
 %% 计算控制分数
 calculate_control_score(Play, Context, AIState) ->
-	{Type, Value, _} = Play,
-	BaseControl = case Type of
-		?CARD_TYPE_BOMB -> 1.0;
-		?CARD_TYPE_ROCKET -> 1.0;
-		_ when Value >= ?CARD_2 -> 0.8;
-		_ -> 0.5
-	end,
-	BaseControl * Context#play_context.control_factor.
+    {Type, Value, _} = Play,
+    BaseControl = case Type of
+        ?CARD_TYPE_BOMB -> 1.0;
+        ?CARD_TYPE_ROCKET -> 1.0;
+        _ when Value >= ?CARD_VALUE_2 -> 0.8;
+        _ -> 0.5
+    end,
+    BaseControl * Context#play_context.control_factor.
 
 %% 计算效率分数
 calculate_efficiency_score(Play, Context) ->
-	{_, _, Cards} = Play,
-	CardsUsed = length(Cards),
-	RemainingCards = Context#play_context.cards_remaining - CardsUsed,
-	Efficiency = CardsUsed / max(1, Context#play_context.cards_remaining),
-	Efficiency * (1 + (20 - RemainingCards) / 20).
+    {_, _, Cards} = Play,
+    CardsUsed = length(Cards),
+    RemainingCards = Context#play_context.cards_remaining - CardsUsed,
+    Efficiency = CardsUsed / max(1, Context#play_context.cards_remaining),
+    Efficiency * (1 + (20 - RemainingCards) / 20).
 
 %% 根据上下文调整分数
 adjust_score_for_context(Score, Play, Context, AIState) ->
-	RoleMultiplier = case AIState#ai_state.role of
-		dizhu -> 1.2;
-		nongmin -> 1.0
-	end,
+    RoleMultiplier = case AIState#ai_state.role of
+        dizhu -> 1.2;
+        nongmin -> 1.0
+    end,
 
-	StageMultiplier = case Context#play_context.game_stage of
-		early_game -> 0.9;
-		mid_game -> 1.0;
-		end_game -> 1.1
-	end,
+    StageMultiplier = case Context#play_context.game_stage of
+        early_game -> 0.9;
+        mid_game -> 1.0;
+        end_game -> 1.1
+    end,
 
-	Score * RoleMultiplier * StageMultiplier.
+    Score * RoleMultiplier * StageMultiplier.
 
 %% 更新出牌后的状态
 update_after_play(Play, AIState) ->
-	{_, _, Cards} = Play,
-	NewHand = AIState#ai_state.hand_cards -- Cards,
-	NewPlayed = AIState#ai_state.played_cards ++ Cards,
+    {_, _, Cards} = Play,
+    NewHand = AIState#ai_state.hand_cards -- Cards,
+    NewPlayed = AIState#ai_state.played_cards ++ Cards,
 
-	AIState#ai_state{
-		hand_cards = NewHand,
-		played_cards = NewPlayed
-	}.
+    AIState#ai_state{
+        hand_cards = NewHand,
+        played_cards = NewPlayed
+    }.
 
 %% 辅助函数
 
 normalize_probability(P) ->
-	max(0.0, min(1.0, P)).
+    max(0.0, min(1.0, P)).
 
 count_control_cards(Cards) ->
-	length([C || {V, _} = C <- Cards, V >= ?CARD_2]).
+    length([C || {V, _} = C <- Cards, V >= ?CARD_VALUE_2]).
 
 calculate_position_bonus(AIState, GameState) ->
-	case get_position(AIState, GameState) of
-		first -> 1.2;
-		middle -> 1.0;
-		last -> 0.8
-	end.
+    case get_position(AIState, GameState) of
+        first -> 1.2;
+        middle -> 1.0;
+        last -> 0.8
+    end.
 
 get_position(AIState, GameState) ->
-	% 根据游戏状态判断位置
-	first.  % 简化实现，实际需要根据具体游戏状态判断
+    % 根据游戏状态判断位置
+    first.  % 简化实现，实际需要根据具体游戏状态判断
 
 is_current_player(AIState, GameState) ->
-	% 判断是否当前玩家
-	true.  % 简化实现，实际需要根据具体游戏状态判断
+    % 判断是否当前玩家
+    true.  % 简化实现，实际需要根据具体游戏状态判断
 
 has_active_play(GameState) ->
-	% 判断是否有活跃的出牌
-	false.  % 简化实现，实际需要根据具体游戏状态判断
+    % 判断是否有活跃的出牌
+    false.  % 简化实现，实际需要根据具体游戏状态判断
 
 should_beat(HandStrength, ControlLevel, CardsLeft, LastPlay) ->
-	BaseThreshold = 0.6,
-	StrengthFactor = HandStrength / 100,
-	ControlFactor = ControlLevel / 100,
-	CardsFactor = (20 - CardsLeft) / 20,
+    BaseThreshold = 0.6,
+    StrengthFactor = HandStrength / 100,
+    ControlFactor = ControlLevel / 100,
+    CardsFactor = (20 - CardsLeft) / 20,
 
-	PlayThreshold = BaseThreshold * (StrengthFactor + ControlFactor + CardsFactor) / 3,
-	evaluate_play_value(LastPlay) < PlayThreshold.
+    PlayThreshold = BaseThreshold * (StrengthFactor + ControlFactor + CardsFactor) / 3,
+    evaluate_play_value(LastPlay) < PlayThreshold.
 
 evaluate_play_value({Type, Value, Cards}) ->
-	BaseValue = case Type of
-		?CARD_TYPE_ROCKET -> 1.0;
-		?CARD_TYPE_BOMB -> 0.9;
-		?CARD_TYPE_PLANE -> 0.7;
-		?CARD_TYPE_STRAIGHT -> 0.6;
-		?CARD_TYPE_STRAIGHT_PAIR -> 0.5;
-		?CARD_TYPE_THREE_TWO -> 0.4;
-		?CARD_TYPE_THREE_ONE -> 0.3;
-		?CARD_TYPE_THREE -> 0.25;
-		?CARD_TYPE_PAIR -> 0.2;
-		?CARD_TYPE_SINGLE -> 0.1
-	end,
-
-	ValueBonus = Value / ?CARD_JOKER_BIG,
-	CardCountFactor = length(Cards) / 10,
-
-	BaseValue * (1 + ValueBonus) * (1 + CardCountFactor).
+    BaseValue = case Type of
+        ?CARD_TYPE_ROCKET -> 1.0;
+        ?CARD_TYPE_BOMB -> 0.9;
+        ?CARD_TYPE_PLANE -> 0.7;
+        ?CARD_TYPE_STRAIGHT -> 0.6;
+        ?CARD_TYPE_STRAIGHT_PAIR -> 0.5;
+        ?CARD_TYPE_THREE_TWO -> 0.4;
+        ?CARD_TYPE_THREE_ONE -> 0.3;
+        ?CARD_TYPE_THREE -> 0.25;
+        ?CARD_TYPE_PAIR -> 0.2;
+        ?CARD_TYPE_SINGLE -> 0.1
+    end,
+
+    ValueBonus = Value / ?CARD_VALUE_BIG_JOKER,
+    CardCountFactor = length(Cards) / 10,
+
+    BaseValue * (1 + ValueBonus) * (1 + CardCountFactor).
 
 %% 牌型生成函数
 generate_single_plays(Components) ->
-	[{?CARD_TYPE_SINGLE, Value, [Card]} ||
-		{Value, Card} <- maps:get(singles, Components, [])].
+    [{?CARD_TYPE_SINGLE, Value, [Card]} ||
+        {Value, Card} <- maps:get(singles, Components, [])].
 
 generate_pair_plays(Components) ->
-	[{?CARD_TYPE_PAIR, Value, Cards} ||
-		{Value, Cards} <- maps:get(pairs, Components, [])].
+    [{?CARD_TYPE_PAIR, Value, Cards} ||
+        {Value, Cards} <- maps:get(pairs, Components, [])].
 
 generate_triple_plays(Components) ->
-	Triples = maps:get(triples, Components, []),
-	BasicTriples = [{?CARD_TYPE_THREE, Value, Cards} ||
-		{Value, Cards} <- Triples],
-	% 生成三带一和三带二
-	generate_triple_combinations(Triples, Components).
+    Triples = maps:get(triples, Components, []),
+    BasicTriples = [{?CARD_TYPE_THREE, Value, Cards} ||
+        {Value, Cards} <- Triples],
+    % 生成三带一和三带二
+    generate_triple_combinations(Triples, Components).
 
 generate_sequence_plays(Components) ->
-	Sequences = maps:get(sequences, Components, []),
-	[{?CARD_TYPE_STRAIGHT, Value, Cards} ||
-		{Value, Cards} <- Sequences].
+    Sequences = maps:get(sequences, Components, []),
+    [{?CARD_TYPE_STRAIGHT, Value, Cards} ||
+        {Value, Cards} <- Sequences].
 
 generate_bomb_plays(Components) ->
-	[{?CARD_TYPE_BOMB, Value, Cards} ||
-		{Value, Cards} <- maps:get(bombs, Components, [])].
+    [{?CARD_TYPE_BOMB, Value, Cards} ||
+        {Value, Cards} <- maps:get(bombs, Components, [])].
 
 generate_triple_combinations(Triples, Components) ->
-	Singles = maps:get(singles, Components, []),
-	Pairs = maps:get(pairs, Components, []),
+    Singles = maps:get(singles, Components, []),
+    Pairs = maps:get(pairs, Components, []),
 
-	ThreeOne = generate_three_one(Triples, Singles),
-	ThreeTwo = generate_three_two(Triples, Pairs),
+    ThreeOne = generate_three_one(Triples, Singles),
+    ThreeTwo = generate_three_two(Triples, Pairs),
 
-	ThreeOne ++ ThreeTwo.
+    ThreeOne ++ ThreeTwo.
 
 generate_three_one(Triples, Singles) ->
-	[{?CARD_TYPE_THREE_ONE, TripleValue, TripleCards ++ [SingleCard]} ||
-		{TripleValue, TripleCards} <- Triples,
-		{SingleValue, SingleCard} <- Singles,
-		SingleValue =/= TripleValue].
+    [{?CARD_TYPE_THREE_ONE, TripleValue, TripleCards ++ [SingleCard]} ||
+        {TripleValue, TripleCards} <- Triples,
+        {SingleValue, SingleCard} <- Singles,
+        SingleValue =/= TripleValue].
 
 generate_three_two(Triples, Pairs) ->
-	[{?CARD_TYPE_THREE_TWO, TripleValue, TripleCards ++ PairCards} ||
-		{TripleValue, TripleCards} <- Triples,
-		{PairValue, PairCards} <- Pairs,
-		PairValue =/= TripleValue].
+    [{?CARD_TYPE_THREE_TWO, TripleValue, TripleCards ++ PairCards} ||
+        {TripleValue, TripleCards} <- Triples,
+        {PairValue, PairCards} <- Pairs,
+        PairValue =/= TripleValue].
 
 %% 查找特定牌型
 find_greater_plays(Cards, Type, MinValue) ->
-	Components = analyze_components(Cards),
-	case Type of
-		?CARD_TYPE_SINGLE ->
-			find_greater_singles(Components, MinValue);
-		?CARD_TYPE_PAIR ->
-			find_greater_pairs(Components, MinValue);
-		?CARD_TYPE_THREE ->
-			find_greater_triples(Components, MinValue);
-		?CARD_TYPE_THREE_ONE ->
-			find_greater_three_one(Components, MinValue);
-		?CARD_TYPE_THREE_TWO ->
-			find_greater_three_two(Components, MinValue);
-		?CARD_TYPE_STRAIGHT ->
-			find_greater_straight(Components, MinValue);
-		?CARD_TYPE_STRAIGHT_PAIR ->
-			find_greater_straight_pair(Components, MinValue);
-		?CARD_TYPE_PLANE ->
-			find_greater_plane(Components, MinValue);
-		?CARD_TYPE_BOMB ->
-			find_greater_bomb(Components, MinValue);
-		_ -> []
-	end.
+    Components = analyze_components(Cards),
+    case Type of
+        ?CARD_TYPE_SINGLE ->
+            find_greater_singles(Components, MinValue);
+        ?CARD_TYPE_PAIR ->
+            find_greater_pairs(Components, MinValue);
+        ?CARD_TYPE_THREE ->
+            find_greater_triples(Components, MinValue);
+        ?CARD_TYPE_THREE_ONE ->
+            find_greater_three_one(Components, MinValue);
+        ?CARD_TYPE_THREE_TWO ->
+            find_greater_three_two(Components, MinValue);
+        ?CARD_TYPE_STRAIGHT ->
+            find_greater_straight(Components, MinValue);
+        ?CARD_TYPE_STRAIGHT_PAIR ->
+            find_greater_straight_pair(Components, MinValue);
+        ?CARD_TYPE_PLANE ->
+            find_greater_plane(Components, MinValue);
+        ?CARD_TYPE_BOMB ->
+            find_greater_bomb(Components, MinValue);
+        _ -> []
+    end.
 
 find_greater_singles(Components, MinValue) ->
-	[{?CARD_TYPE_SINGLE, Value, [Card]} ||
-		{Value, Card} <- maps:get(singles, Components, []),
-		Value > MinValue].
+    [{?CARD_TYPE_SINGLE, Value, [Card]} ||
+        {Value, Card} <- maps:get(singles, Components, []),
+        Value > MinValue].
 
 find_greater_pairs(Components, MinValue) ->
-	[{?CARD_TYPE_PAIR, Value, Cards} ||
-		{Value, Cards} <- maps:get(pairs, Components, []),
-		Value > MinValue].
+    [{?CARD_TYPE_PAIR, Value, Cards} ||
+        {Value, Cards} <- maps:get(pairs, Components, []),
+        Value > MinValue].
 
 find_greater_triples(Components, MinValue) ->
-	[{?CARD_TYPE_THREE, Value, Cards} ||
-		{Value, Cards} <- maps:get(triples, Components, []),
-		Value > MinValue].
+    [{?CARD_TYPE_THREE, Value, Cards} ||
+        {Value, Cards} <- maps:get(triples, Components, []),
+        Value > MinValue].
 
 find_greater_three_one(Components, MinValue) ->
-	Triples = [{V, C} || {V, C} <- maps:get(triples, Components, []),
-		V > MinValue],
-	Singles = maps:get(singles, Components, []),
-	generate_three_one(Triples, Singles).
+    Triples = [{V, C} || {V, C} <- maps:get(triples, Components, []),
+        V > MinValue],
+    Singles = maps:get(singles, Components, []),
+    generate_three_one(Triples, Singles).
 
 find_greater_three_two(Components, MinValue) ->
-	Triples = [{V, C} || {V, C} <- maps:get(triples, Components, []),
-		V > MinValue],
-	Pairs = maps:get(pairs, Components, []),
-	generate_three_two(Triples, Pairs).
+    Triples = [{V, C} || {V, C} <- maps:get(triples, Components, []),
+        V > MinValue],
+    Pairs = maps:get(pairs, Components, []),
+    generate_three_two(Triples, Pairs).
 
 find_greater_straight(Components, MinValue) ->
-	Sequences = maps:get(sequences, Components, []),
-	[{?CARD_TYPE_STRAIGHT, Value, Cards} ||
-		{Value, Cards} <- Sequences,
-		Value > MinValue].
+    Sequences = maps:get(sequences, Components, []),
+    [{?CARD_TYPE_STRAIGHT, Value, Cards} ||
+        {Value, Cards} <- Sequences,
+        Value > MinValue].
 
 find_greater_straight_pair(Components, MinValue) ->
-	Sequences = find_pair_sequences(Components),
-	[{?CARD_TYPE_STRAIGHT_PAIR, Value, Cards} ||
-		{Value, Cards} <- Sequences,
-		Value > MinValue].
+    Sequences = find_pair_sequences(Components),
+    [{?CARD_TYPE_STRAIGHT_PAIR, Value, Cards} ||
+        {Value, Cards} <- Sequences,
+        Value > MinValue].
 
 find_greater_plane(Components, MinValue) ->
-	Planes = find_planes(Components),
-	[{?CARD_TYPE_PLANE, Value, Cards} ||
-		{Value, Cards} <- Planes,
-		Value > MinValue].
+    Planes = find_planes(Components),
+    [{?CARD_TYPE_PLANE, Value, Cards} ||
+        {Value, Cards} <- Planes,
+        Value > MinValue].
 
 find_greater_bomb(Components, MinValue) ->
-	[{?CARD_TYPE_BOMB, Value, Cards} ||
-		{Value, Cards} <- maps:get(bombs, Components, []),
-		Value > MinValue].
+    [{?CARD_TYPE_BOMB, Value, Cards} ||
+        {Value, Cards} <- maps:get(bombs, Components, []),
+        Value > MinValue].
 
 find_bomb_plays(Cards) ->
-	Components = analyze_components(Cards),
-	[{?CARD_TYPE_BOMB, Value, Cards} ||
-		{Value, Cards} <- maps:get(bombs, Components, [])].
+    Components = analyze_components(Cards),
+    [{?CARD_TYPE_BOMB, Value, Cards} ||
+        {Value, Cards} <- maps:get(bombs, Components, [])].
 
 find_rocket_play(Cards) ->
-	Components = analyze_components(Cards),
-	case find_rocket(Components) of
-		{ok, Rocket} -> [Rocket];
-		_ -> []
-	end.
+    Components = analyze_components(Cards),
+    case find_rocket(Components) of
+        {ok, Rocket} -> [Rocket];
+        _ -> []
+    end.
 
 find_rocket(Components) ->
-	case {find_card(?CARD_JOKER_SMALL, Components),
-		find_card(?CARD_JOKER_BIG, Components)} of
-		{{ok, Small}, {ok, Big}} ->
-			{ok, {?CARD_TYPE_ROCKET, ?CARD_JOKER_BIG, [Small, Big]}};
-		_ ->
-			false
-	end.
+    case {find_card(?CARD_VALUE_SMALL_JOKER, Components),
+        find_card(?CARD_VALUE_BIG_JOKER, Components)} of
+        {{ok, Small}, {ok, Big}} ->
+            {ok, {?CARD_TYPE_ROCKET, ?CARD_VALUE_BIG_JOKER, [Small, Big]}};
+        _ ->
+            false
+    end.
 
 find_card(Value, Components) ->
-	Singles = maps:get(singles, Components, []),
-	case lists:keyfind(Value, 1, Singles) of
-		{Value, Card} -> {ok, Card};
-		_ -> false
-	end.
+    Singles = maps:get(singles, Components, []),
+    case lists:keyfind(Value, 1, Singles) of
+        {Value, Card} -> {ok, Card};
+        _ -> false
+    end.
 
 find_pair_sequences(Components) ->
-	Pairs = maps:get(pairs, Components, []),
-	find_consecutive_pairs(lists:sort(Pairs), []).
+    Pairs = maps:get(pairs, Components, []),
+    find_consecutive_pairs(lists:sort(Pairs), []).
 
 find_planes(Components) ->
-	Triples = maps:get(triples, Components, []),
-	find_consecutive_triples(lists:sort(Triples), []).
+    Triples = maps:get(triples, Components, []),
+    find_consecutive_triples(lists:sort(Triples), []).
 
 find_consecutive_pairs([], Acc) -> lists:reverse(Acc);
 find_consecutive_pairs([{V1, Cards1} | Rest], Acc) ->
-	case find_consecutive_pair_sequence(V1, Cards1, Rest) of
-		{Sequence, NewRest} when length(Sequence) >= 3 ->
-			find_consecutive_pairs(NewRest, [{V1, Sequence} | Acc]);
-		_ ->
-			find_consecutive_pairs(Rest, Acc)
-	end.
+    case find_consecutive_pair_sequence(V1, Cards1, Rest) of
+        {Sequence, NewRest} when length(Sequence) >= 3 ->
+            find_consecutive_pairs(NewRest, [{V1, Sequence} | Acc]);
+        _ ->
+            find_consecutive_pairs(Rest, Acc)
+    end.
 
 find_consecutive_pair_sequence(Value, Cards, Rest) ->
-	find_consecutive_pair_sequence(Value, Cards, Rest, [Cards]).
+    find_consecutive_pair_sequence(Value, Cards, Rest, [Cards]).
 
 find_consecutive_pair_sequence(Value, _, [], Acc) ->
-	{lists:flatten(lists:reverse(Acc)), []};
+    {lists:flatten(lists:reverse(Acc)), []};
 find_consecutive_pair_sequence(Value, _, [{NextValue, NextCards} | Rest], Acc)
-	when NextValue =:= Value + 1 ->
-	find_consecutive_pair_sequence(NextValue, NextCards, Rest, [NextCards | Acc]);
+    when NextValue =:= Value + 1 ->
+    find_consecutive_pair_sequence(NextValue, NextCards, Rest, [NextCards | Acc]);
 find_consecutive_pair_sequence(_, _, Rest, Acc) ->
-	{lists:flatten(lists:reverse(Acc)), Rest}.
+    {lists:flatten(lists:reverse(Acc)), Rest}.
 
 find_consecutive_triples([], Acc) -> lists:reverse(Acc);
 find_consecutive_triples([{V1, Cards1} | Rest], Acc) ->
-	case find_consecutive_triple_sequence(V1, Cards1, Rest) of
-		{Sequence, NewRest} when length(Sequence) >= 6 ->
-			find_consecutive_triples(NewRest, [{V1, Sequence} | Acc]);
-		_ ->
-			find_consecutive_triples(Rest, Acc)
-	end.
+    case find_consecutive_triple_sequence(V1, Cards1, Rest) of
+        {Sequence, NewRest} when length(Sequence) >= 6 ->
+            find_consecutive_triples(NewRest, [{V1, Sequence} | Acc]);
+        _ ->
+            find_consecutive_triples(Rest, Acc)
+    end.
 
 find_consecutive_triple_sequence(Value, Cards, Rest) ->
-	find_consecutive_triple_sequence(Value, Cards, Rest, [Cards]).
+    find_consecutive_triple_sequence(Value, Cards, Rest, [Cards]).
 
 find_consecutive_triple_sequence(Value, _, [], Acc) ->
-	{lists:flatten(lists:reverse(Acc)), []};
+    {lists:flatten(lists:reverse(Acc)), []};
 find_consecutive_triple_sequence(Value, _, [{NextValue, NextCards} | Rest], Acc)
-	when NextValue =:= Value + 1 ->
-	find_consecutive_triple_sequence(NextValue, NextCards, Rest, [NextCards | Acc]);
+    when NextValue =:= Value + 1 ->
+    find_consecutive_triple_sequence(NextValue, NextCards, Rest, [NextCards | Acc]);
 find_consecutive_triple_sequence(_, _, Rest, Acc) ->
-	{lists:flatten(lists:reverse(Acc)), Rest}.
+    {lists:flatten(lists:reverse(Acc)), Rest}.
 
 %% 计算早期、中期和末期的节奏分数
 calculate_early_tempo({Type, Value, _}, _Context) ->
-	case Type of
-		?CARD_TYPE_SINGLE when Value < ?CARD_2 -> 0.8;
-		?CARD_TYPE_PAIR when Value < ?CARD_2 -> 0.7;
-		?CARD_TYPE_STRAIGHT -> 0.9;
-		?CARD_TYPE_STRAIGHT_PAIR -> 0.85;
-		_ -> 0.5
-	end.
+    case Type of
+        ?CARD_TYPE_SINGLE when Value < ?CARD_VALUE_2 -> 0.8;
+        ?CARD_TYPE_PAIR when Value < ?CARD_VALUE_2 -> 0.7;
+        ?CARD_TYPE_STRAIGHT -> 0.9;
+        ?CARD_TYPE_STRAIGHT_PAIR -> 0.85;
+        _ -> 0.5
+    end.
 
 calculate_mid_tempo({Type, Value, _}, _Context) ->
-	case Type of
-		?CARD_TYPE_THREE_ONE -> 0.8;
-		?CARD_TYPE_THREE_TWO -> 0.85;
-		?CARD_TYPE_PLANE -> 0.9;
-		?CARD_TYPE_BOMB -> 0.7;
-		_ -> 0.6
-	end.
+    case Type of
+        ?CARD_TYPE_THREE_ONE -> 0.8;
+        ?CARD_TYPE_THREE_TWO -> 0.85;
+        ?CARD_TYPE_PLANE -> 0.9;
+        ?CARD_TYPE_BOMB -> 0.7;
+        _ -> 0.6
+    end.
 
 calculate_end_tempo({Type, Value, _}, Context) ->
-	CardsLeft = Context#play_context.cards_remaining,
-	case Type of
-		?CARD_TYPE_BOMB -> 0.9;
-		?CARD_TYPE_ROCKET -> 1.0;
-		_ when CardsLeft =< 4 -> 0.95;
-		_ -> 0.7
-	end.
+    CardsLeft = Context#play_context.cards_remaining,
+    case Type of
+        ?CARD_TYPE_BOMB -> 0.9;
+        ?CARD_TYPE_ROCKET -> 1.0;
+        _ when CardsLeft =< 4 -> 0.95;
+        _ -> 0.7
+    end.
 
 %% 过滤候选出牌
 filter_candidates(Plays, Context) ->
-	case Context#play_context.game_stage of
-		early_game ->
-			filter_early_game_plays(Plays, Context);
-		mid_game ->
-			filter_mid_game_plays(Plays, Context);
-		end_game ->
-			filter_end_game_plays(Plays, Context)
-	end.
+    case Context#play_context.game_stage of
+        early_game ->
+            filter_early_game_plays(Plays, Context);
+        mid_game ->
+            filter_mid_game_plays(Plays, Context);
+        end_game ->
+            filter_end_game_plays(Plays, Context)
+    end.
 
 filter_early_game_plays(Plays, _Context) ->
-	% 早期游戏倾向于出小牌，保留炸弹
-	[Play || {Type, Value, _} = Play <- Plays,
-		Type =/= ?CARD_TYPE_BOMB orelse Value >= ?CARD_2].
+    % 早期游戏倾向于出小牌，保留炸弹
+    [Play || {Type, Value, _} = Play <- Plays,
+        Type =/= ?CARD_TYPE_BOMB orelse Value >= ?CARD_VALUE_2].
 
 filter_mid_game_plays(Plays, Context) ->
-	% 中期游戏根据局势决定是否使用炸弹
-	case Context#play_context.control_factor < 0.5 of
-		true -> Plays;
-		false ->
-			[Play || {Type, _, _} = Play <- Plays,
-				Type =/= ?CARD_TYPE_BOMB]
-	end.
+    % 中期游戏根据局势决定是否使用炸弹
+    case Context#play_context.control_factor < 0.5 of
+        true -> Plays;
+        false ->
+            [Play || {Type, _, _} = Play <- Plays,
+                Type =/= ?CARD_TYPE_BOMB]
+    end.
 
 filter_end_game_plays(Plays, _Context) ->
-	% 末期游戏可以使用任何牌型
-	Plays.
+    % 末期游戏可以使用任何牌型
+    Plays.
 
 %% 对手牌进行分组
 group_cards_by_value(Cards) ->
-	lists:foldl(fun(Card, Acc) ->
-		{Value, _} = Card,
-		maps:update_with(Value,
-			fun(List) -> [Card|List] end,
-			[Card],
-			Acc)
-	end, maps:new(), Cards).
\ No newline at end of file
+    lists:foldl(fun(Card, Acc) ->
+        {Value, _} = Card,
+        maps:update_with(Value,
+            fun(List) -> [Card|List] end,
+            [Card],
+            Acc)
+    end, maps:new(), Cards).
\ No newline at end of file
diff --git a/斗地主.md b/斗地主.md
deleted file mode 100644
index 49e4ed1..0000000
--- a/斗地主.md
+++ /dev/null
@@ -1,190 +0,0 @@
-# 自动斗地主AI系统项目文档
-
-**文档生成日期:** 2025-02-21 03:49:02 UTC  
-**作者:** SisMaker  
-**项目版本:** 1.0.0
-
-## 项目概述
-
-本项目是一个基于Erlang开发的智能斗地主游戏系统，集成了深度学习、并行计算、性能监控和可视化分析等先进功能。系统采用模块化设计，具有高可扩展性和可维护性。
-
-## 系统架构
-
-### 核心模块
-
-1. **游戏核心模块**
-   - cards.erl: 牌类操作
-   - card_rules.erl: 游戏规则
-   - game_server.erl: 游戏服务器
-   - player.erl: 玩家管理
-
-2. **AI系统模块**
-   - deep_learning.erl: 深度学习引擎
-   - advanced_ai_player.erl: 高级AI玩家
-   - matrix.erl: 矩阵运算
-   - optimizer.erl: 优化器
-
-3. **系统支持模块**
-   - parallel_compute.erl: 并行计算
-   - performance_monitor.erl: 性能监控
-
-## 功能特性
-
-### 1. 基础游戏功能
-- 完整的斗地主规则实现
-- 多人游戏支持
-- 房间管理系统
-- 积分系统
-
-### 2. AI系统
-#### 2.1 深度学习功能
-- 多层神经网络
-- 多种优化器（Adam, SGD）
-- 实时学习能力
-- 策略适应
-
-#### 2.2 AI玩家特性
-- 多种性格特征（激进、保守、平衡、自适应）
-- 动态决策系统
-- 对手模式识别
-- 自适应学习
-
-### 3. 系统性能
-#### 3.1 并行计算
-- 工作进程池管理
-- 负载均衡
-- 异步处理
-- 结果聚合
-
-#### 3.2 性能监控
-- 实时性能指标收集
-- 自动化性能分析
-- 告警系统
-- 性能报告生成
-
-### 4. 可视化分析
-- 多种图表类型支持
-- 实时数据更新
-- 多格式导出
-- 自定义显示选项
-
-## 技术实现
-
-### 1. 深度学习实现
-```erlang
-% 示例：创建神经网络
-NetworkConfig = [64, 128, 64, 32],
-{ok, Network} = deep_learning:create_network(NetworkConfig).
-```
-
-### 2. 并行处理
-```erlang
-% 示例：并行预测
-Inputs = [Input1, Input2, Input3],
-{ok, Results} = parallel_compute:parallel_predict(Inputs, Network).
-```
-
-### 3. 性能监控
-```erlang
-% 示例：启动监控
-{ok, MonitorId} = performance_monitor:start_monitoring(Network).
-```
-
-## 系统要求
-
-- Erlang/OTP 21+
-- 支持并行计算的多核系统
-- 足够的内存支持深度学习运算
-- 图形库支持（用于可视化）
-
-## 性能指标
-
-- 支持同时运行多个游戏房间
-- AI决策响应时间 < 1秒
-- 支持实时性能监控和分析
-- 可扩展到分布式系统
-
-## 已实现功能列表
-
-### 游戏核心功能
-- [x] 完整的斗地主规则实现
-- [x] 多玩家支持
-- [x] 房间管理
-- [x] 积分系统
-
-### AI功能
-- [x] 深度学习引擎
-- [x] 多种AI性格
-- [x] 自适应学习
-- [x] 策略优化
-
-### 系统功能
-- [x] 并行计算
-- [x] 性能监控
-- [x] 可视化分析
-- [x] 实时数据处理
-
-## 待优化功能
-
-1. 分布式系统支持
-2. 数据持久化
-3. 更多AI算法
-4. Web界面
-5. 移动端支持
-6. 安全性增强
-7. 容错机制
-8. 日志系统
-
-## 使用说明
-
-### 1. 启动系统
-```erlang
-% 编译所有模块
-c(matrix).
-c(optimizer).
-c(deep_learning).
-c(parallel_compute).
-c(performance_monitor).
-c(ai_test).
-
-% 运行测试
-ai_test:run_test().
-```
-
-### 2. 创建游戏房间
-```erlang
-{ok, RoomId} = room_manager:create_room("新手房", PlayerPid).
-```
-
-### 3. 添加AI玩家
-```erlang
-{ok, AiPlayer} = advanced_ai_player:start_link("AI_Player", aggressive).
-```
-
-## 错误处理
-
-系统实现了基本的错误处理机制：
-- 游戏异常处理
-- AI系统容错
-- 并行计算错误恢复
-- 性能监控告警
-
-## 维护建议
-
-1. 定期检查性能监控报告
-2. 更新AI模型训练数据
-3. 优化并行计算配置
-4. 备份系统数据
-
-## 联系方式
-
-- 作者：SisMaker
-- 文档最后更新：2025-02-21 03:49:02 UTC
-
-## 版权信息
-
-版权所有 © 2025 SisMaker。保留所有权利。
-
----
-
-本文档详细描述了斗地主AI系统的架构、功能和实现细节，为系统的使用、维护和进一步开发提供了参考。如有任何问题或建议，请联系作者。
\ No newline at end of file