Distribution Platforms

Navigate the world of game distribution! Learn about Steam, itch.io, Epic Games Store, mobile app stores, and choose the right platform for your game! 🎮🚀🌍

🎯 Major Distribution Platforms

🎮 Publishing on Steam

Steamworks Integration

# steamworks.py - Steam API integration example
import sys
import os

# Steamworks API wrapper (using steamworks-py or similar)
try:
    import steamworks
except ImportError:
    print("Steamworks API not available")
    steamworks = None

class SteamIntegration:
    def __init__(self, app_id):
        self.app_id = app_id
        self.initialized = False
        self.client = None
        
    def initialize(self):
        """Initialize Steam API"""
        if not steamworks:
            print("Running without Steam")
            return False
        
        try:
            # Set Steam App ID
            os.environ['SteamAppId'] = str(self.app_id)
            
            # Initialize client
            self.client = steamworks.STEAMWORKS()
            self.client.initialize()
            self.initialized = True
            
            print(f"Steam initialized for App ID: {self.app_id}")
            return True
        except Exception as e:
            print(f"Failed to initialize Steam: {e}")
            return False
    
    def get_user_info(self):
        """Get current user information"""
        if not self.initialized:
            return None
        
        user = self.client.Users.GetLocalPlayer()
        return {
            'id': user.steam_id,
            'name': user.name,
            'level': user.level
        }
    
    def unlock_achievement(self, achievement_name):
        """Unlock a Steam achievement"""
        if not self.initialized:
            return False
        
        try:
            self.client.UserStats.SetAchievement(achievement_name)
            self.client.UserStats.StoreStats()
            print(f"Achievement unlocked: {achievement_name}")
            return True
        except Exception as e:
            print(f"Failed to unlock achievement: {e}")
            return False
    
    def set_rich_presence(self, key, value):
        """Set Steam Rich Presence"""
        if not self.initialized:
            return False
        
        try:
            self.client.Friends.SetRichPresence(key, value)
            return True
        except:
            return False
    
    def get_leaderboard(self, leaderboard_name, num_entries=10):
        """Get leaderboard entries"""
        if not self.initialized:
            return []
        
        try:
            leaderboard = self.client.UserStats.FindLeaderboard(leaderboard_name)
            entries = leaderboard.GetEntries(
                steamworks.LeaderboardDataRequest.Global,
                1, num_entries
            )
            
            return [{
                'rank': entry.rank,
                'score': entry.score,
                'user': entry.user_name
            } for entry in entries]
        except:
            return []
    
    def submit_score(self, leaderboard_name, score):
        """Submit score to leaderboard"""
        if not self.initialized:
            return False
        
        try:
            leaderboard = self.client.UserStats.FindLeaderboard(leaderboard_name)
            leaderboard.UploadScore(
                steamworks.LeaderboardUploadScoreMethod.KeepBest,
                score
            )
            return True
        except:
            return False
    
    def shutdown(self):
        """Shutdown Steam API"""
        if self.initialized and self.client:
            self.client.shutdown()
            self.initialized = False

# Steam App ID configuration
STEAM_APP_ID = 480  # Use 480 for testing (Spacewar)

# Usage in game
steam = SteamIntegration(STEAM_APP_ID)

if steam.initialize():
    # Get user info
    user = steam.get_user_info()
    if user:
        print(f"Welcome, {user['name']}!")
    
    # Set rich presence
    steam.set_rich_presence("status", "In Main Menu")
    
    # Unlock achievement
    steam.unlock_achievement("FIRST_LAUNCH")
    
    # Submit score
    steam.submit_score("HIGH_SCORES", 1000)

# Steamworks configuration file - steam_appid.txt
# Place in same directory as executable
# Contains only the App ID number: 480
        

Steam Store Page Requirements

• 📝 Game description (short and detailed)
• 🖼️ Capsule images (multiple sizes)
• 📸 At least 5 screenshots
• 🎬 Gameplay trailer (highly recommended)
• 🏷️ Tags and categories
• 💰 Pricing and regional settings
• 📅 Release date planning
• 🔞 Age rating (ESRB, PEGI, etc.)

