Skip to main content

Get Tournament Results

The groupTournamentResults method retrieves the final rankings and results for a completed tournament. This includes participant rankings, scores, and prize information. Results are typically available after the tournament has ended.

Overview​

Use this method to:

  • Display final tournament rankings
  • Show prize winners and their achievements
  • Analyze tournament performance
  • Provide historical tournament data
  • Generate tournament completion reports

Method Signature​

MoitribeSDK(gameId, 'groupTournamentResults', {
  tournamentid: string,
  callback: (result) => {
    // Handle response
  }
});

Parameters​

ParameterTypeRequiredDescription
tournamentidstringYesUnique identifier of the tournament
callbackfunctionYesFunction to handle the response

Response Format​

{
  success: boolean;
  tournamentId: string;
  tournamentName: string;
  endTime: number;  // When tournament ended
  totalParticipants: number;  // Total number of participants
  rankings: TournamentRanking[];  // Array of player rankings
  playerRank?: number;  // Current player's rank (if participated)
  playerScore?: number;  // Current player's score (if participated)
  prizes?: PrizeAward[];  // Prize distribution information
  statistics?: TournamentStatistics;  // Tournament statistics
  msg?: string;  // Error message if success is false
}

interface TournamentRanking {
  rank: number;  // Final position (1, 2, 3...)
  player: Player;  // Player information
  score: number;  // Final score
  timestamp: number;  // When score was submitted
  prize?: PrizeInfo;  // Prize won (if any)
  isCurrentUser?: boolean;  // True if this is the current user
}

interface Player {
  id: string;  // Player unique ID
  name: string;  // Display name
  username?: string;  // Username
  avatar?: string;  // Avatar URL
  level?: number;  // Player level
  country?: string;  // Country code
}

interface PrizeAward {
  rank: number;  // Rank position
  prizeDescription: string;  // Prize description
  winnerId: string;  // Winner's player ID
  winnerName: string;  // Winner's name
  awarded: boolean;  // Whether prize was awarded
}

interface TournamentStatistics {
  averageScore: number;  // Average score of all participants
  highestScore: number;  // Highest score achieved
  lowestScore: number;  // Lowest score achieved
  totalSubmissions: number;  // Total score submissions
  averageSubmissionsPerPlayer: number;  // Average submissions per participant
  completionRate: number;  // Percentage of active participants
}

JavaScript Example​

// Get tournament results
MoitribeSDK('my-game-id', 'groupTournamentResults', {
  tournamentid: 'weekly-challenge-001',
  callback: (result) => {
    if (result.success) {
      console.log('Tournament Results:', result);
      console.log('Tournament:', result.tournamentName);
      console.log('Total participants:', result.totalParticipants);
      console.log('Ended:', new Date(result.endTime));
      
      // Show player's performance
      if (result.playerRank) {
        console.log(`Your rank: #${result.playerRank}`);
        console.log(`Your score: ${result.playerScore}`);
      }
      
      // Display rankings
      result.rankings.forEach((ranking, index) => {
        console.log(`#${ranking.rank}: ${ranking.player.name} - ${ranking.score}`);
        if (ranking.prize) {
          console.log(`  Prize: ${ranking.prize.description}`);
        }
      });
      
      // Show tournament statistics
      if (result.statistics) {
        console.log('Average score:', result.statistics.averageScore);
        console.log('Highest score:', result.statistics.highestScore);
      }
      
    } else {
      console.error('Failed to get tournament results:', result.msg);
      
      // Handle specific errors
      if (result.msg.includes('not ended')) {
        showMessage('Tournament has not ended yet');
      } else if (result.msg.includes('not found')) {
        showMessage('Tournament not found');
      } else if (result.msg.includes('available')) {
        showMessage('Results are not available yet');
      } else {
        showMessage('Failed to load tournament results');
      }
    }
  }
});

TypeScript Example​

import MoitribeSDK from '@veniso/moitribe-js';

