libstormgames/scoreboard.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Scoreboard handling for Storm Games.

Provides functionality for:
- Tracking high scores with player names
- Saving/loading high scores from configuration
"""

import time
from .services import ConfigService
from .speech import Speech

# For backward compatibility
from .config import localConfig, write_config, read_config

class Scoreboard:
    """Handles high score tracking with player names."""
    
    def __init__(self, score=0, config_service=None, speech=None):
        """Initialize scoreboard.
        
        Args:
            score (int): Initial score (default: 0)
            config_service (ConfigService): Config service (default: global instance)
            speech (Speech): Speech system (default: global instance)
        """
        self.config_service = config_service or ConfigService.get_instance()
        self.speech = speech or Speech.get_instance()
        self.current_score = score
        self.high_scores = []
        
        # For backward compatibility
        read_config()
    
        try:
            # Try to use config_service
            self.config_service.local_config.add_section("scoreboard")
        except:
            # Fallback to old method
            try:
                localConfig.add_section("scoreboard")
            except:
                pass
        
        # Load existing high scores
        for i in range(1, 11):
            try:
                # Try to use config_service
                score = self.config_service.local_config.getint("scoreboard", f"score_{i}")
                name = self.config_service.local_config.get("scoreboard", f"name_{i}")
                self.high_scores.append({
                    'name': name,
                    'score': score
                })
            except:
                # Fallback to old method
                try:
                    score = localConfig.getint("scoreboard", f"score_{i}")
                    name = localConfig.get("scoreboard", f"name_{i}")
                    self.high_scores.append({
                        'name': name,
                        'score': score
                    })
                except:
                    self.high_scores.append({
                        'name': "Player",
                        'score': 0
                    })
    
        # Sort high scores by score value in descending order
        self.high_scores.sort(key=lambda x: x['score'], reverse=True)
                
    def get_score(self):
        """Get current score."""
        return self.current_score
        
    def get_high_scores(self):
        """Get list of high scores."""
        return self.high_scores
        
    def decrease_score(self, points=1):
        """Decrease the current score."""
        self.current_score -= int(points)
        return self
        
    def increase_score(self, points=1):
        """Increase the current score."""
        self.current_score += int(points)
        return self
        
    def set_score(self, score):
        """Set the current score to a specific value."""
        self.current_score = int(score)
        return self
        
    def reset_score(self):
        """Reset the current score to zero."""
        self.current_score = 0
        return self
        
    def check_high_score(self):
        """Check if current score qualifies as a high score.
        
        Returns:
            int: Position (1-10) if high score, None if not
        """
        for i, entry in enumerate(self.high_scores):
            if self.current_score > entry['score']:
                return i + 1
        return None
        
    def add_high_score(self, name=None):
        """Add current score to high scores if it qualifies.
        
        Args:
            name (str): Player name (if None, will prompt user)
        
        Returns:
            bool: True if score was added, False if not
        """
        position = self.check_high_score()
        if position is None:
            return False
        
        # Get player name
        if name is None:
            # Import get_input here to avoid circular imports
            from .input import get_input
            name = get_input("New high score! Enter your name:", "Player")
            if name is None:  # User cancelled
                name = "Player"
        
        # Insert new score at correct position
        self.high_scores.insert(position - 1, {
            'name': name,
            'score': self.current_score
        })
    
        # Keep only top 10
        self.high_scores = self.high_scores[:10]
    
        # Save to config - try both methods for maximum compatibility
        try:
            # Try new method first
            for i, entry in enumerate(self.high_scores):
                self.config_service.local_config.set("scoreboard", f"score_{i+1}", str(entry['score']))
                self.config_service.local_config.set("scoreboard", f"name_{i+1}", entry['name'])
            
            # Try to write with config_service
            try:
                self.config_service.write_local_config()
            except Exception as e:
                # Fallback to old method if config_service fails
                for i, entry in enumerate(self.high_scores):
                    localConfig.set("scoreboard", f"score_{i+1}", str(entry['score']))
                    localConfig.set("scoreboard", f"name_{i+1}", entry['name'])
                write_config()
                
        except Exception as e:
            # If all else fails, try direct old method
            for i, entry in enumerate(self.high_scores):
                localConfig.set("scoreboard", f"score_{i+1}", str(entry['score']))
                localConfig.set("scoreboard", f"name_{i+1}", entry['name'])
            write_config()
        
        # Announce success
        try:
            self.speech.messagebox(f"Congratulations {name}! You got position {position} on the scoreboard!")
        except:
            # Fallback to global speak function
            from .speech import speak
            speak(f"Congratulations {name}! You got position {position} on the scoreboard!")
            
        time.sleep(1)
        return True