🎨 Publishing on itch.io

Butler - Command Line Tool

# Install Butler
# Download from: https://itch.io/docs/butler/

# Login to itch.io
butler login

# Push your game build
butler push mygame-windows.zip username/game-name:windows

# Push with version number
butler push mygame-windows.zip username/game-name:windows --userversion 1.0.0

# Different platforms
butler push mygame-linux.tar.gz username/game-name:linux
butler push mygame-mac.zip username/game-name:mac

# Web build (HTML5)
butler push webgame/ username/game-name:html5

# Check status
butler status username/game-name
        

itch.io API Integration

import requests
import json

class ItchIOAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://itch.io/api/1"
        self.headers = {
            "Authorization": f"Bearer {api_key}"
        }
    
    def get_my_games(self):
        """Get list of your games"""
        response = requests.get(
            f"{self.base_url}/{self.api_key}/my-games",
            headers=self.headers
        )
        return response.json()
    
    def get_game_stats(self, game_id):
        """Get game statistics"""
        response = requests.get(
            f"{self.base_url}/game/{game_id}/stats",
            headers=self.headers
        )
        return response.json()
    
    def post_devlog(self, game_id, title, body, status="published"):
        """Post a devlog update"""
        data = {
            "title": title,
            "body": body,
            "status": status
        }
        response = requests.post(
            f"{self.base_url}/game/{game_id}/devlog",
            headers=self.headers,
            json=data
        )
        return response.json()

# Web embed for itch.io
HTML_TEMPLATE = '''

'''
        

📱 Google Play & App Store

Preparing for Mobile

# mobile_build.py - Mobile-specific configurations
import json
import os

class MobileBuildConfig:
    def __init__(self):
        self.config = {
            "android": {
                "package_name": "com.yourcompany.gamename",
                "version_code": 1,
                "version_name": "1.0.0",
                "min_sdk": 21,
                "target_sdk": 33,
                "permissions": [
                    "INTERNET",
                    "ACCESS_NETWORK_STATE"
                ],
                "features": [],
                "signing": {
                    "keystore": "release.keystore",
                    "key_alias": "release_key",
                    "store_password": os.environ.get("KEYSTORE_PASSWORD"),
                    "key_password": os.environ.get("KEY_PASSWORD")
                }
            },
            "ios": {
                "bundle_id": "com.yourcompany.gamename",
                "version": "1.0.0",
                "build": "1",
                "min_ios": "12.0",
                "device_capabilities": ["armv7"],
                "orientations": ["portrait", "landscape"],
                "info_plist": {
                    "CFBundleDisplayName": "Game Name",
                    "ITSAppUsesNonExemptEncryption": False,
                    "NSUserTrackingUsageDescription": "This app needs tracking for analytics"
                }
            }
        }
    
    def generate_android_manifest(self):
        """Generate AndroidManifest.xml content"""
        android = self.config["android"]
        
        manifest = f'''

    
    
    '''
        
        for permission in android['permissions']:
            manifest += f'\n    '
        
        manifest += '''
    
    
        
        
            
                
                
            
        
    
'''
        
        return manifest
    
    def generate_info_plist(self):
        """Generate Info.plist for iOS"""
        import plistlib
        
        ios = self.config["ios"]
        plist = {
            "CFBundleIdentifier": ios["bundle_id"],
            "CFBundleVersion": ios["build"],
            "CFBundleShortVersionString": ios["version"],
            "MinimumOSVersion": ios["min_ios"],
            "UIRequiredDeviceCapabilities": ios["device_capabilities"],
            "UISupportedInterfaceOrientations": ios["orientations"],
            **ios["info_plist"]
        }
        
        return plistlib.dumps(plist)