interface TournamentResultsResponse {
  success: boolean;
  tournamentId: string;
  tournamentName: string;
  endTime: number;
  totalParticipants: number;
  rankings: TournamentRanking[];
  playerRank?: number;
  playerScore?: number;
  prizes?: PrizeAward[];
  statistics?: TournamentStatistics;
  msg?: string;
}

interface TournamentRanking {
  rank: number;
  player: Player;
  score: number;
  timestamp: number;
  prize?: PrizeInfo;
  isCurrentUser?: boolean;
}

interface Player {
  id: string;
  name: string;
  username?: string;
  avatar?: string;
  level?: number;
  country?: string;
}

interface PrizeInfo {
  description: string;
  value?: string;
  icon?: string;
}

interface PrizeAward {
  rank: number;
  prizeDescription: string;
  winnerId: string;
  winnerName: string;
  awarded: boolean;
}

interface TournamentStatistics {
  averageScore: number;
  highestScore: number;
  lowestScore: number;
  totalSubmissions: number;
  averageSubmissionsPerPlayer: number;
  completionRate: number;
}

// Get tournament results with proper typing
MoitribeSDK('my-game-id', 'groupTournamentResults', {
  tournamentid: 'weekly-challenge-001',
  callback: (result: TournamentResultsResponse) => {
    if (result.success) {
      displayTournamentResults(result);
    } else {
      handleResultsError(result.msg);
    }
  }
});

function displayTournamentResults(results: TournamentResultsResponse) {
  const container = document.getElementById('tournament-results');
  
  // Tournament header
  const header = document.createElement('div');
  header.className = 'results-header';
  header.innerHTML = `
    <h1>${results.tournamentName} - Final Results</h1>
    <div class="tournament-meta">
      <span class="end-time">Ended: ${new Date(results.endTime).toLocaleString()}</span>
      <span class="participants">${results.totalParticipants} Participants</span>
    </div>
  `;
  
  container.appendChild(header);
  
  // Player's performance summary
  if (results.playerRank) {
    const playerSummary = document.createElement('div');
    playerSummary.className = 'player-summary';
    playerSummary.innerHTML = `
      <h2>Your Performance</h2>
      <div class="performance-stats">
        <div class="stat-item">
          <span class="stat-value">#${results.playerRank}</span>
          <span class="stat-label">Final Rank</span>
        </div>
        <div class="stat-item">
          <span class="stat-value">${formatScore(results.playerScore)}</span>
          <span class="stat-label">Final Score</span>
        </div>
        <div class="stat-item">
          <span class="stat-value">${calculatePercentile(results.playerRank, results.totalParticipants)}</span>
          <span class="stat-label">Percentile</span>
        </div>
      </div>
    `;
    container.appendChild(playerSummary);
  }
  
  // Rankings table
  const rankingsSection = document.createElement('div');
  rankingsSection.className = 'rankings-section';
  rankingsSection.innerHTML = `
    <h2>Final Rankings</h2>
    <div class="rankings-table">
      ${generateRankingsTable(results.rankings)}
    </div>
  `;
  container.appendChild(rankingsSection);
  
  // Prize winners
  if (results.prizes && results.prizes.length > 0) {
    const prizesSection = document.createElement('div');
    prizesSection.className = 'prizes-section';
    prizesSection.innerHTML = `
      <h2>Prize Winners</h2>
      <div class="prize-winners">
        ${results.prizes.map(prize => `
          <div class="prize-winner">
            <div class="prize-rank">Rank ${prize.rank}</div>
            <div class="prize-description">${prize.prizeDescription}</div>
            <div class="winner-info">
              <strong>${prize.winnerName}</strong>
              ${prize.awarded ? '✓' : 'Pending'}
            </div>
          </div>
        `).join('')}
      </div>
    `;
    container.appendChild(prizesSection);
  }
  
  // Tournament statistics
  if (results.statistics) {
    const statsSection = document.createElement('div');
    statsSection.className = 'statistics-section';
    statsSection.innerHTML = `
      <h2>Tournament Statistics</h2>
      <div class="stats-grid">
        <div class="stat-card">
          <div class="stat-title">Average Score</div>
          <div class="stat-value">${formatScore(results.statistics.averageScore)}</div>
        </div>
        <div class="stat-card">
          <div class="stat-title">Highest Score</div>
          <div class="stat-value">${formatScore(results.statistics.highestScore)}</div>
        </div>
        <div class="stat-card">
          <div class="stat-title">Total Submissions</div>
          <div class="stat-value">${results.statistics.totalSubmissions.toLocaleString()}</div>
        </div>
        <div class="stat-card">
          <div class="stat-title">Completion Rate</div>
          <div class="stat-value">${(results.statistics.completionRate * 100).toFixed(1)}%</div>
        </div>
      </div>
    `;
    container.appendChild(statsSection);
  }
}

