advanced-games-library/src/utils/performance.js

Advanced Gaming Library for React Native - Four Complete Games with iOS Compatibility Fixes

// Performance monitoring utility
class PerformanceMonitor {
  constructor() {
    this.sessions = new Map();
    this.metrics = {
      gameLoadTimes: [],
      renderTimes: [],
      inputLatencies: []
    };
  }

  startGameSession(gameId) {
    const session = {
      gameId,
      startTime: Date.now(),
      metrics: {
        loadTime: 0,
        renderTimes: [],
        inputLatencies: [],
        memoryUsage: []
      }
    };
    this.sessions.set(gameId, session);
    console.log(`📊 Started performance session for ${gameId}`);
  }

  endGameSession(gameId) {
    const session = this.sessions.get(gameId);
    if (!session) return null;

    const endTime = Date.now();
    const duration = endTime - session.startTime;
    
    const benchmark = {
      gameId,
      duration,
      averageRenderTime: this.average(session.metrics.renderTimes),
      averageInputLatency: this.average(session.metrics.inputLatencies),
      totalMetrics: session.metrics
    };

    this.sessions.delete(gameId);
    console.log(`📊 Ended performance session for ${gameId}:`, benchmark);
    
    return benchmark;
  }

  recordGameLoadTime(gameId, time) {
    this.metrics.gameLoadTimes.push({ gameId, time, timestamp: Date.now() });
    const session = this.sessions.get(gameId);
    if (session) {
      session.metrics.loadTime = time;
    }
  }

  recordRenderTime(gameId, time) {
    this.metrics.renderTimes.push({ gameId, time, timestamp: Date.now() });
    const session = this.sessions.get(gameId);
    if (session) {
      session.metrics.renderTimes.push(time);
    }
  }

  recordInputLatency(gameId, time) {
    this.metrics.inputLatencies.push({ gameId, time, timestamp: Date.now() });
    const session = this.sessions.get(gameId);
    if (session) {
      session.metrics.inputLatencies.push(time);
    }
  }

  generateReport() {
    return {
      totalSessions: this.sessions.size,
      averageLoadTime: this.average(this.metrics.gameLoadTimes.map(m => m.time)),
      averageRenderTime: this.average(this.metrics.renderTimes.map(m => m.time)),
      averageInputLatency: this.average(this.metrics.inputLatencies.map(m => m.time)),
      activeSessions: Array.from(this.sessions.keys()),
      timestamp: new Date().toISOString()
    };
  }

  enableRemoteReporting(url) {
    console.log(`📊 Enabled remote reporting to ${url}`);
    // In a real implementation, this would send data to a remote endpoint
  }

  average(array) {
    if (!array || array.length === 0) return 0;
    return array.reduce((sum, val) => sum + val, 0) / array.length;
  }
}

export const performanceMonitor = new PerformanceMonitor();