# App Store Connect API
class AppStoreConnect:
    def __init__(self, key_id, issuer_id, private_key_path):
        self.key_id = key_id
        self.issuer_id = issuer_id
        self.private_key = self.load_private_key(private_key_path)
        
    def create_jwt_token(self):
        """Create JWT for App Store Connect API"""
        import jwt
        import time
        
        header = {
            "alg": "ES256",
            "kid": self.key_id,
            "typ": "JWT"
        }
        
        payload = {
            "iss": self.issuer_id,
            "exp": int(time.time()) + 1200,  # 20 minutes
            "aud": "appstoreconnect-v1"
        }
        
        token = jwt.encode(payload, self.private_key, 
                          algorithm="ES256", headers=header)
        return token
    
    def upload_build(self, ipa_path):
        """Upload IPA to App Store Connect"""
        # Use altool or Transporter
        import subprocess
        
        cmd = [
            "xcrun", "altool",
            "--upload-app",
            "--type", "ios",
            "--file", ipa_path,
            "--apiKey", self.key_id,
            "--apiIssuer", self.issuer_id
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        return result.returncode == 0
        

🌐 Web-Based Games

Hosting Options

• GitHub Pages: Free, static hosting
• Netlify: Free tier with CI/CD
• Vercel: Optimized for web apps
• itch.io: Built-in web game support
• Game Portals: Kongregate, Newgrounds, Armor Games
• Your Own Server: Full control

Web Monetization

// Web Monetization API
if (document.monetization) {
    document.monetization.addEventListener('monetizationstart', () => {
        console.log('Payment started');
        // Unlock premium features
        unlockPremiumContent();
    });
}

// Ad Integration (example with AdSense)
function showAd() {
    const adContainer = document.getElementById('ad-container');
    adContainer.innerHTML = `
        
        
        
        
    `;
}

// In-App Purchases with Stripe
async function purchaseItem(itemId, price) {
    const response = await fetch('/api/create-payment-intent', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ itemId, price })
    });
    
    const { clientSecret } = await response.json();
    
    // Use Stripe.js to complete payment
    const result = await stripe.confirmCardPayment(clientSecret);
    
    if (result.error) {
        console.error(result.error);
    } else {
        // Payment successful
        unlockItem(itemId);
    }
}
        

📊 Choosing the Right Platform

🎯 Release Strategy Timeline

Platform Release Order

1. itch.io Alpha/Beta: Test with early adopters
2. Steam Early Access: Gather feedback, build wishlist
3. Full Steam/Epic Release: Main launch
4. Mobile Ports: Expand audience
5. Console Ports: If successful on PC

🔧 Integration Checklist

Steam Features

• ☑️ Achievements
• ☑️ Trading Cards
• ☑️ Cloud Saves
• ☑️ Workshop (mods)
• ☑️ Leaderboards
• ☑️ Rich Presence
• ☑️ Remote Play
• ☑️ Steam Deck verified

Mobile Features

• ☑️ Push Notifications
• ☑️ In-App Purchases
• ☑️ Ad Monetization
• ☑️ Game Center/Google Play Games
• ☑️ Cloud Save
• ☑️ Social Sharing
• ☑️ Analytics
• ☑️ Crash Reporting

✨ Distribution Best Practices

• Start Early: Set up store pages months before launch
• Cross-Promote: Use each platform to promote others
• Platform Features: Implement platform-specific features
• Regional Pricing: Research and set appropriate prices
• Localization: Translate store pages at minimum
• Reviews: Respond professionally to feedback
• Updates: Regular updates keep games visible
• Analytics: Track metrics across all platforms
• Community: Build platform-specific communities
• Compliance: Follow each platform's guidelines

• 🎮 Each platform has unique strengths and audiences
• 💰 Revenue splits vary significantly (12-30% platform cut)
• 🚀 itch.io is perfect for testing and building community
• 📊 Steam dominates PC gaming but has high competition
• 📱 Mobile requires different monetization strategies
• 🌐 Web games have lowest barrier to entry
• 🎯 Multi-platform releases maximize reach
• 🔧 Platform-specific features increase visibility