function generateRankingsTable(rankings: TournamentRanking[]): string {
  return `
    <table class="rankings-table">
      <thead>
        <tr>
          <th>Rank</th>
          <th>Player</th>
          <th>Score</th>
          <th>Time</th>
          <th>Prize</th>
        </tr>
      </thead>
      <tbody>
        ${rankings.map(ranking => `
          <tr class="${ranking.isCurrentUser ? 'current-user' : ''}">
            <td class="rank-cell">
              ${getRankDisplay(ranking.rank)}
            </td>
            <td class="player-cell">
              <div class="player-info">
                ${ranking.player.avatar ? 
                  `<img src="${ranking.player.avatar}" alt="${ranking.player.name}" class="player-avatar">` : 
                  `<div class="default-avatar">${ranking.player.name.charAt(0).toUpperCase()}</div>`
                }
                <div class="player-details">
                  <div class="player-name">${ranking.player.name}</div>
                  ${ranking.player.level ? `<div class="player-level">Level ${ranking.player.level}</div>` : ''}
                  ${ranking.player.country ? `<div class="player-country">${ranking.player.country}</div>` : ''}
                </div>
              </div>
            </td>
            <td class="score-cell">
              <span class="score-value">${formatScore(ranking.score)}</span>
            </td>
            <td class="time-cell">
              ${formatRelativeTime(ranking.timestamp)}
            </td>
            <td class="prize-cell">
              ${ranking.prize ? 
                `<div class="prize-badge">${ranking.prize.description}</div>` : 
                '-'
              }
            </td>
          </tr>
        `).join('')}
      </tbody>
    </table>
  `;
}

function getRankDisplay(rank: number): string {
  if (rank === 1) return '🥇';
  if (rank === 2) return '🥈';
  if (rank === 3) return '🥉';
  return `#${rank}`;
}

function formatScore(score: number): string {
  if (score >= 1000000) {
    return (score / 1000000).toFixed(1) + 'M';
  } else if (score >= 1000) {
    return (score / 1000).toFixed(1) + 'K';
  }
  return score.toString();
}

function formatRelativeTime(timestamp: number): string {
  const now = Date.now();
  const diff = now - timestamp;
  const minutes = Math.floor(diff / (1000 * 60));
  const hours = Math.floor(minutes / 60);
  const days = Math.floor(hours / 24);
  
  if (days > 0) return `${days} day${days > 1 ? 's' : ''} ago`;
  if (hours > 0) return `${hours} hour${hours > 1 ? 's' : ''} ago`;
  if (minutes > 0) return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
  return 'Just now';
}

function calculatePercentile(rank: number, totalParticipants: number): string {
  const percentile = ((totalParticipants - rank) / totalParticipants * 100).toFixed(1);
  return `Top ${percentile}%`;
}

function handleResultsError(errorMsg?: string) {
  let userMessage = 'Failed to load tournament results';
  
  if (errorMsg) {
    if (errorMsg.includes('not ended')) {
      userMessage = 'Tournament has not ended yet. Results will be available after completion.';
    } else if (errorMsg.includes('not found')) {
      userMessage = 'Tournament not found or does not exist.';
    } else if (errorMsg.includes('available')) {
      userMessage = 'Results are being processed. Please check back later.';
    } else if (errorMsg.includes('access')) {
      userMessage = 'You do not have permission to view these results.';
    } else {
      userMessage = errorMsg;
    }
  }
  
  showNotification(userMessage, 'error');
}

