Performance Optimization

Transform your game from prototype to polished product! Learn profiling techniques, identify bottlenecks, optimize rendering, manage memory efficiently, and deliver smooth gameplay! 🚀⚡🎮

🎯 Performance Metrics

Key metrics to monitor and optimize:

• Frame Rate (FPS): Target 60 FPS for smooth gameplay
• Frame Time: Time to render one frame (16.67ms for 60 FPS)
• Memory Usage: RAM consumption and allocation patterns
• CPU Usage: Processing load and bottlenecks
• GPU Usage: Graphics rendering efficiency
• Load Times: Asset loading and level transitions
• Battery Life: Power consumption on mobile devices

📊 Python Profiling Tools

import cProfile
import pstats
import pygame
import time
from memory_profiler import profile
import tracemalloc

# Basic FPS counter
class FPSCounter:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.fps_history = []
        self.frame_times = []
        
    def tick(self, target_fps=60):
        dt = self.clock.tick(target_fps)
        current_fps = self.clock.get_fps()
        self.fps_history.append(current_fps)
        self.frame_times.append(dt)
        
        # Keep only last 60 frames
        if len(self.fps_history) > 60:
            self.fps_history.pop(0)
            self.frame_times.pop(0)
        
        return dt / 1000.0  # Return delta time in seconds
    
    def get_average_fps(self):
        if self.fps_history:
            return sum(self.fps_history) / len(self.fps_history)
        return 0
    
    def get_frame_time_stats(self):
        if not self.frame_times:
            return {}
        
        return {
            'min': min(self.frame_times),
            'max': max(self.frame_times),
            'avg': sum(self.frame_times) / len(self.frame_times)
        }

# CPU Profiling
def profile_game_loop():
    profiler = cProfile.Profile()
    profiler.enable()
    
    # Run your game loop here
    for _ in range(1000):
        update_game()
        render_game()
    
    profiler.disable()
    stats = pstats.Stats(profiler)
    stats.sort_stats('cumulative')
    stats.print_stats(20)  # Print top 20 functions

# Memory profiling decorator
@profile
def memory_intensive_function():
    large_list = [i for i in range(1000000)]
    return large_list

# Memory tracking
def track_memory_usage():
    tracemalloc.start()
    
    # Your code here
    snapshot1 = tracemalloc.take_snapshot()
    
    # More code
    snapshot2 = tracemalloc.take_snapshot()
    
    top_stats = snapshot2.compare_to(snapshot1, 'lineno')
    for stat in top_stats[:10]:
        print(stat)
        

⚡ Algorithm Optimization

# Bad: O(n²) collision detection
def check_collisions_naive(objects):
    collisions = []
    for i, obj1 in enumerate(objects):
        for j, obj2 in enumerate(objects[i+1:], i+1):
            if obj1.collides_with(obj2):
                collisions.append((obj1, obj2))
    return collisions

