From 5aabaddc316b4928087830ef45f9f24d347ee200 Mon Sep 17 00:00:00 2001
From: Kunagisa <1549184870@qq.com>
Date: Fri, 1 Aug 2025 01:29:18 +0800
Subject: [PATCH] =?UTF-8?q?=E5=8D=95=E8=B4=A5=E9=87=8D=E6=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/components/RankContestant.vue           | 121 +--
 src/components/TournamentBracket.vue        | 997 ++++++++++++--------
 src/views/competition/CompetitionDetail.vue |  70 +-
 3 files changed, 731 insertions(+), 457 deletions(-)

diff --git a/src/components/RankContestant.vue b/src/components/RankContestant.vue
index 773e081..584de10 100644
--- a/src/components/RankContestant.vue
+++ b/src/components/RankContestant.vue
@@ -46,76 +46,77 @@ const rankData = ref([])
 const fetchRankData = async () => {
     try {
         const response = await getSignUpResultList()
+        console.log('RankContestant 原始数据:', response)
+        
         // 筛选当前赛事的玩家
         const filteredPlayers = response.filter(player => player.tournament_id === props.tournamentId)
+        console.log('RankContestant 筛选后数据:', filteredPlayers)
         
-        // 计算每个玩家的积分
-        const playersWithPoints = filteredPlayers.map(player => {
-            // 获取玩家积分，如果没有则计算
-            let points = parseFloat(player.points || 0)
+        // 按玩家名称分组，计算总胜利数和总失败数
+        const playerStats = {}
+        
+        filteredPlayers.forEach((player, index) => {
+            const playerName = player.sign_name
+            const win = parseInt(player.win || 0)
+            const lose = parseInt(player.lose || 0)
+            const round = player.round || '0'
             
-            // 如果没有积分字段，根据胜场和所在组别计算积分
-            if (!player.points) {
-                const wins = parseInt(player.win) || 0
-                // 败者组积分是胜者组的一半
-                const multiplier = player.bracket_type === 'losers' ? 0.5 : 1
-                points = wins * multiplier
-            }
-            
-            // 获取排名信息
-            const rank = player.rank || ''
-            
-            return {
+            console.log(`RankContestant 处理第${index + 1}条数据:`, {
                 id: player.id,
-                rank: rank,
-                username: player.sign_name,
-                faction: player.faction || player.team_name || '',
-                win: parseInt(player.win) || 0,
-                lose: parseInt(player.lose) || 0,
-                points: points,
-                status: player.status || '',
-                bracket_type: player.bracket_type || 'winners', // 默认为胜者组
-                score: `${player.win}胜${player.lose}负 (${points.toFixed(1)}分)`
+                sign_name: playerName,
+                round: round,
+                win: win,
+                lose: lose,
+                status: player.status
+            })
+            
+            if (!playerStats[playerName]) {
+                playerStats[playerName] = {
+                    username: playerName,
+                    faction: player.faction || player.team_name || '',
+                    totalWin: 0,
+                    totalLose: 0,
+                    totalPoints: 0,
+                    rounds: []
+                }
             }
+            
+            playerStats[playerName].totalWin += win
+            playerStats[playerName].totalLose += lose
+            playerStats[playerName].rounds.push(round)
+            
+            // 计算积分（胜场数）
+            playerStats[playerName].totalPoints = playerStats[playerName].totalWin
         })
         
-        // 排序逻辑
-        const sortedPlayers = [...playersWithPoints].sort((a, b) => {
-            // 首先检查是否有明确的排名
-            if (a.rank && b.rank) {
-                return parseInt(a.rank) - parseInt(b.rank)
-            }
-            
-            // 如果是决赛选手，按照状态排序（win在前，lose在后）
-            if (a.status === 'win' && b.status === 'lose') return -1
-            if (a.status === 'lose' && b.status === 'win') return 1
-            
-            // 按积分排序
-            if (b.points !== a.points) {
-                return b.points - a.points
-            }
-            
-            // 如果积分相同，胜者组选手排在败者组选手前面
-            if (a.bracket_type !== b.bracket_type) {
-                return a.bracket_type === 'winners' ? -1 : 1
-            }
-            
-            // 如果积分和组别都相同，按胜场数排序
-            if (b.win !== a.win) {
-                return b.win - a.win
-            }
-            
-            // 如果胜场数相同，则按负场数排序（负场数少的排前面）
-            return a.lose - b.lose
-        })
+        console.log('RankContestant 分组后统计:', playerStats)
         
-        // 重新分配排名
-        const results = sortedPlayers.map((player, index) => ({
-            ...player,
-            rank: player.rank || (index + 1).toString()
-        }))
+        // 转换为数组并按总胜利数排序
+        const sortedPlayers = Object.values(playerStats)
+            .sort((a, b) => {
+                // 首先按总胜利数排序
+                if (b.totalWin !== a.totalWin) {
+                    return b.totalWin - a.totalWin
+                }
+                // 如果胜利数相同，按失败数排序（失败数少的排名靠前）
+                return a.totalLose - b.totalLose
+            })
+            .map((player, index) => ({
+                id: index + 1, // 使用索引作为ID
+                rank: (index + 1).toString(),
+                username: player.username,
+                faction: player.faction,
+                win: player.totalWin,
+                lose: player.totalLose,
+                points: player.totalPoints,
+                status: '',
+                bracket_type: 'winners',
+                score: `${player.totalWin}胜${player.totalLose}负 (${player.totalPoints.toFixed(1)}分)`,
+                rounds: player.rounds.join(',')
+            }))
         
-        rankData.value = results
+        console.log('RankContestant 最终排名结果:', sortedPlayers)
+        rankData.value = sortedPlayers
     } catch (error) {
         console.error('获取排名数据失败:', error)
     }
diff --git a/src/components/TournamentBracket.vue b/src/components/TournamentBracket.vue
index 7475d77..ee34c40 100644
--- a/src/components/TournamentBracket.vue
+++ b/src/components/TournamentBracket.vue
@@ -1,41 +1,10 @@
 <template>
   <div class="tournament-bracket-root">
     <h1>单败淘汰赛赛程树状图</h1>
+    <div class="tournament-info">
+      <p><strong>总轮数:</strong> {{ totalRounds }} 轮 (基于 {{ participantCount }} 位参赛者，log₂({{ participantCount }}) = {{ Math.log2(participantCount) }})</p>
+    </div>
     <div class="container">
-      <div class="control-panel">
-        <div class="tournament-info">
-          <div>
-            <strong>当前比赛:</strong> {{ tournament.name || '加载中...' }}
-          </div>
-        </div>
-
-        <h2>参赛者列表</h2>
-        <div id="player-list">
-          <div v-if="loading" class="loading">加载中...</div>
-          <div v-else>
-            <p v-if="participants.length === 0">暂无参赛者</p>
-            <template v-else>
-              <p>共 {{ participants.length }} 位参赛者</p>
-              <ul>
-                <li v-for="participant in participants" :key="participant.id">
-                  {{ participant.name }}
-                </li>
-              </ul>
-            </template>
-          </div>
-        </div>
-
-        <h2>生成赛程</h2>
-        <button @click="generateBracket" :disabled="!canGenerateBracket">生成单败淘汰赛程</button>
-
-        <div v-if="finalRanking" id="finalRanking">
-          <h3>最终排名</h3>
-          <p>冠军: {{ finalRanking.champion }}</p>
-          <p>亚军: {{ finalRanking.runnerUp }}</p>
-          <p>季军: {{ finalRanking.thirdPlace }}</p>
-        </div>
-      </div>
-
       <div class="bracket-container" id="bracketContainer">
         <div class="zoom-controls">
           <button class="zoom-btn" @click="zoomIn" title="放大 (+)">+</button>
@@ -65,7 +34,7 @@
 
 <script setup>
 import { ref, computed, onMounted, watch, nextTick, onUnmounted } from 'vue';
-import { getSignUpResultList, updateSignUpResult, getTournamentList } from '@/api/tournament';
+import { getSignUpResultList, updateSignUpResult, getTournamentList, addSignUpResult } from '@/api/tournament';
 import * as d3 from 'd3';
 import SuccessDialog from '@/components/SuccessDialog.vue';
 import ErrorDialog from '@/components/ErrorDialog.vue';
@@ -77,10 +46,6 @@ const props = defineProps({
   }
 });
 
-const participants = ref([]);
-const loading = ref(false);
-const finalRanking = ref(null);
-
 // Dialog state
 const successDialog = ref({ visible: false, message: '' });
 const errorDialog = ref({ visible: false, message: '' });
@@ -94,19 +59,17 @@ const tournament = ref({
   name: '',
   participants: [],
   rounds: 0,
-  matches: []
+  matches: [],
+  apiData: []
 });
 
-const canGenerateBracket = computed(() => {
-  return participants.value.length >= 2;
+// 计算总轮数和参赛人数
+const totalRounds = computed(() => {
+  return tournament.value.rounds;
 });
 
-const roundsMatches = computed(() => {
-  const arr = [];
-  for (let r = 1; r <= tournament.value.rounds; r++) {
-    arr.push(tournament.value.matches.filter(m => m.round === r));
-  }
-  return arr;
+const participantCount = computed(() => {
+  return tournament.value.participants.length;
 });
 
 onMounted(() => {
@@ -114,7 +77,7 @@ onMounted(() => {
   
   // Add keyboard shortcuts for zoom control
   const handleKeydown = (event) => {
-    if (event.target.tagName === 'INPUT') return; // Don't trigger when typing in inputs
+    if (event.target.tagName === 'INPUT') return;
     
     switch(event.key) {
       case '+':
@@ -146,123 +109,523 @@ onMounted(() => {
 const loadTournamentData = async () => {
   if (!props.tournamentId) return;
   
-  loading.value = true;
   tournament.value.id = props.tournamentId;
   
   try {
-    // Get tournament list to find the tournament name
+    // 获取锦标赛信息
     const tournaments = await getTournamentList();
     const selectedTournament = tournaments.find(t => t.id === props.tournamentId);
     if (selectedTournament) {
       tournament.value.name = selectedTournament.name;
     }
     
-    // Get participants for this tournament
+    // 获取参赛者数据（第0轮）
     const data = await getSignUpResultList();
-    const filtered = data.filter(item => item.tournament_id == props.tournamentId);
-    participants.value = filtered.map(item => ({ id: item.id, name: item.sign_name }));
-    tournament.value.participants = participants.value;
+    const filtered = data.filter(item => 
+      item.tournament_id == props.tournamentId && 
+      parseInt(item.round || 0) === 0
+    );
+    const participants = filtered.map(item => ({ id: item.id, name: item.sign_name }));
+    tournament.value.participants = participants;
+    
+    // 保存API数据
+    tournament.value.apiData = data.filter(item => item.tournament_id == tournament.value.id);
+    
+    // 计算总轮数
+    tournament.value.rounds = Math.ceil(Math.log2(participants.length));
+    
+    // 生成单败淘汰赛树状图
+    if (participants.length >= 2) {
+      await generateSingleEliminationBracket();
+      nextTick(() => drawD3Bracket());
+    }
   } catch (err) {
-    console.error('获取比赛数据失败:', err);
-  } finally {
-    loading.value = false;
+    errorDialog.value = { visible: true, message: '获取比赛数据失败: ' + err.message };
   }
 };
 
-const generateBracket = () => {
-  if (!canGenerateBracket.value) return;
-  finalRanking.value = null;
-  generateSingleEliminationBracket();
-  nextTick(() => drawD3Bracket());
-};
-
 const generateSingleEliminationBracket = async () => {
   tournament.value.matches = [];
-  tournament.value.rounds = Math.ceil(Math.log2(tournament.value.participants.length));
-  const totalPlayers = Math.pow(2, tournament.value.rounds);
-  const shuffled = [...tournament.value.participants].sort(() => Math.random() - 0.5);
-
-  const latestData = await getSignUpResultList();
-  const filteredData = latestData.filter(item => item.tournament_id == tournament.value.id);
-
-  while (shuffled.length < totalPlayers) {
-    shuffled.push(null);
-  }
-
-  // 生成第一轮比赛
-  const firstRoundMatchesCount = totalPlayers / 2;
-  for (let i = 0; i < firstRoundMatchesCount; i++) {
-    const p1 = shuffled[i * 2];
-    const p2 = shuffled[i * 2 + 1];
-    let winner = null;
-    let decided = false;
-
-    if (p1 && !p2) { // p1 gets a bye
-      winner = p1;
-      decided = true;
-    } else if (!p1 && p2) { // p2 gets a bye
-      winner = p2;
-      decided = true;
-    } else if (!p1 && !p2) { // double bye
-      winner = null; // Winner is null for a double bye
-      decided = true;
+  
+  // 获取所有API数据
+  const allData = await getSignUpResultList();
+  const tournamentData = allData.filter(item => item.tournament_id == tournament.value.id);
+  tournament.value.apiData = tournamentData;
+  
+  // 按轮数分组数据
+  const roundsData = {};
+  tournamentData.forEach(item => {
+    const round = parseInt(item.round || 0);
+    if (!roundsData[round]) {
+      roundsData[round] = [];
+    }
+    roundsData[round].push(item);
+  });
+  
+  // 获取所有存在的轮次
+  const existingRounds = Object.keys(roundsData).map(Number).sort((a, b) => a - b);
+  console.log('存在的轮次:', existingRounds);
+  
+  // 生成所有轮次的比赛
+  for (const round of existingRounds) {
+    if (round === 0) {
+      await generateRound0Matches(roundsData[round] || []);
+    } else {
+      await generateRoundMatches(round, roundsData[round] || []);
     }
-    // If p1 && p2, winner is null, decided is false (normal match)
-
-    const p1Latest = p1 ? filteredData.find(item => item.id === p1.id) : null;
-    const p2Latest = p2 ? filteredData.find(item => item.id === p2.id) : null;
-
-    tournament.value.matches.push({
-      id: `${1}-${i + 1}`,
-      round: 1,
-      matchNumber: i + 1,
-      participant1: p1,
-      participant2: p2,
-      winner,
-      score1: decided && winner === p1 ? 1 : (p1Latest?.win || 0), // Score 1 for bye winner, else existing or 0
-      score2: decided && winner === p2 ? 1 : (p2Latest?.win || 0), // Score 1 for bye winner, else existing or 0
-      decided,
-      // participantXResolved flags are not needed for round 1 matches as they are resolved by definition or play
-    });
   }
+  
+  // 更新总轮数为实际存在的最大轮次
+  if (existingRounds.length > 0) {
+    tournament.value.rounds = Math.max(...existingRounds);
+  }
+};
 
-  // 生成后续轮次
-  for (let r = 2; r <= tournament.value.rounds; r++) {
-    const matchCount = totalPlayers / Math.pow(2, r);
-    for (let i = 0; i < matchCount; i++) {
-      tournament.value.matches.push({
-        id: `${r}-${i + 1}`,
-        round: r,
-        matchNumber: i + 1,
-        participant1: null, // Placeholder, will be filled by previous round's winner
-        participant2: null, // Placeholder
-        participant1Resolved: false, // New flag
-        participant2Resolved: false, // New flag
+const generateRound0Matches = async (round0Data) => {
+  const matches = [];
+  const usedPlayers = new Set();
+  
+  // 处理正常配对
+  for (const player of round0Data) {
+    if (usedPlayers.has(player.id)) continue;
+    
+    const rivalName = player.rival_name;
+    const isBye = rivalName === '轮空' || rivalName === 'bye' || rivalName === 'BYE' || rivalName === 'Bye';
+    const isPending = rivalName === '待定' || rivalName === 'pending' || rivalName === 'PENDING' || rivalName === 'Pending';
+    
+    if (isBye || isPending) continue;
+    
+    // 寻找对手
+    const rival = round0Data.find(p => 
+      p.sign_name === rivalName && p.id !== player.id && !usedPlayers.has(p.id)
+    );
+    
+    if (rival) {
+      const matchNumber = matches.length + 1;
+      matches.push({
+        id: `0-${matchNumber}`,
+        round: 0,
+        matchNumber: matchNumber,
+        participant1: { id: player.id, name: player.sign_name },
+        participant2: { id: rival.id, name: rival.sign_name },
         winner: null,
-        score1: null,
-        score2: null,
+        score1: parseInt(player.win || 0),
+        score2: parseInt(rival.win || 0),
         decided: false
       });
+      usedPlayers.add(player.id);
+      usedPlayers.add(rival.id);
     }
   }
+  
+  // 处理轮空
+  for (const player of round0Data) {
+    if (usedPlayers.has(player.id)) continue;
+    
+    const rivalName = player.rival_name;
+    const isBye = rivalName === '轮空' || rivalName === 'bye' || rivalName === 'BYE' || rivalName === 'Bye';
+    
+    if (isBye) {
+      const matchNumber = matches.length + 1;
+      matches.push({
+        id: `0-${matchNumber}`,
+        round: 0,
+        matchNumber: matchNumber,
+        participant1: { id: player.id, name: player.sign_name },
+        participant2: null,
+        winner: { id: player.id, name: player.sign_name },
+        score1: 1,
+        score2: 0,
+        decided: true
+      });
+      usedPlayers.add(player.id);
+    }
+  }
+  
+  tournament.value.matches.push(...matches);
+};
 
-  // 处理第一轮中的轮空晋级
-  const firstRoundActualMatches = tournament.value.matches.filter(m => m.round === 1);
-  for (const match of firstRoundActualMatches) {
-    if (match.decided) { // If the match was decided (bye, double bye)
-      updateNextRound(match); // Propagate its result (winner could be player or null)
+const generateRoundMatches = async (round, roundData) => {
+  const matches = [];
+  const usedPlayers = new Set();
+  
+  console.log(`生成第${round}轮比赛，数据:`, roundData);
+  
+  // 处理已有数据的比赛
+  for (const player of roundData) {
+    if (usedPlayers.has(player.id)) continue;
+    
+    const rivalName = player.rival_name;
+    const isBye = rivalName === '轮空' || rivalName === 'bye' || rivalName === 'BYE' || rivalName === 'Bye';
+    const isPending = rivalName === '待定' || rivalName === 'pending' || rivalName === 'PENDING' || rivalName === 'Pending';
+    
+    if (isBye || isPending) continue;
+    
+    // 寻找对手
+    const rival = roundData.find(p => 
+      p.sign_name === rivalName && p.id !== player.id && !usedPlayers.has(p.id)
+    );
+    
+    if (rival) {
+      const matchNumber = matches.length + 1;
+      matches.push({
+        id: `${round}-${matchNumber}`,
+        round: round,
+        matchNumber: matchNumber,
+        participant1: { id: player.id, name: player.sign_name },
+        participant2: { id: rival.id, name: rival.sign_name },
+        winner: null,
+        score1: parseInt(player.win || 0),
+        score2: parseInt(rival.win || 0),
+        decided: false
+      });
+      usedPlayers.add(player.id);
+      usedPlayers.add(rival.id);
     }
   }
+  
+  // 处理轮空
+  for (const player of roundData) {
+    if (usedPlayers.has(player.id)) continue;
+    
+    const rivalName = player.rival_name;
+    const isBye = rivalName === '轮空' || rivalName === 'bye' || rivalName === 'BYE' || rivalName === 'Bye';
+    
+    if (isBye) {
+      const matchNumber = matches.length + 1;
+      matches.push({
+        id: `${round}-${matchNumber}`,
+        round: round,
+        matchNumber: matchNumber,
+        participant1: { id: player.id, name: player.sign_name },
+        participant2: null,
+        winner: { id: player.id, name: player.sign_name },
+        score1: 1,
+        score2: 0,
+        decided: true
+      });
+      usedPlayers.add(player.id);
+    }
+  }
+  
+  // 处理待定的玩家（单独显示）
+  for (const player of roundData) {
+    if (usedPlayers.has(player.id)) continue;
+    
+    const rivalName = player.rival_name;
+    const isPending = rivalName === '待定' || rivalName === 'pending' || rivalName === 'PENDING' || rivalName === 'Pending';
+    
+    if (isPending) {
+      const matchNumber = matches.length + 1;
+      matches.push({
+        id: `${round}-${matchNumber}`,
+        round: round,
+        matchNumber: matchNumber,
+        participant1: { id: player.id, name: player.sign_name },
+        participant2: null,
+        winner: null,
+        score1: parseInt(player.win || 0),
+        score2: 0,
+        decided: false
+      });
+      usedPlayers.add(player.id);
+    }
+  }
+  
+  console.log(`第${round}轮生成比赛:`, matches);
+  tournament.value.matches.push(...matches);
+};
+
+
+
+// 检查比赛顺序是否合法
+const isMatchOrderValid = (match) => {
+  const currentRoundMatches = tournament.value.matches
+    .filter(m => m.round === match.round)
+    .sort((a, b) => a.matchNumber - b.matchNumber);
+  
+  const currentMatchIndex = currentRoundMatches.findIndex(m => m.id === match.id);
+  
+  // 检查是否有更小编号的比赛未完成
+  for (let i = 0; i < currentMatchIndex; i++) {
+    const previousMatch = currentRoundMatches[i];
+    if (!previousMatch.decided) {
+      return false;
+    }
+  }
+  
+  return true;
+};
+
+const handlePlayerAdvancement = async (match) => {
+  if (!match.winner) return;
+  
+  const nextRound = match.round + 1;
+  
+  // 检查是否到达最后一轮
+  if (nextRound > tournament.value.rounds) {
+    console.log('已到达最后一轮，停止处理');
+    return;
+  }
+  
+  const nextMatchNumber = Math.floor((match.matchNumber - 1) / 2) + 1;
+  
+  // 检查API中是否已经有下一轮的数据
+  const nextRoundApiData = tournament.value.apiData.filter(item => 
+    item.tournament_id == tournament.value.id && 
+    parseInt(item.round || 0) === nextRound
+  );
+  
+  // 如果API中没有下一轮数据，不处理晋级
+  if (nextRoundApiData.length === 0) {
+    console.log(`API中没有第${nextRound}轮数据，不处理晋级`);
+    return;
+  }
+  
+  // 查找下一轮比赛
+  let nextMatch = tournament.value.matches.find(m => 
+    m.round === nextRound && m.matchNumber === nextMatchNumber
+  );
+  
+  if (!nextMatch) {
+    console.log(`未找到第${nextRound}轮第${nextMatchNumber}场比赛，不处理晋级`);
+    return;
+  }
+  
+  // 确定晋级位置
+  const isFeederForParticipant1 = (match.matchNumber - 1) % 2 === 0;
+  
+  if (isFeederForParticipant1) {
+    nextMatch.participant1 = match.winner;
+  } else {
+    nextMatch.participant2 = match.winner;
+  }
+  
+  // 检查是否形成轮空
+  if (nextMatch.participant1 && nextMatch.participant2) {
+    // 正常比赛，等待结果
+    console.log('下一轮为正常比赛，等待结果');
+  } else if (nextMatch.participant1 && !nextMatch.participant2) {
+    // 轮空，自动晋级
+    nextMatch.winner = nextMatch.participant1;
+    nextMatch.score1 = 1;
+    nextMatch.score2 = 0;
+    nextMatch.decided = true;
+    console.log(`第${nextRound}轮第${nextMatchNumber}场比赛轮空，${nextMatch.participant1.name}自动晋级`);
+    
+    // 递归处理连续轮空（但只在API有数据时）
+    await handlePlayerAdvancement(nextMatch);
+  } else if (!nextMatch.participant1 && nextMatch.participant2) {
+    // 轮空，自动晋级
+    nextMatch.winner = nextMatch.participant2;
+    nextMatch.score1 = 0;
+    nextMatch.score2 = 1;
+    nextMatch.decided = true;
+    console.log(`第${nextRound}轮第${nextMatchNumber}场比赛轮空，${nextMatch.participant2.name}自动晋级`);
+    
+    // 递归处理连续轮空（但只在API有数据时）
+    await handlePlayerAdvancement(nextMatch);
+  }
+  
+  // 更新获胜者的API记录，而不是创建新记录
+  try {
+    const winnerData = tournament.value.apiData.find(item => item.id === match.winner.id);
+    if (winnerData) {
+      // 检查是否已经存在该玩家在下一轮的记录
+      const existingNextRoundRecord = tournament.value.apiData.find(item => 
+        item.tournament_id == tournament.value.id && 
+        item.sign_name === winnerData.sign_name && 
+        parseInt(item.round || 0) === nextRound
+      );
+      
+      if (existingNextRoundRecord) {
+        // 如果已存在下一轮记录，更新状态
+        const updateData = {
+          ...existingNextRoundRecord,
+          win: '0',
+          lose: '0',
+          status: 'tie',
+          rival_name: '待定'
+        };
+        
+        await updateSignUpResult(existingNextRoundRecord.id, updateData);
+        console.log(`更新现有记录: ${winnerData.sign_name} 晋级到第${nextRound}轮`);
+      } else {
+        // 如果不存在下一轮记录，创建新记录
+        const advancementData = {
+          tournament_id: parseInt(winnerData.tournament_id),
+          tournament_name: winnerData.tournament_name,
+          team_name: winnerData.team_name || null,
+          sign_name: winnerData.sign_name,
+          win: '0',
+          lose: '0',
+          status: 'tie',
+          round: String(nextRound),
+          rival_name: '待定'
+        };
+        
+        await addSignUpResult(advancementData);
+        console.log(`创建新记录: ${winnerData.sign_name} 晋级到第${nextRound}轮`);
+      }
+    }
+  } catch (error) {
+    console.error('处理晋级记录失败:', error);
+  }
+};
+
+const confirmScore = async (match) => {
+  // 检查比赛顺序
+  if (!isMatchOrderValid(match)) {
+    const currentRoundMatches = tournament.value.matches
+      .filter(m => m.round === match.round)
+      .sort((a, b) => a.matchNumber - b.matchNumber);
+    
+    const currentMatchIndex = currentRoundMatches.findIndex(m => m.id === match.id);
+    const previousMatch = currentRoundMatches[currentMatchIndex - 1];
+    
+    errorDialog.value = { 
+      visible: true, 
+      message: `请先完成第${previousMatch.matchNumber}场比赛` 
+    };
+    return;
+  }
+  
+  // 处理轮空比赛
+  if (!match.participant2) {
+    if (!match.decided) {
+      match.winner = match.participant1;
+      match.decided = true;
+      match.score1 = 1;
+      match.score2 = 0;
+    }
+    
+    // 更新轮空玩家的状态并创建新记录
+    try {
+      const p1Data = tournament.value.apiData.find(item => item.id === match.participant1.id);
+      
+      if (p1Data) {
+        // 更新轮空玩家的状态
+        const winnerUpdate = {
+          ...p1Data,
+          win: '1',
+          lose: '0',
+          status: 'win'
+        };
+        
+        await updateSignUpResult(p1Data.id, winnerUpdate);
+        
+        // 为轮空玩家创建新的API记录（轮数+1）
+        const nextRound = parseInt(p1Data.round || 0) + 1;
+        const newRecord = {
+          tournament_id: parseInt(p1Data.tournament_id),
+          tournament_name: p1Data.tournament_name,
+          team_name: p1Data.team_name || null,
+          sign_name: p1Data.sign_name,
+          win: '0',
+          lose: '0',
+          status: 'tie',
+          round: String(nextRound),
+          rival_name: '待定'
+        };
+        
+        await addSignUpResult(newRecord);
+        console.log(`轮空玩家 ${p1Data.sign_name} 晋级到第${nextRound}轮`);
+      }
+    } catch (error) {
+      console.error('处理轮空晋级失败:', error);
+    }
+    
+    nextTick(() => drawD3Bracket());
+    await loadTournamentData();
+    emit('refreshPlayers');
+    return;
+  }
+  
+  // 验证比分
+  const s1 = Number(match.score1);
+  const s2 = Number(match.score2);
+  
+  if (isNaN(s1) || isNaN(s2)) {
+    errorDialog.value = { visible: true, message: '请输入有效的比分' };
+    return;
+  }
+  
+  if (s1 === s2) {
+    errorDialog.value = { visible: true, message: '比分不能平局' };
+    return;
+  }
+  
+  // 设置比赛结果
+  match.score1 = s1;
+  match.score2 = s2;
+  match.winner = s1 > s2 ? match.participant1 : match.participant2;
+  match.decided = true;
+  
+  // 更新API数据
+  try {
+    const p1Data = tournament.value.apiData.find(item => item.id === match.participant1.id);
+    const p2Data = tournament.value.apiData.find(item => item.id === match.participant2.id);
+    
+    if (p1Data && p2Data) {
+      // 更新失败者的状态
+      const loser = s1 > s2 ? p2Data : p1Data;
+      const loserUpdate = {
+        ...loser,
+        win: String(s1 > s2 ? s2 : s1),
+        lose: String(s1 > s2 ? s1 : s2),
+        status: 'lose'
+      };
+      
+      await updateSignUpResult(loser.id, loserUpdate);
+      
+      // 更新获胜者的状态
+      const winner = s1 > s2 ? p1Data : p2Data;
+      const winnerUpdate = {
+        ...winner,
+        win: String(s1 > s2 ? s1 : s2),
+        lose: String(s1 > s2 ? s2 : s1),
+        status: 'win'
+      };
+      
+      await updateSignUpResult(winner.id, winnerUpdate);
+      
+      // 为获胜者创建新的API记录（轮数+1）
+      const nextRound = parseInt(winner.round || 0) + 1;
+      const newRecord = {
+        tournament_id: parseInt(winner.tournament_id),
+        tournament_name: winner.tournament_name,
+        team_name: winner.team_name || null,
+        sign_name: winner.sign_name,
+        win: '0',
+        lose: '0',
+        status: 'tie',
+        round: String(nextRound),
+        rival_name: '待定'
+      };
+      
+      await addSignUpResult(newRecord);
+      console.log(`为获胜者 ${winner.sign_name} 创建新记录，轮数: ${nextRound}`);
+    }
+  } catch (error) {
+    console.error('更新比赛结果失败:', error);
+  }
+  
+  // 重新绘制和刷新
+  nextTick(() => drawD3Bracket());
+  await loadTournamentData();
+  emit('refreshPlayers');
 };
 
 const drawD3Bracket = () => {
   const svg = d3.select('#d3-bracket');
-  svg.selectAll('*').remove(); // Clear previous content
+  svg.selectAll('*').remove();
 
-  if (!tournament.value.matches.length) return;
+  if (!tournament.value.matches.length) {
+    return;
+  }
 
   const margin = { top: 40, right: 40, bottom: 40, left: 40 };
-  const matchWidth = 180;
+  const matchWidth = 220;
   const matchHeight = 120;
   const roundGap = 50;
   const matchGap = 20;
@@ -270,12 +633,11 @@ const drawD3Bracket = () => {
   const rounds = tournament.value.rounds;
   const maxMatchesInRound = Math.pow(2, rounds - 1);
 
-  const totalWidth = rounds * (matchWidth + roundGap) + margin.left + margin.right;
+  const totalWidth = (rounds + 1) * (matchWidth + roundGap) + margin.left + margin.right;
   const totalHeight = maxMatchesInRound * (matchHeight + matchGap) + margin.top + margin.bottom;
 
-  // Get container dimensions for proper sizing
   const container = document.getElementById('bracketContainer');
-  const containerWidth = container.clientWidth - 30; // Account for padding
+  const containerWidth = container.clientWidth - 30;
   const containerHeight = container.clientHeight - 30;
 
   svg
@@ -284,55 +646,46 @@ const drawD3Bracket = () => {
     .attr('viewBox', `0 0 ${totalWidth} ${totalHeight}`)
     .attr('preserveAspectRatio', 'xMidYMid meet');
 
-  // Create zoom behavior
+  // 创建缩放行为
   const zoom = d3.zoom()
-    .scaleExtent([0.1, 3]) // Allow zoom from 10% to 300%
+    .scaleExtent([0.1, 3])
     .on('zoom', (event) => {
       g.attr('transform', `translate(${margin.left},${margin.top}) ${event.transform}`);
     });
 
-  // Store references for external control
   zoomBehavior = zoom;
   svgSelection = svg;
 
-  // Apply zoom to SVG
   svg.call(zoom);
 
-  // Add cursor styles for pan/zoom
   svg.style('cursor', 'grab')
     .on('mousedown', () => svg.style('cursor', 'grabbing'))
     .on('mouseup', () => svg.style('cursor', 'grab'));
 
-  // Create main group for content
   const g = svg.append('g')
     .attr('transform', `translate(${margin.left},${margin.top})`);
 
-  // Draw matches for each round
-  for (let round = 1; round <= rounds; round++) {
-    const roundMatches = tournament.value.matches.filter(m => m.round === round);
+  // 绘制每轮比赛
+  for (let round = 0; round <= rounds; round++) {
+    const roundMatches = tournament.value.matches
+      .filter(m => m.round === round)
+      .sort((a, b) => a.matchNumber - b.matchNumber);
+    
+    console.log(`绘制第${round}轮比赛:`, roundMatches);
+    
     const matchesInRound = roundMatches.length;
-    const roundX = (round - 1) * (matchWidth + roundGap);
+    const roundX = round * (matchWidth + roundGap);
     const roundStartY = (maxMatchesInRound * (matchHeight + matchGap) - matchesInRound * (matchHeight + matchGap)) / 2;
 
-    // Round title
-    g.append('text')
-      .attr('x', roundX + matchWidth / 2)
-      .attr('y', -10)
-      .attr('text-anchor', 'middle')
-      .attr('class', 'round-title')
-      .style('font-weight', 'bold')
-      .style('font-size', '14px')
-      .text(`第 ${round} 轮`);
-
     roundMatches.forEach((match, idx) => {
       const matchY = roundStartY + idx * (matchHeight + matchGap);
       
-      // Match container
+      // 比赛容器
       const matchGroup = g.append('g')
         .attr('class', 'match-group')
         .attr('data-match-id', match.id);
 
-      // Match background
+      // 比赛背景
       matchGroup.append('rect')
         .attr('x', roundX)
         .attr('y', matchY)
@@ -344,7 +697,11 @@ const drawD3Bracket = () => {
         .style('stroke-width', 1)
         .style('rx', 6);
 
-      // Participant 1
+      // 获取玩家数据
+      const p1Data = tournament.value.apiData?.find(p => p.id === match.participant1?.id);
+      const p2Data = tournament.value.apiData?.find(p => p.id === match.participant2?.id);
+
+      // 玩家1
       const p1Group = matchGroup.append('g')
         .attr('class', 'participant-group')
         .attr('transform', `translate(${roundX + 10}, ${matchY + 20})`);
@@ -364,10 +721,28 @@ const drawD3Bracket = () => {
         .style('fill', match.winner && match.participant1 && match.winner.id === match.participant1.id ? '#2a7f2a' : '#333')
         .text(match.participant1 ? match.participant1.name : '轮空');
 
-      // Score input for participant 1
+      if (p1Data) {
+        p1Group.append('text')
+          .attr('x', matchWidth - 145)
+          .attr('y', 20)
+          .style('font-size', '10px')
+          .style('fill', '#666')
+          .text(`胜:${p1Data.win || '0'} 败:${p1Data.lose || '0'}`);
+      }
+
+      if (match.participant1 && match.participant2 && !match.decided) {
+        p1Group.append('text')
+          .attr('x', matchWidth - 100)
+          .attr('y', 20)
+          .style('font-size', '10px')
+          .style('fill', '#666')
+          .text('胜场数:');
+      }
+
+      // 玩家1比分输入
       if (match.participant1 && match.participant2 && !match.decided) {
         const scoreInput1 = p1Group.append('foreignObject')
-          .attr('x', matchWidth - 60)
+          .attr('x', matchWidth - 65)
           .attr('y', 5)
           .attr('width', 40)
           .attr('height', 20);
@@ -375,27 +750,28 @@ const drawD3Bracket = () => {
         scoreInput1.append('xhtml:input')
           .attr('type', 'number')
           .attr('min', '0')
+          .attr('placeholder', '胜场')
           .style('width', '35px')
           .style('height', '18px')
           .style('font-size', '11px')
           .style('text-align', 'center')
           .style('border', '1px solid #aaa')
           .style('border-radius', '3px')
-          .property('value', match.score1 || '')
+          .property('value', p1Data ? (p1Data.win || '0') : '')
           .on('input', function() {
             match.score1 = +this.value;
           });
       } else if (match.decided) {
         p1Group.append('text')
-          .attr('x', matchWidth - 35)
+          .attr('x', matchWidth - 50)
           .attr('y', 20)
           .style('font-size', '12px')
           .style('font-weight', 'bold')
           .style('text-anchor', 'middle')
-          .text(match.score1 || 0);
+          .text(p1Data ? (p1Data.win || '0') : '0');
       }
 
-      // Participant 2
+      // 玩家2
       const p2Group = matchGroup.append('g')
         .attr('class', 'participant-group')
         .attr('transform', `translate(${roundX + 10}, ${matchY + 55})`);
@@ -415,39 +791,58 @@ const drawD3Bracket = () => {
         .style('fill', match.winner && match.participant2 && match.winner.id === match.participant2.id ? '#2a7f2a' : '#333')
         .text(match.participant2 ? match.participant2.name : '轮空');
 
-      // Score input for participant 2
+      if (p2Data) {
+        p2Group.append('text')
+          .attr('x', matchWidth - 145)
+          .attr('y', 20)
+          .style('font-size', '10px')
+          .style('fill', '#666')
+          .text(`胜:${p2Data.win || '0'} 败:${p2Data.lose || '0'}`);
+      }
+
+      if (match.participant1 && match.participant2 && !match.decided) {
+        p2Group.append('text')
+          .attr('x', matchWidth - 100)
+          .attr('y', 20)
+          .style('font-size', '10px')
+          .style('fill', '#666')
+          .text('胜场数:');
+      }
+
+      // 玩家2比分输入
       if (match.participant1 && match.participant2 && !match.decided) {
         const scoreInput2 = p2Group.append('foreignObject')
-          .attr('x', matchWidth - 60)
+          .attr('x', matchWidth - 65)
           .attr('y', 5)
-          .attr('width', 40)
-          .attr('height', 20);
+          .attr('width', '40')
+          .attr('height', '20');
 
         scoreInput2.append('xhtml:input')
           .attr('type', 'number')
           .attr('min', '0')
+          .attr('placeholder', '胜场')
           .style('width', '35px')
           .style('height', '18px')
           .style('font-size', '11px')
           .style('text-align', 'center')
           .style('border', '1px solid #aaa')
           .style('border-radius', '3px')
-          .property('value', match.score2 || '')
+          .property('value', p2Data ? (p2Data.win || '0') : '')
           .on('input', function() {
             match.score2 = +this.value;
           });
       } else if (match.decided) {
         p2Group.append('text')
-          .attr('x', matchWidth - 35)
+          .attr('x', matchWidth - 50)
           .attr('y', 20)
           .style('font-size', '12px')
           .style('font-weight', 'bold')
           .style('text-anchor', 'middle')
-          .text(match.score2 || 0);
+          .text(p2Data ? (p2Data.win || '0') : '0');
       }
 
-      // Confirm score button
-      if (match.participant1 && match.participant2 && !match.decided) {
+      // 确认比分按钮
+      if (match.participant1 && !match.decided && match.participant2) {
         const buttonGroup = matchGroup.append('g')
           .attr('transform', `translate(${roundX + 10}, ${matchY + 90})`);
 
@@ -458,7 +853,11 @@ const drawD3Bracket = () => {
           .style('stroke', 'none')
           .style('rx', 4)
           .style('cursor', 'pointer')
-          .on('click', () => confirmScore(match));
+          .on('click', () => {
+            if (!match.decided) {
+              confirmScore(match);
+            }
+          });
 
         buttonGroup.append('text')
           .attr('x', (matchWidth - 20) / 2)
@@ -471,28 +870,38 @@ const drawD3Bracket = () => {
           .text('确认比分');
       }
 
-      // Store match position for connection drawing
+      // 存储比赛位置用于连线
       match._x = roundX + matchWidth;
       match._y = matchY + matchHeight / 2;
     });
   }
 
-  // Draw connections between matches
-  drawD3Connections(g, matchWidth, matchHeight, roundGap, matchGap);
+  // 绘制连线
+  drawConnections(g, matchWidth, matchHeight, roundGap, matchGap);
 };
 
-const drawD3Connections = (g, matchWidth, matchHeight, roundGap, matchGap) => {
+const drawConnections = (g, matchWidth, matchHeight, roundGap, matchGap) => {
   const rounds = tournament.value.rounds;
   
-  for (let round = 1; round < rounds; round++) {
-    const currentRoundMatches = tournament.value.matches.filter(m => m.round === round && m.decided);
+  for (let round = 0; round < rounds; round++) {
+    const currentRoundMatches = tournament.value.matches
+      .filter(m => m.round === round)
+      .sort((a, b) => a.matchNumber - b.matchNumber);
     
-    currentRoundMatches.forEach(match => {
-      const nextRound = round + 1;
+    const nextRoundMatches = tournament.value.matches
+      .filter(m => m.round === round + 1)
+      .sort((a, b) => a.matchNumber - b.matchNumber);
+    
+    console.log(`绘制连线: 第${round}轮 -> 第${round + 1}轮`, {
+      currentRound: currentRoundMatches.length,
+      nextRound: nextRoundMatches.length
+    });
+    
+    currentRoundMatches.forEach((match) => {
       const nextMatchNumber = Math.floor((match.matchNumber - 1) / 2) + 1;
-      const nextMatch = tournament.value.matches.find(m => m.round === nextRound && m.matchNumber === nextMatchNumber);
+      const nextMatch = nextRoundMatches.find(m => m.matchNumber === nextMatchNumber);
       
-      if (nextMatch && match.winner) {
+      if (nextMatch) {
         const startX = match._x;
         const startY = match._y;
         const endX = nextMatch._x - matchWidth;
@@ -500,7 +909,6 @@ const drawD3Connections = (g, matchWidth, matchHeight, roundGap, matchGap) => {
         
         const midX = startX + roundGap / 2;
         
-        // Draw connection line
         g.append('path')
           .attr('d', `M${startX},${startY} L${midX},${startY} L${midX},${endY} L${endX},${endY}`)
           .style('stroke', '#4CAF50')
@@ -514,169 +922,7 @@ const drawD3Connections = (g, matchWidth, matchHeight, roundGap, matchGap) => {
 
 const emit = defineEmits(['refreshPlayers']);
 
-async function confirmScore(match) {
-  const s1 = Number(match.score1);
-  const s2 = Number(match.score2);
-  if (isNaN(s1) || isNaN(s2)) {
-    errorDialog.value = { visible: true, message: '请输入有效的比分' };
-    return;
-  }
-  if (s1 === s2) {
-    errorDialog.value = { visible: true, message: '比分不能平局' };
-    return;
-  }
-  match.score1 = s1;
-  match.score2 = s2;
-  match.winner = s1 > s2 ? match.participant1 : match.participant2;
-  match.decided = true;
-  updateNextRound(match);
-  // 重新绘制D3树状图
-  nextTick(() => drawD3Bracket());
-  if (match.round === tournament.value.rounds) {
-    calculateFinalRanking();
-  }
-
-  // 新增：同步胜负到API
-  const p1 = match.participant1;
-  const p2 = match.participant2;
-  try {
-    if (p1 && p2) {
-      // 先获取最新的报名数据
-      const latestData = await getSignUpResultList();
-      const p1Latest = latestData.find(item => item.id === p1.id);
-      const p2Latest = latestData.find(item => item.id === p2.id);
-
-      // 补全字段，使用最新的API数据
-      const p1Data = {
-        tournament_id: tournament.value.id,
-        tournament_name: tournament.value.name,
-        team_name: p1.team_name || '',
-        sign_name: p1.name || p1.sign_name || '',
-        win: String(Number(p1Latest?.win || 0) + s1),
-        lose: String(Number(p1Latest?.lose || 0) + s2),
-        status: s1 > s2 ? 'win' : 'lose',
-        qq_code: p1.qq_code || p1.qq || ''
-      };
-      const p2Data = {
-        tournament_id: tournament.value.id,
-        tournament_name: tournament.value.name,
-        team_name: p2.team_name || '',
-        sign_name: p2.name || p2.sign_name || '',
-        win: String(Number(p2Latest?.win || 0) + s2),
-        lose: String(Number(p2Latest?.lose || 0) + s1),
-        status: s2 > s1 ? 'win' : 'lose',
-        qq_code: p2.qq_code || p2.qq || ''
-      };
-      await updateSignUpResult(p1.id, p1Data);
-      await updateSignUpResult(p2.id, p2Data);
-      // 刷新比赛数据
-      await loadTournamentData();
-      // 强制同步 participants 和 tournament.value.participants
-      participants.value = [...participants.value];
-      tournament.value.participants = [...participants.value];
-    }
-  } catch (err) {
-    errorDialog.value = { visible: true, message: '更新数据失败' };
-    console.error(err);
-  }
-
-  emit('refreshPlayers');
-}
-
-const updateNextRound = (currentDecidedMatch) => {
-  if (!currentDecidedMatch.decided) { // Winner can be null (e.g. double bye)
-    console.warn("updateNextRound called on non-decided match", currentDecidedMatch);
-    return;
-  }
-
-  if (currentDecidedMatch.round === tournament.value.rounds) {
-    return; // This was the final match or a match in the final round
-  }
-
-  const nextRound = currentDecidedMatch.round + 1;
-  const nextMatchIndexInRound = Math.floor((currentDecidedMatch.matchNumber - 1) / 2);
-  const nextMatch = tournament.value.matches.find(m => m.round === nextRound && m.matchNumber === nextMatchIndexInRound + 1);
-
-  if (!nextMatch) {
-    console.error("Could not find next match for", currentDecidedMatch);
-    return;
-  }
-
-  const isFeederForParticipant1 = (currentDecidedMatch.matchNumber - 1) % 2 === 0;
-
-  if (isFeederForParticipant1) {
-    nextMatch.participant1 = currentDecidedMatch.winner; // Winner might be null
-    nextMatch.participant1Resolved = true;
-  } else {
-    nextMatch.participant2 = currentDecidedMatch.winner; // Winner might be null
-    nextMatch.participant2Resolved = true;
-  }
-
-  // Only proceed if both participant slots for nextMatch are resolved
-  if (nextMatch.participant1Resolved && nextMatch.participant2Resolved) {
-    const p1 = nextMatch.participant1;
-    const p2 = nextMatch.participant2;
-
-    if (p1 && !p2) { // p1 advances due to p2 being a bye (null)
-      nextMatch.winner = p1;
-      nextMatch.score1 = 1; // Convention for bye win
-      nextMatch.score2 = 0;
-      nextMatch.decided = true;
-    } else if (!p1 && p2) { // p2 advances due to p1 being a bye (null)
-      nextMatch.winner = p2;
-      nextMatch.score1 = 0;
-      nextMatch.score2 = 1; // Convention for bye win
-      nextMatch.decided = true;
-    } else if (!p1 && !p2) { // Double bye in this nextMatch
-      nextMatch.winner = null; // No winner advances
-      nextMatch.score1 = 0;
-      nextMatch.score2 = 0;
-      nextMatch.decided = true; // This "match" is decided as a double bye
-    } else if (p1 && p2) { // Both participants are actual players, match is ready to be played
-      nextMatch.winner = null;
-      nextMatch.score1 = null; // Or 0, depending on display preference for undecided matches
-      nextMatch.score2 = null; // Or 0
-      nextMatch.decided = false;
-    } else {
-      // This case should ideally not be reached if logic is correct
-      console.warn("Unexpected state in updateNextRound for nextMatch:", nextMatch);
-      nextMatch.decided = false; // Default to not decided to prevent erroneous propagation
-    }
-
-    // If nextMatch itself was decided (due to byes), propagate its result further
-    if (nextMatch.decided) {
-      updateNextRound(nextMatch);
-    }
-  }
-  // If only one participant is resolved, wait for the other feeder match to complete.
-};
-
-const calculateFinalRanking = () => {
-  const finalMatch = tournament.value.matches.find(m => m.round === tournament.value.rounds);
-  if (!finalMatch || !finalMatch.winner) return;
-
-  const champion = finalMatch.winner;
-  const runnerUp = finalMatch.participant1 && finalMatch.participant2
-    ? (finalMatch.winner.id === finalMatch.participant1.id ? finalMatch.participant2 : finalMatch.participant1)
-    : null;
-
-  let semiFinalMatches = tournament.value.matches.filter(m => m.round === tournament.value.rounds - 1);
-  let semiFinalLosers = [];
-  semiFinalMatches.forEach(m => {
-    if (m.decided && m.winner) {
-      const loser = (m.participant1 && m.participant1.id !== m.winner.id) ? m.participant1 : m.participant2;
-      if (loser) semiFinalLosers.push(loser);
-    }
-  });
-
-  finalRanking.value = {
-    champion: champion.name,
-    runnerUp: runnerUp ? runnerUp.name : '未知',
-    thirdPlace: semiFinalLosers.length > 0 ? semiFinalLosers[0].name : '未知'
-  };
-};
-
-// Zoom control functions
+// 缩放控制函数
 const zoomIn = () => {
   if (svgSelection && zoomBehavior) {
     svgSelection.transition().duration(300).call(
@@ -702,12 +948,7 @@ const resetZoom = () => {
   }
 };
 
-// 监听赛程变化自动重绘D3树状图
-watch(roundsMatches, () => {
-  nextTick(() => drawD3Bracket());
-});
-
-// 监听tournamentId变化自动加载新的比赛数据
+// 监听tournamentId变化
 watch(() => props.tournamentId, (newId) => {
   if (newId) {
     loadTournamentData();
@@ -775,25 +1016,29 @@ watch(() => props.tournamentId, (newId) => {
   text-align: center;
 }
 
+.tournament-bracket-root .tournament-info {
+  text-align: center;
+  margin: 10px 0 20px 0;
+  padding: 10px;
+  background: #f8f9fa;
+  border-radius: 6px;
+  border-left: 4px solid #007acc;
+}
+
+.tournament-bracket-root .tournament-info p {
+  margin: 0;
+  font-size: 14px;
+  color: #333;
+}
+
 .tournament-bracket-root .container {
   display: flex;
-  gap: 20px;
   align-items: flex-start;
   min-height: 500px;
 }
 
-.tournament-bracket-root .control-panel {
-  flex: 1;
-  min-width: 280px;
-  background: #f0f0f0;
-  padding: 15px;
-  border-radius: 6px;
-  height: 100%;
-  box-sizing: border-box;
-}
-
 .tournament-bracket-root .bracket-container {
-  flex: 3;
+  flex: 1;
   position: relative;
   overflow: auto;
   background: #fff;
@@ -874,24 +1119,4 @@ watch(() => props.tournamentId, (newId) => {
 .tournament-bracket-root .d3-bracket:active {
   cursor: grabbing;
 }
-
-.tournament-bracket-root #finalRanking {
-  margin-top: 15px;
-  background: #fffbdb;
-  border: 1px solid #f0e68c;
-  padding: 12px;
-  border-radius: 6px;
-}
-
-.tournament-bracket-root .tournament-info {
-  margin-bottom: 15px;
-  padding: 10px;
-  background: #e6f7ff;
-  border-radius: 4px;
-}
-
-.tournament-bracket-root .loading {
-  color: #666;
-  font-style: italic;
-}
 </style>
\ No newline at end of file
diff --git a/src/views/competition/CompetitionDetail.vue b/src/views/competition/CompetitionDetail.vue
index 53ced59..2b741bf 100644
--- a/src/views/competition/CompetitionDetail.vue
+++ b/src/views/competition/CompetitionDetail.vue
@@ -86,7 +86,6 @@
         <tournament-bracket
           v-else-if="competition.status === 'starting'"
           :tournament-id="parseInt(route.query.id)"
-          @refreshPlayers="fetchRegisteredPlayers"
         />
       </template>
 
@@ -919,22 +918,71 @@ const fetchFinalResults = async () => {
   try {
     const tournamentId = parseInt(route.query.id)
     const response = await getSignUpResultList()
-    // 筛选当前赛事的玩家并按胜场数排序
-    const results = response
-      .filter(player => player.tournament_id === tournamentId)
+    
+    console.log('原始API数据:', response)
+    
+    // 筛选当前赛事的所有轮次数据
+    const tournamentData = response.filter(player => player.tournament_id === tournamentId)
+    
+    console.log('筛选后的赛事数据:', tournamentData)
+    console.log('数据条数:', tournamentData.length)
+    
+    // 按玩家名称分组，计算总胜利数和总失败数
+    const playerStats = {}
+    
+    tournamentData.forEach((player, index) => {
+      const playerName = player.sign_name
+      const win = parseInt(player.win || 0)
+      const lose = parseInt(player.lose || 0)
+      const round = player.round || '0'
+      
+      console.log(`处理第${index + 1}条数据:`, {
+        id: player.id,
+        sign_name: playerName,
+        round: round,
+        win: win,
+        lose: lose,
+        status: player.status
+      })
+      
+      if (!playerStats[playerName]) {
+        playerStats[playerName] = {
+          username: playerName,
+          qq: player.qq || '',
+          faction: player.faction || 'random',
+          totalWin: 0,
+          totalLose: 0,
+          rounds: []
+        }
+      }
+      
+      playerStats[playerName].totalWin += win
+      playerStats[playerName].totalLose += lose
+      playerStats[playerName].rounds.push(round)
+    })
+    
+    console.log('分组后的玩家统计:', playerStats)
+    
+    // 转换为数组并按总胜利数排序
+    const results = Object.values(playerStats)
+      .sort((a, b) => {
+        // 首先按总胜利数排序
+        if (b.totalWin !== a.totalWin) {
+          return b.totalWin - a.totalWin
+        }
+        // 如果胜利数相同，按失败数排序（失败数少的排名靠前）
+        return a.totalLose - b.totalLose
+      })
       .map((player, index) => ({
         rank: index + 1,
-        username: player.sign_name,
+        username: player.username,
         qq: player.qq,
         faction: player.faction,
-        score: `${player.win}胜${player.lose}负`
+        score: `${player.totalWin}胜${player.totalLose}负`,
+        rounds: player.rounds.join(',')
       }))
-      .sort((a, b) => {
-        const aScore = parseInt(a.score.split('胜')[0])
-        const bScore = parseInt(b.score.split('胜')[0])
-        return bScore - aScore
-      })
     
+    console.log('最终排名结果:', results)
     finalResults.value = results
   } catch (error) {
     console.error('获取最终结果失败:', error)