Common Use Cases​

Complete Results Display​

Create a comprehensive tournament results page:

function displayCompleteTournamentResults(tournamentId) {
  showLoadingState();
  
  MoitribeSDK('my-game-id', 'groupTournamentResults', {
    tournamentid: tournamentId,
    callback: (result) => {
      hideLoadingState();
      
      if (result.success) {
        renderCompleteResults(result);
      } else {
        showResultsError(result.msg);
      }
    }
  });
}

function renderCompleteResults(results) {
  const container = document.getElementById('tournament-results');
  container.innerHTML = '';
  
  // Results header with tournament info
  renderResultsHeader(container, results);
  
  // Player performance summary
  if (results.playerRank) {
    renderPlayerPerformance(container, results);
  }
  
  // Top 3 podium
  renderPodium(container, results.rankings.slice(0, 3));
  
  // Full rankings table
  renderRankingsTable(container, results.rankings);
  
  // Prize distribution
  if (results.prizes && results.prizes.length > 0) {
    renderPrizeDistribution(container, results.prizes);
  }
  
  // Tournament statistics
  if (results.statistics) {
    renderTournamentStatistics(container, results.statistics);
  }
  
  // Action buttons
  renderActionButtons(container, results);
}

function renderResultsHeader(container, results) {
  const header = document.createElement('div');
  header.className = 'results-header';
  header.innerHTML = `
    <div class="tournament-banner">
      <h1>${results.tournamentName}</h1>
      <div class="tournament-status completed">COMPLETED</div>
    </div>
    <div class="tournament-info">
      <div class="info-item">
        <span class="info-label">Ended:</span>
        <span class="info-value">${new Date(results.endTime).toLocaleString()}</span>
      </div>
      <div class="info-item">
        <span class="info-label">Participants:</span>
        <span class="info-value">${results.totalParticipants.toLocaleString()}</span>
      </div>
      <div class="info-item">
        <span class="info-label">Duration:</span>
        <span class="info-value">${calculateTournamentDuration(results.endTime)}</span>
      </div>
    </div>
  `;
  
  container.appendChild(header);
}

function renderPodium(container, topThree) {
  const podium = document.createElement('div');
  podium.className = 'podium-section';
  podium.innerHTML = `
    <h2>🏆 Winners Podium</h2>
    <div class="podium">
      ${topThree.map((player, index) => `
        <div class="podium-position position-${index + 1}">
          <div class="podium-rank">${getMedalEmoji(index + 1)}</div>
          <div class="podium-player">
            ${player.player.avatar ? 
              `<img src="${player.player.avatar}" alt="${player.player.name}" class="podium-avatar">` :
              `<div class="podium-avatar-placeholder">${player.player.name.charAt(0).toUpperCase()}</div>`
            }
            <div class="podium-name">${player.player.name}</div>
            <div class="podium-score">${formatScore(player.score)}</div>
          </div>
          ${player.prize ? `<div class="podium-prize">${player.prize.description}</div>` : ''}
        </div>
      `).join('')}
    </div>
  `;
  
  container.appendChild(podium);
}

function getMedalEmoji(rank) {
  const medals = { 1: '🥇', 2: '🥈', 3: '🥉' };
  return medals[rank] || `#${rank}`;
}

