Spaces:

trd69
/

cps

Running

App Files Files Community

trd69 commited on Jun 13, 2025

Commit

2db64c5

verified ·

1 Parent(s): 38103a1

Update index.html

Browse files

Files changed (1) hide show

index.html +428 -331

index.html CHANGED Viewed

@@ -1,3 +1,4 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -97,7 +98,6 @@
             margin-left: 10px;
             align-self: center;
         }
         .row-container {
             display: flex;
             align-items: center;
@@ -517,40 +517,12 @@
                 // All cards placed - show final scores
                 if (opponentCards === 13 && playerCards === 13) {
-                    const resultsContainer = document.getElementById('score-summary');
-                    const playerTopCombo = document.getElementById('player-top-combination').textContent;
-                    const playerMiddleCombo = document.getElementById('player-middle-combination').textContent;
-                    const playerBottomCombo = document.getElementById('player-bottom-combination').textContent;
-                    const opponentTopCombo = document.getElementById('opponent-top-combination').textContent;
-                    const opponentMiddleCombo = document.getElementById('opponent-middle-combination').textContent;
-                    const opponentBottomCombo = document.getElementById('opponent-bottom-combination').textContent;
-                    // Display results
-                    document.getElementById('final-player-top').textContent = `${playerTopCombo} (${document.getElementById('player-top-points').textContent} pts)`;
-                    document.getElementById('final-player-middle').textContent = `${playerMiddleCombo} (${document.getElementById('player-middle-points').textContent} pts)`;
-                    document.getElementById('final-player-bottom').textContent = `${playerBottomCombo} (${document.getElementById('player-bottom-points').textContent} pts)`;
-                    document.getElementById('final-opponent-top').textContent = `${opponentTopCombo} (${document.getElementById('opponent-top-points').textContent} pts)`;
-                    document.getElementById('final-opponent-middle').textContent = `${opponentMiddleCombo} (${document.getElementById('opponent-middle-points').textContent} pts)`;
-                    document.getElementById('final-opponent-bottom').textContent = `${opponentBottomCombo} (${document.getElementById('opponent-bottom-points').textContent} pts)`;
-                    // Calculate final score (simplified for demo)
-                    const playerScore =
-                        parseInt(document.getElementById('player-top-points').textContent) +
-                        parseInt(document.getElementById('player-middle-points').textContent) +
-                        parseInt(document.getElementById('player-bottom-points').textContent);
-                    const opponentScore =
-                        parseInt(document.getElementById('opponent-top-points').textContent) +
-                        parseInt(document.getElementById('opponent-middle-points').textContent) +
-                        parseInt(document.getElementById('opponent-bottom-points').textContent);
-                    document.getElementById('final-player-score').textContent = playerScore;
-                    document.getElementById('final-opponent-score').textContent = opponentScore;
-                    resultsContainer.classList.remove('hidden');
-                    calculateBtn.disabled = true;
-                    gameState.lastMoveValid = true;
                 }
                 else if (isValidState) {
                     calculateBtn.disabled = false;
@@ -580,168 +552,410 @@
             // Update combination label for a specific row
             function updateRowCombination(prefix, size) {
-                const cardIds = [];
-                for (let i = 0; i < size; i++) {
-                    const cardId = gameState.slots[`${prefix}-${i}`];
-                    if (cardId !== null) {
-                        cardIds.push(gameState.cards.find(c => c.id == cardId));
-                    }
-                }
-                if (cardIds.length < size) {
-                    document.getElementById(`${prefix}-combination`).textContent = '-';
-                    document.getElementById(`${prefix}-points`).textContent = '0';
-                    return;
-                }
-                const combination = evaluateCombination(cardIds, prefix.split('-')[0]);
-                document.getElementById(`${prefix}-combination`).textContent = combination.name;
-                document.getElementById(`${prefix}-points`).textContent = combination.points;
-            }
             // Evaluate combination for a set of cards
-            function evaluateCombination(cards, rowType) {
-                // Sort cards by rank (high to low)
-                cards.sort((a, b) => b.rank - a.rank);
-                // For Chinese Poker different rows have different combinations:
-                if (rowType === 'top') {
-                    // Top row: only simple 3-card combinations (no flushes/straights)
-                    return evaluateTopRow(cards);
-                } else if (rowType === 'middle' || rowType === 'bottom') {
-                    // Middle/Bottom rows: standard 5-card poker hands
-                    return evaluateFiveCardHand(cards);
-                } else {
-                    // For other rows (like opponent's) default to simple evaluation
-                    if (cards.length === 3) {
-                        return evaluateTopRow(cards);
-                    } else if (cards.length === 5) {
-                        return evaluateFiveCardHand(cards);
-                    }
-                    return { name: 'Unknown', points: 0 };
-                }
-            }
-            // Evaluate top row (3 cards)
-            function evaluateTopRow(cards) {
-                cards.sort((a, b) => b.rank - a.rank); // Sort descending
-                const ranks = cards.map(c => c.rank);
-                // Three of a kind (set)
-                if (ranks[0] === ranks[1] && ranks[1] === ranks[2]) {
-                    return {
-                        name: `Three ${cards[0].value}'s`,
-                        points: cards[0].rank // Points equal to card rank (2=2, A=14)
-                    };
-                }
-                // Pair
-                if (ranks[0] === ranks[1] || ranks[1] === ranks[2]) {
-                    const pairRank = ranks[0] === ranks[1] ? ranks[0] : ranks[1];
-                    return {
-                        name: `Pair of ${cards[0].value}'s`,
-                        points: Math.floor(pairRank / 2) // Simple point scale (2=1, A=7)
                     };
                 }
-                // High card (single card)
-                return {
-                    name: `High ${cards[0].value}`,
-                    points: 0
-                };
-            }
-            // Evaluate 5-card hand (middle or bottom row)
-            function evaluateFiveCardHand(cards) {
-                // For now we'll implement basic poker hands
-                // Check flush
-                const isFlush = cards.every(c => c.suit === cards[0].suit);
-                // Check straight
-                let isStraight = true;
-                for (let i = 1; i < cards.length; i++) {
-                    if (cards[i].rank !== cards[i-1].rank - 1) {
-                        isStraight = false;
-                        break;
-                    }
-                }
-                // Check wheel (A-2-3-4-5)
-                const wheelRanks = [12, 0, 1, 2, 3];
-                const currentRanks = cards.map(c => c.rank).sort((a,b) => a-b);
-                let isWheel = true;
-                for (let i = 0; i < wheelRanks.length; i++) {
-                    if (currentRanks[i] !== wheelRanks[i]) {
-                        isWheel = false;
-                        break;
-                    }
-                }
-                isStraight = isStraight || isWheel;
-                // Check royal flush (10-J-Q-K-A of same suit)
-                const isRoyal = isFlush &&
-                               (cards[0].rank === 14) &&  // Ace
-                               (cards[1].rank === 13) &&  // King
-                               (cards[2].rank === 12) &&  // Queen
-                               (cards[3].rank === 11) &&  // Jack
-                               (cards[4].rank === 10);    // 10
-                // Check straight flush and royal flush
-                if (isStraight && isFlush) {
-                    if (isRoyal) {
-                        return { name: 'Royal Flush', points: 15 };
-                    }
-                    return { name: 'Straight Flush', points: 10 };
-                }
-                // Check four of a kind
-                const rankCounts = {};
-                cards.forEach(c => {
-                    rankCounts[c.rank] = (rankCounts[c.rank] || 0) + 1;
-                });
-                const counts = Object.values(rankCounts);
-                if (counts.includes(4)) {
-                    return { name: 'Four of a Kind', points: 8 };
-                }
-                // Check full house
-                if (counts.includes(3) && counts.includes(2)) {
-                    return { name: 'Full House', points: 6 };
-                }
-                // Check flush
-                if (isFlush) {
-                    return { name: 'Flush', points: 4 };
-                }
-                // Check straight
-                if (isStraight || isWheel) {
-                    return { name: 'Straight', points: 2 };
-                }
-                // Check three of a kind
-                if (counts.includes(3)) {
-                    return { name: 'Three of a Kind', points: 0 };
-                }
-                // Check two pairs
-                const pairCount = counts.filter(c => c === 2).length;
-                if (pairCount === 2) {
-                    return { name: 'Two Pairs', points: 0 };
-                }
-                // Check pair
-                if (pairCount === 1) {
-                    return { name: 'Pair', points: 0 };
-                }
-                // High card
-                return { name: 'High Card', points: 0 };
             }
             // Calculate best moves (simplified for demo)
             function calculateBestMoves() {
@@ -754,12 +968,7 @@
                     v => v !== null && gameState.cardPositions[v]?.startsWith('opponent-')
                 ).length;
-                if (playerCards === 13 && opponentCards === 13) {
-                    // Show final scores
-                    showFinalScores();
-                    return;
-                }
                 const resultsContainer = document.getElementById('results');
                 const resultsContent = document.getElementById('results-content');
@@ -825,140 +1034,30 @@
             // Show final scores when all cards are placed
             function showFinalScores() {
-                // Display results
-                const playerTopCombo = document.getElementById('player-top-combination').textContent;
-                const playerMiddleCombo = document.getElementById('player-middle-combination').textContent;
-                const playerBottomCombo = document.getElementById('player-bottom-combination').textContent;
-                const opponentTopCombo = document.getElementById('opponent-top-combination').textContent;
-                const opponentMiddleCombo = document.getElementById('opponent-middle-combination').textContent;
-                const opponentBottomCombo = document.getElementById('opponent-bottom-combination').textContent;
-                // Get points for each row
-                const playerTopPoints = parseInt(document.getElementById('player-top-points').textContent);
-                const playerMiddlePoints = parseInt(document.getElementById('player-middle-points').textContent);
-                const playerBottomPoints = parseInt(document.getElementById('player-bottom-points').textContent);
-                const opponentTopPoints = parseInt(document.getElementById('opponent-top-points').textContent);
-                const opponentMiddlePoints = parseInt(document.getElementById('opponent-middle-points').textContent);
-                const opponentBottomPoints = parseInt(document.getElementById('opponent-bottom-points').textContent);
-                // Check for seniority violation (broken hand)
-                let playerBrokenHand = false;
-                let opponentBrokenHand = false;
-                if (playerMiddlePoints > playerBottomPoints || playerTopPoints > playerMiddlePoints) {
-                    playerBrokenHand = true;
-                    alert("You have a broken hand! (Bottom must be strongest, middle stronger than top)");
-                }
-                if (opponentMiddlePoints > opponentBottomPoints || opponentTopPoints > opponentMiddlePoints) {
-                    opponentBrokenHand = true;
-                    alert("Opponent has a broken hand! (Bottom must be strongest, middle stronger than top)");
-                }
-                // Reset scores
-                let playerScore = 0;
-                let opponentScore = 0;
-                // Apply breaking hand rule - if hand is broken, ALL points are zero including royalties
-                if (playerBrokenHand || opponentBrokenHand) {
-                    playerScore = 0;
-                    opponentScore = 0;
-                } else {
-                    let playerRowWins = 0;
-                    let opponentRowWins = 0;
-                    // Compare top rows (3 cards)
-                    if (playerTopPoints > opponentTopPoints) {
-                        playerScore += 1;
-                        playerRowWins += 1;
-                    } else if (playerTopPoints < opponentTopPoints) {
-                        opponentScore += 1;
-                        opponentRowWins += 1;
-                    }
-                    // Compare middle rows (5 cards)
-                    if (playerMiddlePoints > opponentMiddlePoints) {
-                        playerScore += 1;
-                        playerRowWins += 1;
-                    } else if (playerMiddlePoints < opponentMiddlePoints) {
-                        opponentScore += 1;
-                        opponentRowWins += 1;
-                    }
-                    // Compare bottom rows (5 cards)
-                    if (playerBottomPoints > opponentBottomPoints) {
-                        playerScore += 1;
-                        playerRowWins += 1;
-                    } else if (playerBottomPoints < opponentBottomPoints) {
-                        opponentScore += 1;
-                        opponentRowWins += 1;
-                    }
-                    // Scoop bonus: +3 for winning all 3 rows
-                    if (playerRowWins === 3) {
-                        playerScore += 3;
-                    } else if (opponentRowWins === 3) {
-                        opponentScore += 3;
-                    }
-                    // Add royalties as additional points (if no broken hand)
-                    const playerRoyalty = calculateRoyaltyPoints(playerTopCombo, 'top') +
-                                        calculateRoyaltyPoints(playerMiddleCombo, 'middle') +
-                                        calculateRoyaltyPoints(playerBottomCombo, 'bottom');
-                    playerScore += playerRoyalty;
-                    const opponentRoyalty = calculateRoyaltyPoints(opponentTopCombo, 'top') +
-                                          calculateRoyaltyPoints(opponentMiddleCombo, 'middle') +
-                                          calculateRoyaltyPoints(opponentBottomCombo, 'bottom');
-                    opponentScore += opponentRoyalty;
-                }
-                function calculateRoyaltyPoints(combo, rowType) {
-                    let points = 0;
-                    const comboStr = combo.toLowerCase();
-                    // Top row royalties
-                    if (rowType === 'top') {
-                        if (comboStr.includes('three')) points += 3;
-                        else if (comboStr.includes('pair')) points += 1;
-                    }
-                    // Middle row royalties
-                    else if (rowType === 'middle') {
-                        if (comboStr.includes('royal flush')) points += 15;
-                        else if (comboStr.includes('straight flush')) points += 10;
-                        else if (comboStr.includes('four of')) points += 8;
-                        else if (comboStr.includes('full house')) points += 4;
-                    }
-                    // Bottom row royalties
-                    else if (rowType === 'bottom') {
-                        if (comboStr.includes('royal flush')) points += 25;
-                        else if (comboStr.includes('straight flush')) points += 15;
-                        else if (comboStr.includes('four of')) points += 10;
-                        else if (comboStr.includes('full house')) points += 6;
-                        else if (comboStr.includes('flush')) points += 4;
-                        else if (comboStr.includes('straight')) points += 2;
-                    }
-                    return points;
-                }
-                // Display final scores
-                document.getElementById('final-player-top').textContent = `${playerTopCombo} (${playerTopPoints} pts)`;
-                document.getElementById('final-player-middle').textContent = `${playerMiddleCombo} (${playerMiddlePoints} pts)`;
-                document.getElementById('final-player-bottom').textContent = `${playerBottomCombo} (${playerBottomPoints} pts)`;
-                document.getElementById('final-opponent-top').textContent = `${opponentTopCombo} (${opponentTopPoints} pts)`;
-                document.getElementById('final-opponent-middle').textContent = `${opponentMiddleCombo} (${opponentMiddlePoints} pts)`;
-                document.getElementById('final-opponent-bottom').textContent = `${opponentBottomCombo} (${opponentBottomPoints} pts)`;
-                document.getElementById('final-player-score').textContent = playerScore;
-                document.getElementById('final-opponent-score').textContent = opponentScore;
-                document.getElementById('score-summary').classList.remove('hidden');
-                document.getElementById('results').classList.add('hidden');
-            }
             // Reset all cards
             function resetAllCards() {
@@ -1022,5 +1121,3 @@
             initGame();
         });
     </script>
-<p style="border-radius: 8px; text-align: center; font-size: 12px; color: #fff; margin-top: 16px;position: fixed; left: 8px; bottom: 8px; z-index: 10; background: rgba(0, 0, 0, 0.8); padding: 4px 8px;">Made with <img src="https://enzostvs-deepsite.hf.space/logo.svg" alt="DeepSite Logo" style="width: 16px; height: 16px; vertical-align: middle;display:inline-block;margin-right:3px;filter:brightness(0) invert(1);"><a href="https://enzostvs-deepsite.hf.space" style="color: #fff;text-decoration: underline;" target="_blank" >DeepSite</a> - 🧬 <a href="https://enzostvs-deepsite.hf.space?remix=trd69/cps" style="color: #fff;text-decoration: underline;" target="_blank" >Remix</a></p></body>
-</html>

 <!DOCTYPE html>
 <html lang="en">
 <head>
             margin-left: 10px;
             align-self: center;
         }
         .row-container {
             display: flex;
             align-items: center;
                 // All cards placed - show final scores
                 if (opponentCards === 13 && playerCards === 13) {
+        // Вызываем функцию расчета итоговых очков
+            showFinalScores();
+                  // Отображаем таблицу с очками
+        document.getElementById('score-summary').classList.remove('hidden');
+        calculateBtn.disabled = true;
+        gameState.lastMoveValid = true;
                 }
                 else if (isValidState) {
                     calculateBtn.disabled = false;
             // Update combination label for a specific row
             function updateRowCombination(prefix, size) {
+    const cardIds = [];
+    for (let i = 0; i < size; i++) {
+        const cardId = gameState.slots[`${prefix}-${i}`];
+        if (cardId !== null) {
+            cardIds.push(gameState.cards.find(c => c.id == cardId));
+        }
+    }
+    if (cardIds.length < size) {
+        document.getElementById(`${prefix}-combination`).textContent = '-';
+        document.getElementById(`${prefix}-points`).textContent = '0';
+        return null;
+    }
+    const result = evaluateCombinationWithCards(cardIds);
+    document.getElementById(`${prefix}-combination`).textContent = result.combination;
+    // Рассчитываем бонусы только для UI
+    const rowType = prefix.split('-')[1];
+    const royalty = calculateRoyalty(result, rowType);
+    document.getElementById(`${prefix}-points`).textContent = royalty;
+    return result;
+}
+   function getCombinationRank(combination) {
+    const ranks = {
+        'High Card': 0,
+        'Pair': 1,
+        'Two Pairs': 2,
+        'Three of a Kind': 3,
+        'Straight': 4,
+        'Flush': 5,
+        'Full House': 6,
+        'Four of a Kind': 7,
+        'Straight Flush': 8,
+        'Royal Flush': 9
+    };
+    return ranks[combination] || 0;
+}
+// Get kicker strength (for comparing same combination types)
+function getCombinationStrength(cards, combination) {
+    // Sort cards by rank (high to low)
+    const sortedCards = [...cards].sort((a, b) => b.rank - a.rank);
+    // For combinations with fixed kickers
+    switch(combination) {
+        case 'Pair':
+            // Find pair value
+            const pairValue = sortedCards.find(card =>
+                sortedCards.filter(c => c.rank === card.rank).length === 2
+            ).rank;
+            // Get kickers
+            const kickers = sortedCards
+                .filter(c => c.rank !== pairValue)
+                .map(c => c.rank)
+                .sort((a, b) => b - a);
+            return [pairValue, ...kickers];
+        case 'Two Pairs':
+    const values = sortedCards.map(c => c.rank);
+    const counts = {};
+    values.forEach(v => counts[v] = (counts[v] || 0) + 1);
+    const pairs = Object.entries(counts)
+        .filter(([_, count]) => count === 2)
+        .map(([rank]) => parseInt(rank))
+        .sort((a, b) => b - a);
+    const kicker = Object.entries(counts)
+        .filter(([_, count]) => count === 1)
+        .map(([rank]) => parseInt(rank))[0];
+    return [...pairs, kicker];
+        case 'Three of a Kind':
+            const setValue = sortedCards.find(card =>
+                sortedCards.filter(c => c.rank === card.rank).length === 3
+            ).rank;
+            return [setValue];
+        case 'Straight':
+        case 'Straight Flush':
+            // Handle wheel (A-2-3-4-5)
+            const isWheel = sortedCards.some(c => c.rank === 14) &&
+                sortedCards.some(c => c.rank === 2) &&
+                sortedCards.some(c => c.rank === 3) &&
+                sortedCards.some(c => c.rank === 4) &&
+                sortedCards.some(c => c.rank === 5);
+            return [isWheel ? 5 : sortedCards[0].rank];
+        case 'Flush':
+        case 'High Card':
+            return sortedCards.map(c => c.rank);
+        case 'Full House':
+            const setVal = sortedCards.find(card =>
+                sortedCards.filter(c => c.rank === card.rank).length === 3
+            ).rank;
+            const pairVal = sortedCards.find(card =>
+                card.rank !== setVal &&
+                sortedCards.filter(c => c.rank === card.rank).length === 2
+            ).rank;
+            return [setVal, pairVal];
+        case 'Four of a Kind':
+            const quadValue = sortedCards.find(card =>
+                sortedCards.filter(c => c.rank === card.rank).length === 4
+            ).rank;
+            const kickerValue = sortedCards.find(c => c.rank !== quadValue).rank;
+            return [quadValue, kickerValue];
+        case 'Royal Flush':
+            return [14]; // Always highest
+        default:
+            return [sortedCards[0].rank];
+    }
+}
             // Evaluate combination for a set of cards
+function evaluateCombinationWithCards(cards, rowType) {
+    if (cards.length === 0) return {
+        combination: 'None',
+        strength: [],
+        cards: []
+    };
+    // Sort cards by rank (high to low)
+    const sortedCards = [...cards].sort((a, b) => b.rank - a.rank);
+    // Check flush
+    const isFlush = sortedCards.every(c => c.suit === sortedCards[0].suit);
+    // Check straight
+    let isStraight = true;
+    for (let i = 1; i < sortedCards.length; i++) {
+        if (sortedCards[i].rank !== sortedCards[i-1].rank - 1) {
+            isStraight = false;
+            break;
+        }
+    }
+    // Check wheel (A-2-3-4-5)
+    function isWheel(cards) {
+        const hasAce = cards.some(c => c.rank === 14);
+        const ranks = cards.map(c => c.rank).sort((a, b) => a - b);
+        return hasAce &&
+               ranks.includes(2) &&
+               ranks.includes(3) &&
+               ranks.includes(4) &&
+               ranks.includes(5);
+    }
+    isStraight = isStraight || isWheel(sortedCards);
+    // Check royal flush (10-J-Q-K-A of same suit)
+    const isRoyal = isFlush &&
+                   sortedCards[0].rank === 14 &&
+                   sortedCards[1].rank === 13 &&
+                   sortedCards[2].rank === 12 &&
+                   sortedCards[3].rank === 11 &&
+                   sortedCards[4].rank === 10;
+    // Check straight flush and royal flush
+    if (isStraight && isFlush && sortedCards.length >= 5) {
+        const combination = isRoyal ? 'Royal Flush' : 'Straight Flush';
+        return {
+            combination,
+            strength: getCombinationStrength(sortedCards, combination),
+            cards: sortedCards
+        };
+    }
+    // Check four of a kind
+    const rankCounts = {};
+    sortedCards.forEach(c => {
+        rankCounts[c.rank] = (rankCounts[c.rank] || 0) + 1;
+    });
+    const counts = Object.values(rankCounts);
+    if (counts.includes(4)) {
+        return {
+            combination: 'Four of a Kind',
+            strength: getCombinationStrength(sortedCards, 'Four of a Kind'),
+            cards: sortedCards
+        };
+    }
+    // Check full house
+    if (counts.includes(3) && counts.includes(2) && sortedCards.length >= 5) {
+        return {
+            combination: 'Full House',
+            strength: getCombinationStrength(sortedCards, 'Full House'),
+            cards: sortedCards
+        };
+    }
+    // Check flush (only for 5+ cards)
+    if (isFlush && sortedCards.length >= 5) {
+        return {
+            combination: 'Flush',
+            strength: getCombinationStrength(sortedCards, 'Flush'),
+            cards: sortedCards
+        };
+    }
+    // Check straight (only for 5+ cards)
+    if (isStraight && sortedCards.length >= 5) {
+        return {
+            combination: 'Straight',
+            strength: getCombinationStrength(sortedCards, 'Straight'),
+            cards: sortedCards
+        };
+    }
+    // Check three of a kind
+    if (counts.includes(3)) {
+        return {
+            combination: 'Three of a Kind',
+            strength: getCombinationStrength(sortedCards, 'Three of a Kind'),
+            cards: sortedCards
+        };
+    }
+    // Check two pairs
+    const pairCount = counts.filter(c => c === 2).length;
+    if (pairCount === 2) {
+        return {
+            combination: 'Two Pairs',
+            strength: getCombinationStrength(sortedCards, 'Two Pairs'),
+            cards: sortedCards
+        };
+    }
+    // Check pair
+    if (pairCount === 1) {
+        return {
+            combination: 'Pair',
+            strength: getCombinationStrength(sortedCards, 'Pair'),
+            cards: sortedCards
+        };
+    }
+    // High card
+    return {
+        combination: `High ${sortedCards[0].value}`,
+        strength: getCombinationStrength(sortedCards, 'High Card'),
+        cards: sortedCards
+    };
+}
+         function compareCombinations(comb1, comb2) {
+    // Compare combination ranks
+    const rank1 = getCombinationRank(comb1.combination);
+    const rank2 = getCombinationRank(comb2.combination);
+    if (rank1 !== rank2) {
+        return rank1 > rank2 ? 1 : -1;
+    }
+    // Same rank - compare strengths and kickers
+    const strength1 = comb1.strength;
+    const strength2 = comb2.strength;
+    for (let i = 0; i < Math.min(strength1.length, strength2.length); i++) {
+        if (strength1[i] !== strength2[i]) {
+            return strength1[i] > strength2[i] ? 1 : -1;
+        }
+    }
+    // All kickers match
+    return 0;
+}
+// =====================
+// Scoring Module (Updated)
+// =====================
+// Check for dead hand (invalid hand structure)
+function isDeadHand(rows) {
+    const { top, middle, bottom } = rows;
+    return !(compareCombinations(top, middle) <= 0 &&
+            compareCombinations(middle, bottom) <= 0);
+}
+// Calculate royalty points for a row
+function calculateRoyalty(row, rowType) {
+    const combination = row.combination;
+    if (rowType === 'bottom') {
+        switch(combination) {
+            case 'Straight': return 2;
+            case 'Flush': return 4;
+            case 'Full House': return 6;
+            case 'Four of a Kind': return 8;
+            case 'Straight Flush': return 10;
+            case 'Royal Flush': return 15;
+            default: return 0;
+        }
+    }
+    if (rowType === 'middle') {
+        switch(combination) {
+            case 'Three of a Kind': return 2;
+            case 'Straight': return 4;
+            case 'Flush': return 8;
+            case 'Full House': return 12;
+            case 'Four of a Kind': return 16;
+            case 'Straight Flush': return 20;
+            case 'Royal Flush': return 30;
+            default: return 0;
+        }
+    }
+    if (rowType === 'top') {
+        if (combination === 'Three of a Kind') {
+            const value = row.cards[0].value;
+            const rankMap = {
+                '2': 10, '3': 11, '4': 12, '5': 13, '6': 14,
+                '7': 15, '8': 16, '9': 17, 'T': 18, 'J': 19,
+                'Q': 20, 'K': 21, 'A': 22
+            };
+            return rankMap[value] || 0;
+        }
+        if (combination === 'Pair') {
+            // Find pair value
+            const values = row.cards.map(c => c.value);
+            const valueCounts = {};
+            values.forEach(v => valueCounts[v] = (valueCounts[v] || 0) + 1);
+            for (const [value, count] of Object.entries(valueCounts)) {
+                if (count === 2) {
+                    const rankMap = {
+                        '6': 1, '7': 2, '8': 3, '9': 4, 'T': 5,
+                        'J': 6, 'Q': 7, 'K': 8, 'A': 9
                     };
+                    return rankMap[value] || 0;
                 }
             }
+        }
+    }
+    return 0;
+}
+          function calculateRoyalties(rows) {
+    return calculateRoyalty(rows.top, 'top') +
+           calculateRoyalty(rows.middle, 'middle') +
+           calculateRoyalty(rows.bottom, 'bottom');
+}
+          function calculateScores(playerRows, opponentRows) {
+    // Dead hand penalties
+    const playerDead = isDeadHand(playerRows);
+    const opponentDead = isDeadHand(opponentRows);
+    if (playerDead && opponentDead) return { player: 0, opponent: 0 };
+    if (playerDead) return { player: 0, opponent: 6 + calculateRoyalties(opponentRows) };
+    if (opponentDead) return { player: 6 + calculateRoyalties(playerRows), opponent: 0 };
+    // Compare rows
+    const topResult = compareCombinations(playerRows.top, opponentRows.top);
+    const middleResult = compareCombinations(playerRows.middle, opponentRows.middle);
+    const bottomResult = compareCombinations(playerRows.bottom, opponentRows.bottom);
+    // Calculate row wins
+    let playerRowWins = 0;
+    let opponentRowWins = 0;
+    if (topResult > 0) playerRowWins++;
+    else if (topResult < 0) opponentRowWins++;
+    if (middleResult > 0) playerRowWins++;
+    else if (middleResult < 0) opponentRowWins++;
+    if (bottomResult > 0) playerRowWins++;
+    else if (bottomResult < 0) opponentRowWins++;
+    // Scoop bonus
+    let playerScore = playerRowWins;
+    let opponentScore = opponentRowWins;
+    if (playerRowWins === 3) playerScore += 3;
+    else if (opponentRowWins === 3) opponentScore += 3;
+    // Add royalties
+    playerScore += calculateRoyalties(playerRows);
+    opponentScore += calculateRoyalties(opponentRows);
+    return {
+        player: playerScore,
+        opponent: opponentScore,
+        details: {
+            player: { rowWins: playerRowWins, royalties: calculateRoyalties(playerRows) },
+            opponent: { rowWins: opponentRowWins, royalties: calculateRoyalties(opponentRows) }
+        }
+    };
+}
             // Calculate best moves (simplified for demo)
             function calculateBestMoves() {
                     v => v !== null && gameState.cardPositions[v]?.startsWith('opponent-')
                 ).length;
                 const resultsContainer = document.getElementById('results');
                 const resultsContent = document.getElementById('results-content');
             // Show final scores when all cards are placed
             function showFinalScores() {
+    // Получаем данные рядов
+    const playerRows = {
+        top: updateRowCombination('player-top', 3),
+        middle: updateRowCombination('player-middle', 5),
+        bottom: updateRowCombination('player-bottom', 5)
+    };
+    const opponentRows = {
+        top: updateRowCombination('opponent-top', 3),
+        middle: updateRowCombination('opponent-middle', 5),
+        bottom: updateRowCombination('opponent-bottom', 5)
+    };
+    // Вычисляем очки
+    const scores = calculateScores(playerRows, opponentRows);
+    // Только отображение результатов
+    document.getElementById('final-player-score').textContent = scores.player;
+    document.getElementById('final-opponent-score').textContent = scores.opponent;
+    document.getElementById('final-player-top').textContent = scores.details.player.royalties;
+    document.getElementById('final-opponent-top').textContent = scores.details.opponent.royalties;
+    document.getElementById('score-summary').classList.remove('hidden');
+}
             // Reset all cards
             function resetAllCards() {
             initGame();
         });
     </script>