# Good: Spatial hashing O(n)
class SpatialHash:
    def __init__(self, cell_size):
        self.cell_size = cell_size
        self.buckets = {}
    
    def clear(self):
        self.buckets.clear()
    
    def add(self, obj):
        bucket_key = self._get_bucket_key(obj.x, obj.y)
        if bucket_key not in self.buckets:
            self.buckets[bucket_key] = []
        self.buckets[bucket_key].append(obj)
    
    def _get_bucket_key(self, x, y):
        return (int(x // self.cell_size), int(y // self.cell_size))
    
    def get_nearby(self, obj, radius=1):
        nearby = []
        cx, cy = self._get_bucket_key(obj.x, obj.y)
        
        for dx in range(-radius, radius + 1):
            for dy in range(-radius, radius + 1):
                bucket_key = (cx + dx, cy + dy)
                if bucket_key in self.buckets:
                    nearby.extend(self.buckets[bucket_key])
        
        return nearby
    
    def check_collisions(self, objects):
        self.clear()
        for obj in objects:
            self.add(obj)
        
        collisions = set()
        for obj in objects:
            nearby = self.get_nearby(obj)
            for other in nearby:
                if obj != other and obj.collides_with(other):
                    # Use frozenset to avoid duplicate pairs
                    collisions.add(frozenset([obj, other]))
        
        return list(collisions)

# Object pooling to reduce allocations
class ObjectPool:
    def __init__(self, object_class, size=100):
        self.object_class = object_class
        self.available = [object_class() for _ in range(size)]
        self.active = []
    
    def acquire(self):
        if self.available:
            obj = self.available.pop()
            self.active.append(obj)
            return obj
        else:
            # Pool exhausted, create new object
            obj = self.object_class()
            self.active.append(obj)
            return obj
    
    def release(self, obj):
        if obj in self.active:
            self.active.remove(obj)
            self.available.append(obj)
            obj.reset()  # Reset object state

# Cache expensive calculations
class MemoizedFunction:
    def __init__(self, func):
        self.func = func
        self.cache = {}
    
    def __call__(self, *args):
        if args not in self.cache:
            self.cache[args] = self.func(*args)
        return self.cache[args]

@MemoizedFunction
def expensive_calculation(x, y):
    # Simulate expensive operation
    import math
    return math.sqrt(x**2 + y**2) * math.sin(x) * math.cos(y)
        

🎨 Graphics Performance

import pygame

class RenderOptimizer:
    def __init__(self, screen):
        self.screen = screen
        self.dirty_rects = []
        self.static_background = None
        
    def create_static_background(self, render_func):
        """Pre-render static elements"""
        self.static_background = pygame.Surface(self.screen.get_size())
        render_func(self.static_background)
    
    def add_dirty_rect(self, rect):
        """Mark area for redraw"""
        self.dirty_rects.append(rect)
    
    def optimize_dirty_rects(self):
        """Merge overlapping rectangles"""
        if not self.dirty_rects:
            return []
        
        # Sort by position
        self.dirty_rects.sort(key=lambda r: (r.x, r.y))
        
        optimized = []
        current = self.dirty_rects[0]
        
        for rect in self.dirty_rects[1:]:
            if current.colliderect(rect):
                # Merge rectangles
                current = current.union(rect)
            else:
                optimized.append(current)
                current = rect
        
        optimized.append(current)
        self.dirty_rects = []
        return optimized
    
    def render_frame(self, dynamic_objects):
        """Optimized rendering with dirty rectangles"""
        # Clear only dirty areas
        for rect in self.dirty_rects:
            if self.static_background:
                self.screen.blit(self.static_background, rect, rect)
            else:
                pygame.draw.rect(self.screen, (0, 0, 0), rect)
        
        # Draw only visible objects
        screen_rect = self.screen.get_rect()
        for obj in dynamic_objects:
            if screen_rect.colliderect(obj.rect):
                obj.draw(self.screen)
                self.add_dirty_rect(obj.rect)
        
        # Update only changed areas
        dirty_rects = self.optimize_dirty_rects()
        pygame.display.update(dirty_rects)

# Sprite batching
class SpriteBatch:
    def __init__(self):
        self.sprites = {}
    
    def add(self, texture_path, positions):
        """Group sprites by texture"""
        if texture_path not in self.sprites:
            self.sprites[texture_path] = {
                'texture': pygame.image.load(texture_path).convert_alpha(),
                'positions': []
            }
        self.sprites[texture_path]['positions'].extend(positions)
    
    def draw(self, screen):
        """Draw all sprites grouped by texture"""
        for texture_data in self.sprites.values():
            texture = texture_data['texture']
            for pos in texture_data['positions']:
                screen.blit(texture, pos)
    
    def clear(self):
        """Clear batch for next frame"""
        for texture_data in self.sprites.values():
            texture_data['positions'].clear()

# Level of Detail (LOD) system
class LODSprite(pygame.sprite.Sprite):
    def __init__(self, textures_by_distance):
        super().__init__()
        self.textures = textures_by_distance  # {distance: texture}
        self.distances = sorted(textures_by_distance.keys())
        self.current_texture = None
        self.rect = None
    
    def update_lod(self, camera_pos):
        """Switch texture based on distance"""
        distance = self.get_distance_to(camera_pos)
        
        for max_dist in self.distances:
            if distance <= max_dist:
                new_texture = self.textures[max_dist]
                if new_texture != self.current_texture:
                    self.current_texture = new_texture
                    self.image = new_texture
                    if self.rect:
                        self.rect = self.image.get_rect(center=self.rect.center)
                break
    
    def get_distance_to(self, pos):
        if self.rect:
            return ((self.rect.centerx - pos[0])**2 + 
                   (self.rect.centery - pos[1])**2)**0.5
        return 0

# Frustum culling
class FrustumCuller:
    def __init__(self, screen_rect):
        self.screen_rect = screen_rect
        self.margin = 50  # Extra margin for smooth transitions
    
    def is_visible(self, obj_rect):
        """Check if object is in view frustum"""
        expanded_rect = self.screen_rect.inflate(self.margin * 2, self.margin * 2)
        return expanded_rect.colliderect(obj_rect)
    
    def cull_objects(self, objects):
        """Return only visible objects"""
        return [obj for obj in objects if self.is_visible(obj.rect)]
        

📦 Optimizing Game Assets

import pygame
import os
from PIL import Image
import numpy as np

class AssetOptimizer:
    def __init__(self):
        self.texture_cache = {}
        self.sound_cache = {}
        
    def optimize_image(self, path, max_size=(1024, 1024), quality=85):
        """Optimize image file size and dimensions"""
        img = Image.open(path)
        
        # Resize if too large
        if img.size[0] > max_size[0] or img.size[1] > max_size[1]:
            img.thumbnail(max_size, Image.Resampling.LANCZOS)
        
        # Convert to RGB if RGBA not needed
        if img.mode == 'RGBA':
            # Check if alpha channel is used
            alpha = np.array(img.split()[-1])
            if np.all(alpha == 255):
                img = img.convert('RGB')
        
        # Save optimized version
        optimized_path = path.replace('.png', '_opt.png')
        img.save(optimized_path, optimize=True, quality=quality)
        return optimized_path
    
    def create_texture_atlas(self, image_paths, atlas_size=(2048, 2048)):
        """Combine multiple textures into one atlas"""
        atlas = Image.new('RGBA', atlas_size, (0, 0, 0, 0))
        positions = {}
        
        current_x = 0
        current_y = 0
        row_height = 0
        
        for path in image_paths:
            img = Image.open(path)
            
            # Check if image fits in current row
            if current_x + img.width > atlas_size[0]:
                current_x = 0
                current_y += row_height
                row_height = 0
            
            # Check if image fits in atlas
            if current_y + img.height <= atlas_size[1]:
                atlas.paste(img, (current_x, current_y))
                positions[path] = (current_x, current_y, img.width, img.height)
                
                current_x += img.width
                row_height = max(row_height, img.height)
        
        return atlas, positions
    
    def load_texture_cached(self, path, convert_alpha=True):
        """Load texture with caching"""
        if path not in self.texture_cache:
            texture = pygame.image.load(path)
            if convert_alpha:
                texture = texture.convert_alpha()
            else:
                texture = texture.convert()
            self.texture_cache[path] = texture
        
        return self.texture_cache[path]
    
    def preload_assets(self, asset_list):
        """Preload all assets during loading screen"""
        for asset_path in asset_list:
            if asset_path.endswith(('.png', '.jpg', '.jpeg')):
                self.load_texture_cached(asset_path)
            elif asset_path.endswith(('.wav', '.ogg', '.mp3')):
                self.load_sound_cached(asset_path)
    
    def load_sound_cached(self, path):
        """Load sound with caching"""
        if path not in self.sound_cache:
            self.sound_cache[path] = pygame.mixer.Sound(path)
        return self.sound_cache[path]
    
    def compress_save_data(self, data):
        """Compress save game data"""
        import zlib
        import pickle
        
        serialized = pickle.dumps(data)
        compressed = zlib.compress(serialized, level=9)
        
        # Calculate compression ratio
        ratio = len(compressed) / len(serialized)
        print(f"Compression ratio: {ratio:.2%}")
        
        return compressed
    
    def decompress_save_data(self, compressed_data):
        """Decompress save game data"""
        import zlib
        import pickle
        
        decompressed = zlib.decompress(compressed_data)
        return pickle.loads(decompressed)

# Lazy loading for large assets
class LazyLoader:
    def __init__(self):
        self.pending = {}
        self.loaded = {}
    
    def queue_load(self, key, loader_func, *args):
        """Queue asset for loading"""
        self.pending[key] = (loader_func, args)
    
    def load_next(self):
        """Load one asset from queue"""
        if self.pending:
            key, (loader_func, args) = self.pending.popitem()
            self.loaded[key] = loader_func(*args)
            return key
        return None
    
    def get(self, key):
        """Get loaded asset or None"""
        return self.loaded.get(key)
    
    def is_loaded(self, key):
        """Check if asset is loaded"""
        return key in self.loaded
        

💾 Memory Optimization Strategies

• Object Pooling: Reuse objects instead of creating new ones
• Lazy Loading: Load assets only when needed
• Texture Atlases: Combine small textures into larger ones
• Asset Streaming: Load/unload assets based on proximity
• Reference Counting: Track and clean up unused resources
• Garbage Collection: Minimize allocations in hot paths

🎯 Target Platform Considerations

Desktop (Windows/Mac/Linux)

• Higher memory limits (2-4GB typical)
• Multi-core CPU utilization
• Dedicated GPU support
• Higher resolution textures

Mobile (iOS/Android)

• Limited memory (1-2GB)
• Battery optimization critical
• Touch input latency
• Thermal throttling

Web (Browser)

• JavaScript performance constraints
• Download size optimization
• Progressive loading
• WebGL limitations

✅ Testing Your Optimizations

• ☐ Profile on minimum spec hardware
• ☐ Test with maximum entities/effects
• ☐ Monitor memory usage over time
• ☐ Check for memory leaks
• ☐ Verify stable frame rate
• ☐ Test loading times
• ☐ Validate asset compression
• ☐ Profile network usage (multiplayer)
• ☐ Test on all target platforms
• ☐ Stress test with automated bots

🌟 Performance Best Practices

• Profile First: Always measure before optimizing
• Optimize Hotspots: Focus on the 20% of code that uses 80% of time
• Cache Everything: Avoid repeated calculations
• Batch Operations: Group similar operations together
• Use Appropriate Data Structures: Choose the right tool for the job
• Minimize Draw Calls: Batch rendering operations
• Reduce Texture Switches: Use texture atlases
• Cull Aggressively: Don't process what isn't visible
• LOD Systems: Use simpler assets for distant objects
• Async Loading: Never block the main thread

• 📊 Always profile before optimizing
• ⚡ Focus on algorithmic improvements first
• 💾 Manage memory carefully to avoid leaks
• 🎨 Optimize rendering with batching and culling
• 📦 Compress and optimize assets appropriately
• 🎯 Target platform capabilities matter
• 🔄 Use object pooling for frequently created objects
• 📈 Monitor performance metrics continuously