function renderPlayerPerformance(container, results) {
  const performance = document.createElement('div');
  performance.className = 'player-performance';
  
  const percentile = calculatePercentile(results.playerRank, results.totalParticipants);
  const rankImprovement = calculateRankImprovement(results.playerRank);
  
  performance.innerHTML = `
    <h2>Your Performance</h2>
    <div class="performance-cards">
      <div class="performance-card rank-card">
        <div class="card-icon">🏅</div>
        <div class="card-value">#${results.playerRank}</div>
        <div class="card-label">Final Rank</div>
        ${rankImprovement ? `<div class="rank-improvement">${rankImprovement}</div>` : ''}
      </div>
      <div class="performance-card score-card">
        <div class="card-icon">⭐</div>
        <div class="card-value">${formatScore(results.playerScore)}</div>
        <div class="card-label">Final Score</div>
      </div>
      <div class="performance-card percentile-card">
        <div class="card-icon">📊</div>
        <div class="card-value">${percentile}</div>
        <div class="card-label">Percentile</div>
      </div>
    </div>
  `;
  
  container.appendChild(performance);
}

function calculateRankImprovement(currentRank) {
  // This would compare with previous tournament performance
  // For example purposes, returning mock improvement
  const previousRank = Math.floor(currentRank * (0.8 + Math.random() * 0.4));
  if (previousRank > currentRank) {
    return `↑ Improved ${previousRank - currentRank} ranks`;
  } else if (previousRank < currentRank) {
    return `↓ ${currentRank - previousRank} ranks lower`;
  }
  return null;
}

Results Sharing​

Enable sharing tournament results:

function shareTournamentResults(results) {
  const shareText = generateShareText(results);
  const shareUrl = generateShareUrl(results.tournamentId);
  
  if (navigator.share) {
    // Use Web Share API if available
    navigator.share({
      title: `${results.tournamentName} - Results`,
      text: shareText,
      url: shareUrl
    }).catch(err => {
      console.log('Share cancelled or failed:', err);
    });
  } else {
    // Fallback to clipboard
    copyToClipboard(`${shareText}\n${shareUrl}`);
    showNotification('Results copied to clipboard!', 'success');
  }
}

function generateShareText(results) {
  let text = `I finished #${results.playerRank} in ${results.tournamentName} with a score of ${formatScore(results.playerScore)}!`;
  
  if (results.playerRank <= 10) {
    text += ' 🏆 Top 10 finish!';
  } else if (results.playerRank <= 100) {
    text += ' 🎯 Top 100 finish!';
  }
  
  text += ` Out of ${results.totalParticipants.toLocaleString()} participants.`;
  
  return text;
}

function generateShareUrl(tournamentId) {
  const baseUrl = window.location.origin;
  return `${baseUrl}/tournaments/${tournamentId}/results`;
}

function copyToClipboard(text) {
  const textarea = document.createElement('textarea');
  textarea.value = text;
  textarea.style.position = 'fixed';
  textarea.style.opacity = '0';
  document.body.appendChild(textarea);
  textarea.select();
  document.execCommand('copy');
  document.body.removeChild(textarea);
}

Results Comparison​

Compare performance with previous tournaments:

function compareWithPreviousResults(currentResults) {
  const previousResults = loadPreviousTournamentResults();
  
  if (!previousResults || previousResults.length === 0) {
    showNoPreviousResults();
    return;
  }
  
  const comparison = generateComparison(currentResults, previousResults);
  renderComparisonSection(comparison);
}

function generateComparison(currentResults, previousResults) {
  const mostRecent = previousResults[0]; // Assuming sorted by date
  
  return {
    rankChange: mostRecent.rank - currentResults.playerRank,
    scoreChange: currentResults.playerScore - mostRecent.score,
    percentileChange: calculatePercentileChange(currentResults, mostRecent),
    participationTrend: calculateParticipationTrend(currentResults, previousResults),
    improvementStreak: calculateImprovementStreak(currentResults, previousResults)
  };
}

