universal_compatibility_engine.py

#!/usr/bin/env python3
"""
Universal Compatibility Engine
Designed to work fairly across all system configurations
"""

import sqlite3
from typing import Dict, List, Any, Tuple

class UniversalCompatibilityEngine:
    """
    Universal compatibility engine that provides fair assessments across all hardware tiers
    """
    
    def __init__(self, db_path: str):
        self.db_path = db_path
        self.compatibility_thresholds = {
            'ultra_high': 0.9,  # 90% compatibility for ultra-high systems
            'high': 0.75,       # 75% compatibility for high-end systems
            'medium': 0.6,      # 60% compatibility for medium systems
            'low': 0.5,         # 50% compatibility for low-end systems
            'minimum': 0.4      # 40% compatibility for minimum systems
        }
    
    def get_compatible_games_universal(self, system_specs: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Get games compatible with any system using adaptive thresholds"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Get performance tier
            performance_tier = system_specs.get('performance_tier', 'minimum')
            compatibility_threshold = self.compatibility_thresholds.get(performance_tier, 0.4)
            
            cursor.execute('''
                SELECT name, min_requirements, recommended_requirements, 
                       min_cpu_score, min_gpu_score, min_ram, min_storage, source,
                       steam_url, gog_url, epic_url, youtube_trailer
                FROM games
                ORDER BY name
            ''')
            
            rows = cursor.fetchall()
            conn.close()
            
            compatible_games = []
            for row in rows:
                game = {
                    'name': row[0],
                    'min_requirements': row[1],
                    'recommended_requirements': row[2],
                    'min_cpu_score': row[3] or 0,
                    'min_gpu_score': row[4] or 0,
                    'min_ram': row[5] or 0,
                    'min_storage': row[6] or 0,
                    'source': row[7],
                    'steam_url': row[8],
                    'gog_url': row[9],
                    'epic_url': row[10],
                    'youtube_trailer': row[11]
                }
                
                # Calculate compatibility using universal algorithm
                compatibility_score = self.calculate_universal_compatibility(game, system_specs)
                
                if compatibility_score >= compatibility_threshold:
                    game['compatibility_score'] = compatibility_score
                    compatible_games.append(game)
            
            # Sort by compatibility score (best matches first)
            compatible_games.sort(key=lambda x: x['compatibility_score'], reverse=True)
            
            return compatible_games
            
        except Exception as e:
            print(f"Error getting compatible games: {e}")
            return []
    
    def calculate_universal_compatibility(self, game: Dict[str, Any], system_specs: Dict[str, Any]) -> float:
        """Calculate compatibility score using universal algorithm (0.0 to 1.0)"""
        try:
            # Get system specs
            system_cpu = system_specs.get('cpu_score', 0)
            system_gpu = system_specs.get('gpu_score', 0)
            system_ram = system_specs.get('ram', 0)
            system_storage = system_specs.get('storage', 0)
            
            # Get game requirements
            game_cpu = game.get('min_cpu_score', 0)
            game_gpu = game.get('min_gpu_score', 0)
            game_ram = game.get('min_ram', 0)
            game_storage = game.get('min_storage', 0)
            
            # Calculate individual component scores
            cpu_score = self.calculate_component_score(system_cpu, game_cpu)
            gpu_score = self.calculate_component_score(system_gpu, game_gpu)
            ram_score = self.calculate_component_score(system_ram, game_ram)
            storage_score = self.calculate_component_score(system_storage, game_storage)
            
            # Weighted average (GPU and CPU are most important)
            weights = {
                'cpu': 0.3,
                'gpu': 0.4,
                'ram': 0.2,
                'storage': 0.1
            }
            
            total_score = (
                cpu_score * weights['cpu'] +
                gpu_score * weights['gpu'] +
                ram_score * weights['ram'] +
                storage_score * weights['storage']
            )
            
            return min(total_score, 1.0)  # Cap at 1.0
            
        except Exception as e:
            print(f"Error calculating compatibility: {e}")
            return 0.0
    
    def calculate_component_score(self, system_value: float, required_value: float) -> float:
        """Calculate compatibility score for individual component (0.0 to 1.0+)"""
        if required_value <= 0:
            return 1.0  # No requirement means automatic pass
        
        if system_value <= 0:
            return 0.0  # No system capability means fail
        
        ratio = system_value / required_value
        
        if ratio >= 2.0:
            return 1.0  # System exceeds requirements by 2x or more
        elif ratio >= 1.5:
            return 0.95  # System exceeds requirements by 50%+
        elif ratio >= 1.2:
            return 0.9   # System exceeds requirements by 20%+
        elif ratio >= 1.0:
            return 0.8   # System meets requirements exactly
        elif ratio >= 0.9:
            return 0.7   # System is slightly below requirements
        elif ratio >= 0.8:
            return 0.6   # System is notably below requirements
        elif ratio >= 0.7:
            return 0.5   # System is significantly below requirements
        elif ratio >= 0.5:
            return 0.3   # System is well below requirements
        else:
            return 0.1   # System is far below requirements
    
    def get_compatibility_explanation(self, game: Dict[str, Any], system_specs: Dict[str, Any]) -> str:
        """Get human-readable explanation of compatibility"""
        score = self.calculate_universal_compatibility(game, system_specs)
        performance_tier = system_specs.get('performance_tier', 'minimum')
        
        if score >= 0.9:
            return "Excellent - Should run smoothly at high settings"
        elif score >= 0.8:
            return "Very Good - Should run well at medium-high settings"
        elif score >= 0.7:
            return "Good - Should run well at medium settings"
        elif score >= 0.6:
            return "Fair - Should run at medium-low settings"
        elif score >= 0.5:
            return "Playable - May need low settings"
        elif score >= 0.4:
            return "Limited - Low settings, possible stuttering"
        else:
            return "Not Recommended - Likely to have performance issues"
    
    def get_performance_recommendations(self, system_specs: Dict[str, Any]) -> Dict[str, Any]:
        """Get performance and game recommendations based on system"""
        performance_tier = system_specs.get('performance_tier', 'minimum')
        cpu_score = system_specs.get('cpu_score', 0)
        gpu_score = system_specs.get('gpu_score', 0)
        ram_gb = system_specs.get('ram', 0)
        
        recommendations = {
            'tier': performance_tier,
            'suitable_genres': [],
            'recommended_settings': {},
            'upgrade_suggestions': []
        }
        
        if performance_tier in ['ultra_high', 'high']:
            recommendations['suitable_genres'] = [
                'All AAA games', 'VR games', 'Simulation games', 'Open world games'
            ]
            recommendations['recommended_settings'] = {
                'resolution': '1440p-4K',
                'quality': 'High-Ultra',
                'raytracing': 'Possible',
                'fps_target': '60+'
            }
        elif performance_tier == 'medium':
            recommendations['suitable_genres'] = [
                'Most modern games', 'Competitive games', 'RPGs', 'Strategy games'
            ]
            recommendations['recommended_settings'] = {
                'resolution': '1080p',
                'quality': 'Medium-High',
                'raytracing': 'Limited',
                'fps_target': '60'
            }
        elif performance_tier == 'low':
            recommendations['suitable_genres'] = [
                'Indie games', 'Esports titles', 'Older AAA games', 'Strategy games'
            ]
            recommendations['recommended_settings'] = {
                'resolution': '1080p',
                'quality': 'Medium-Low',
                'raytracing': 'Off',
                'fps_target': '30-60'
            }
        else:  # minimum
            recommendations['suitable_genres'] = [
                '2D games', 'Pixel art games', 'Retro games', 'Browser games'
            ]
            recommendations['recommended_settings'] = {
                'resolution': '720p-1080p',
                'quality': 'Low',
                'raytracing': 'Off',
                'fps_target': '30+'
            }
        
        # Upgrade suggestions
        if cpu_score < 50:
            recommendations['upgrade_suggestions'].append('CPU upgrade would improve performance')
        if gpu_score < 40:
            recommendations['upgrade_suggestions'].append('GPU upgrade would significantly improve gaming')
        if ram_gb < 8:
            recommendations['upgrade_suggestions'].append('More RAM (8GB+) recommended for modern games')
        
        return recommendations

# Test the universal system
def test_universal_compatibility():
    """Test the universal compatibility system"""
    from universal_system_analyzer import UniversalSystemAnalyzer
    
    analyzer = UniversalSystemAnalyzer()
    engine = UniversalCompatibilityEngine("games.db")
    
    # Get system specs
    system_specs = analyzer.get_system_specs()
    
    print("=== UNIVERSAL COMPATIBILITY TEST ===")
    print(f"System Performance Tier: {system_specs.get('performance_tier', 'unknown')}")
    print(f"CPU Score: {system_specs.get('cpu_score', 0)}")
    print(f"GPU Score: {system_specs.get('gpu_score', 0)}")
    print(f"RAM: {system_specs.get('ram', 0)} GB")
    
    # Get compatible games
    compatible_games = engine.get_compatible_games_universal(system_specs)
    
    print(f"\nFound {len(compatible_games)} compatible games:")
    for i, game in enumerate(compatible_games[:10], 1):  # Show top 10
        explanation = engine.get_compatibility_explanation(game, system_specs)
        print(f"{i}. {game['name']} - {explanation}")
    
    # Get recommendations
    recommendations = engine.get_performance_recommendations(system_specs)
    print(f"\nRecommendations for {recommendations['tier']} tier system:")
    print(f"Suitable genres: {', '.join(recommendations['suitable_genres'])}")
    print(f"Recommended settings: {recommendations['recommended_settings']}")
    if recommendations['upgrade_suggestions']:
        print(f"Upgrade suggestions: {', '.join(recommendations['upgrade_suggestions'])}")

if __name__ == "__main__":
    test_universal_compatibility()