单败重构

src/components/TournamentBracket.vue

@@ -165,6 +165,11 @@ const generateSingleEliminationBracket = async () => {
   // 获取所有存在的轮次
   const existingRounds = Object.keys(roundsData).map(Number).sort((a, b) => a - b);
   console.log('存在的轮次:', existingRounds);
+  console.log('API数据按轮次分组:');
+  existingRounds.forEach(round => {
+    const roundData = tournament.value.apiData.filter(item => parseInt(item.round) === round);
+    console.log(`第${round}轮数据:`, roundData);
+  });
 
   // 生成所有轮次的比赛
   for (const round of existingRounds) {
@@ -259,6 +264,31 @@ const generateRoundMatches = async (round, roundData) => {
     lose: p.lose
   })));
   
+  // 检查第1轮是否有待匹配的玩家
+  if (round === 1) {
+    const pendingPlayers = roundData.filter(player => player.rival_name === '待定');
+    const matchedPlayers = roundData.filter(player => player.rival_name !== '待定');
+    console.log(`第1轮待匹配玩家:`, pendingPlayers.map(p => p.sign_name));
+    console.log(`第1轮已匹配玩家:`, matchedPlayers.map(p => `${p.sign_name} vs ${p.rival_name}`));
+    
+    // 检查重复记录
+    const playerCounts = {};
+    roundData.forEach(player => {
+      playerCounts[player.sign_name] = (playerCounts[player.sign_name] || 0) + 1;
+    });
+    console.log(`第1轮玩家重复情况:`, playerCounts);
+    
+    // 显示所有第1轮记录的详细信息
+    console.log(`第1轮所有记录详情:`, roundData.map(p => ({
+      id: p.id,
+      sign_name: p.sign_name,
+      rival_name: p.rival_name,
+      status: p.status,
+      win: p.win,
+      lose: p.lose
+    })));
+  }
+  
   // 处理已有数据的比赛
   for (const player of roundData) {
     if (usedPlayers.has(player.id)) {
@@ -559,6 +589,87 @@ const handlePlayerAdvancement = async (match) => {
   }
 };
 
+// 匹配指定轮次的对手
+const matchOpponentsInRound = async (round) => {
+  try {
+    // 获取指定轮次的所有待定玩家
+    const roundData = tournament.value.apiData.filter(item => 
+      parseInt(item.round) === round && item.rival_name === '待定'
+    );
+    
+    console.log(`尝试匹配第${round}轮对手，待定玩家:`, roundData.map(p => p.sign_name));
+    
+    // 如果待定玩家数量为偶数，可以两两匹配
+    if (roundData.length >= 2 && roundData.length % 2 === 0) {
+      // 从第二轮开始（round >= 1），按照从上到下的顺序分配对手
+      if (round >= 1) {
+        // 按ID排序，确保从上到下的顺序
+        const sortedPlayers = roundData.sort((a, b) => a.id - b.id);
+        
+        console.log(`第${round}轮按ID排序的玩家:`, sortedPlayers.map(p => p.sign_name));
+        
+        // 按照从上到下的顺序两两匹配
+        for (let i = 0; i < sortedPlayers.length; i += 2) {
+          const player1 = sortedPlayers[i];
+          const player2 = sortedPlayers[i + 1];
+          
+          if (player1 && player2) {
+            // 更新player1的对手
+            const update1 = {
+              ...player1,
+              rival_name: player2.sign_name
+            };
+            await updateSignUpResult(player1.id, update1);
+            
+            // 更新player2的对手
+            const update2 = {
+              ...player2,
+              rival_name: player1.sign_name
+            };
+            await updateSignUpResult(player2.id, update2);
+            
+            console.log(`第${round}轮匹配对手: ${player1.sign_name} vs ${player2.sign_name}`);
+          }
+        }
+        
+        // 对手匹配完成后，重新获取API数据并更新树状图
+        console.log(`第${round}轮对手匹配完成，开始更新树状图...`);
+        await refreshTournamentData();
+        generateBracket();
+        drawBracket();
+      } else {
+        // 第0轮按ID排序
+        const sortedPlayers = roundData.sort((a, b) => a.id - b.id);
+        
+        for (let i = 0; i < sortedPlayers.length; i += 2) {
+          const player1 = sortedPlayers[i];
+          const player2 = sortedPlayers[i + 1];
+          
+          // 更新player1的对手
+          const update1 = {
+            ...player1,
+            rival_name: player2.sign_name
+          };
+          await updateSignUpResult(player1.id, update1);
+          
+          // 更新player2的对手
+          const update2 = {
+            ...player2,
+            rival_name: player1.sign_name
+          };
+          await updateSignUpResult(player2.id, update2);
+          
+          console.log(`匹配对手: ${player1.sign_name} vs ${player2.sign_name}`);
+        }
+      }
+    } else {
+      console.log(`第${round}轮待定玩家数量为${roundData.length}，无法匹配`);
+    }
+  } catch (error) {
+    console.error(`匹配第${round}轮对手失败:`, error);
+  }
+};
+
 const confirmScore = async (match) => {
   console.log('确认比分，比赛信息:', {
     id: match.id,
@@ -568,7 +679,8 @@ const confirmScore = async (match) => {
     participant2: match.participant2?.name
   });
   
-  // 检查比赛顺序
+  // 检查比赛顺序（已注释掉）
+  /*
   if (!isMatchOrderValid(match)) {
     const currentRoundMatches = tournament.value.matches
       .filter(m => m.round === match.round)
@@ -589,6 +701,7 @@ const confirmScore = async (match) => {
     };
     return;
   }
+  */
   
   // 处理轮空比赛
   if (!match.participant2) {
@@ -628,8 +741,21 @@ const confirmScore = async (match) => {
           rival_name: '待定'
         };
         
+        // 检查是否已存在该玩家的晋级记录
+        const existingRecord = tournament.value.apiData.find(item => 
+          item.sign_name === p1Data.sign_name && 
+          parseInt(item.round) === nextRound
+        );
+        
+        if (existingRecord) {
+          console.log(`轮空玩家 ${p1Data.sign_name} 在第${nextRound}轮已存在记录，跳过创建`);
+        } else {
           await addSignUpResult(newRecord);
           console.log(`轮空玩家 ${p1Data.sign_name} 晋级到第${nextRound}轮`);
+          
+          // 尝试匹配对手
+          await matchOpponentsInRound(nextRound);
+        }
       }
       } catch (error) {
       console.error('处理轮空晋级失败:', error);
@@ -661,6 +787,12 @@ const confirmScore = async (match) => {
   match.winner = s1 > s2 ? match.participant1 : match.participant2;
   match.decided = true;
   
+  console.log('比赛结果设置完成:', {
+    winner: match.winner?.name,
+    score: `${s1}:${s2}`,
+    decided: match.decided
+  });
+  
   // 更新API数据
   try {
     const p1Data = tournament.value.apiData.find(item => item.id === match.participant1.id);
@@ -703,16 +835,32 @@ const confirmScore = async (match) => {
         rival_name: '待定'
       };
       
+      // 检查是否已存在该玩家的晋级记录
+      const existingRecord = tournament.value.apiData.find(item => 
+        item.sign_name === winner.sign_name && 
+        parseInt(item.round) === nextRound
+      );
+      
+      if (existingRecord) {
+        console.log(`玩家 ${winner.sign_name} 在第${nextRound}轮已存在记录，跳过创建`);
+      } else {
         await addSignUpResult(newRecord);
         console.log(`为获胜者 ${winner.sign_name} 创建新记录，轮数: ${nextRound}`);
+        console.log('晋级记录详情:', newRecord);
+        
+        // 尝试匹配对手
+        await matchOpponentsInRound(nextRound);
+      }
     }
   } catch (error) {
     console.error('更新比赛结果失败:', error);
   }
   
   // 重新绘制和刷新
+  console.log('开始重新绘制和刷新数据...');
   nextTick(() => drawD3Bracket());
   await loadTournamentData();
+  console.log('数据刷新完成');
   emit('refreshPlayers');
 };