function renderComparisonSection(comparison) {
  const section = document.createElement('div');
  section.className = 'comparison-section';
  section.innerHTML = `
    <h2>Performance Comparison</h2>
    <div class="comparison-cards">
      <div class="comparison-card">
        <div class="comparison-label">Rank Change</div>
        <div class="comparison-value ${comparison.rankChange > 0 ? 'positive' : 'negative'}">
          ${comparison.rankChange > 0 ? '↑' : '↓'} ${Math.abs(comparison.rankChange)} ranks
        </div>
      </div>
      <div class="comparison-card">
        <div class="comparison-label">Score Change</div>
        <div class="comparison-value ${comparison.scoreChange > 0 ? 'positive' : 'negative'}">
          ${comparison.scoreChange > 0 ? '+' : ''}${formatScore(comparison.scoreChange)}
        </div>
      </div>
      <div class="comparison-card">
        <div class="comparison-label">Improvement Streak</div>
        <div class="comparison-value">
          ${comparison.improvementStreak} tournaments
        </div>
      </div>
    </div>
  `;
  
  document.getElementById('tournament-results').appendChild(section);
}

Results Export​

Export tournament results to different formats:

function exportTournamentResults(results, format) {
  switch (format) {
    case 'csv':
      exportToCSV(results);
      break;
    case 'json':
      exportToJSON(results);
      break;
    case 'pdf':
      exportToPDF(results);
      break;
    default:
      showNotification('Unsupported export format', 'error');
  }
}

function exportToCSV(results) {
  const headers = ['Rank', 'Player Name', 'Score', 'Submission Time', 'Prize'];
  const rows = results.rankings.map(ranking => [
    ranking.rank,
    ranking.player.name,
    ranking.score,
    new Date(ranking.timestamp).toISOString(),
    ranking.prize ? ranking.prize.description : ''
  ]);
  
  const csvContent = [headers, ...rows]
    .map(row => row.map(cell => `"${cell}"`).join(','))
    .join('\n');
  
  downloadFile(csvContent, `${results.tournamentName}-results.csv`, 'text/csv');
}

function exportToJSON(results) {
  const jsonContent = JSON.stringify(results, null, 2);
  downloadFile(jsonContent, `${results.tournamentName}-results.json`, 'application/json');
}

function downloadFile(content, filename, mimeType) {
  const blob = new Blob([content], { type: mimeType });
  const url = URL.createObjectURL(blob);
  
  const link = document.createElement('a');
  link.href = url;
  link.download = filename;
  link.style.display = 'none';
  
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
  
  URL.revokeObjectURL(url);
}

Error Handling​

Handle common results retrieval errors:

function handleResultsError(error, tournamentId) {
  console.error('Tournament results error:', error);
  
  let userMessage = 'Failed to load tournament results';
  let canRetry = true;
  let retryDelay = 2000;
  
  if (error.includes('not ended')) {
    userMessage = 'Tournament has not ended yet. Results will be available after completion.';
    canRetry = false;
    showTournamentCountdown(tournamentId);
  } else if (error.includes('not found')) {
    userMessage = 'Tournament not found or does not exist.';
    canRetry = false;
    showTournamentList();
  } else if (error.includes('available')) {
    userMessage = 'Results are being processed. Please check back later.';
    canRetry = true;
    retryDelay = 30000; // 30 seconds
  } else if (error.includes('access')) {
    userMessage = 'You do not have permission to view these results.';
    canRetry = false;
  } else if (error.includes('network')) {
    userMessage = 'Network error. Please check your connection.';
    retryDelay = 5000;
  } else {
    userMessage = error;
  }
  
  showNotification(userMessage, 'error', canRetry ? () => {
    setTimeout(() => loadTournamentResults(tournamentId), retryDelay);
  } : null);
}

function showTournamentCountdown(tournamentId) {
  // Get tournament data to show countdown
  MoitribeSDK('my-game-id', 'groupTournamentData', {
    tournamentid: tournamentId,
    callback: (result) => {
      if (result.success) {
        showCountdownToResults(result.tournament);
      }
    }
  });
}

function showCountdownToResults(tournament) {
  const container = document.getElementById('tournament-results');
  container.innerHTML = `
    <div class="countdown-to-results">
      <h2>${tournament.name}</h2>
      <div class="status-badge">In Progress</div>
      <div class="countdown-display" id="results-countdown">
        Calculating time remaining...
      </div>
      <p>Results will be available when the tournament ends.</p>
    </div>
  `;
  
  startResultsCountdown(tournament.endTime);
}

function startResultsCountdown(endTime) {
  function updateCountdown() {
    const now = Date.now();
    const timeLeft = endTime - now;
    
    if (timeLeft <= 0) {
      document.getElementById('results-countdown').innerHTML = 
        '<div class="countdown-ended">Tournament ended! Loading results...</div>';
      setTimeout(() => {
        loadTournamentResults(currentTournamentId);
      }, 2000);
      return;
    }
    
    const days = Math.floor(timeLeft / (1000 * 60 * 60 * 24));
    const hours = Math.floor((timeLeft % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
    const minutes = Math.floor((timeLeft % (1000 * 60 * 60)) / (1000 * 60));
    const seconds = Math.floor((timeLeft % (1000 * 60)) / 1000);
    
    document.getElementById('results-countdown').innerHTML = `
      <div class="countdown-timer">
        ${days > 0 ? `<span class="countdown-unit">${days}d</span>` : ''}
        <span class="countdown-unit">${hours}h</span>
        <span class="countdown-unit">${minutes}m</span>
        <span class="countdown-unit">${seconds}s</span>
      </div>
      <div class="countdown-label">until results</div>
    `;
    
    requestAnimationFrame(updateCountdown);
  }
  
  updateCountdown();
}

Best Practices​

Results Caching​

Cache tournament results to improve performance:

class ResultsCache {
  constructor() {
    this.cache = new Map();
    this.cacheTimeout = 5 * 60 * 1000; // 5 minutes
  }
  
  get(tournamentId) {
    const cached = this.cache.get(tournamentId);
    if (cached && (Date.now() - cached.timestamp) < this.cacheTimeout) {
      return cached.data;
    }
    return null;
  }
  
  set(tournamentId, data) {
    this.cache.set(tournamentId, {
      data: data,
      timestamp: Date.now()
    });
  }
  
  clear() {
    this.cache.clear();
  }
}

const resultsCache = new ResultsCache();

function getCachedResults(tournamentId) {
  const cached = resultsCache.get(tournamentId);
  if (cached) {
    displayTournamentResults(cached);
    return true;
  }
  return false;
}

function loadTournamentResults(tournamentId) {
  // Check cache first
  if (getCachedResults(tournamentId)) {
    return;
  }
  
  // Load from API
  MoitribeSDK('my-game-id', 'groupTournamentResults', {
    tournamentid: tournamentId,
    callback: (result) => {
      if (result.success) {
        resultsCache.set(tournamentId, result);
        displayTournamentResults(result);
      } else {
        handleResultsError(result.msg, tournamentId);
      }
    }
  });
}

Progressive Loading​

Load results progressively for better UX:

function loadResultsProgressively(tournamentId) {
  // Show loading skeleton
  showResultsSkeleton();
  
  // Load basic results first
  MoitribeSDK('my-game-id', 'groupTournamentResults', {
    tournamentid: tournamentId,
    callback: (result) => {
      if (result.success) {
        // Show basic info immediately
        showBasicResults(result);
        
        // Load additional data progressively
        loadAdditionalResultsData(result);
      } else {
        handleResultsError(result.msg, tournamentId);
      }
    }
  });
}

function showBasicResults(results) {
  // Show tournament header, player rank, top 10
  renderResultsHeader(results);
  if (results.playerRank) {
    renderPlayerPerformance(results);
  }
  renderTopRankings(results.rankings.slice(0, 10));
}

function loadAdditionalResultsData(results) {
  // Load full rankings
  setTimeout(() => {
    renderFullRankings(results.rankings);
  }, 500);
  
  // Load statistics
  setTimeout(() => {
    if (results.statistics) {
      renderTournamentStatistics(results.statistics);
    }
  }, 1000);
  
  // Load prize information
  setTimeout(() => {
    if (results.prizes) {
      renderPrizeDistribution(results.prizes);
    }
  }, 1500);
}

Next Steps​

After viewing tournament results:

Related topics: