Code_of_Conquest/godot_client/docs/EXPORT.md

Export Configuration Guide

Overview

Code of Conquest targets multiple platforms:

• Desktop: Windows, macOS, Linux
• Mobile: Android, iOS
• Web: HTML5/WebAssembly

Each platform requires specific configuration in Godot's export system.

Prerequisites

1. Install Export Templates

In Godot Editor:

1. Editor → Manage Export Templates
2. Click "Download and Install"
3. Wait for templates to download (~300-500 MB)

Alternatively, download manually from Godot downloads.

2. Platform-Specific Requirements

Windows

• Template: Included by default
• Optional: Custom icon (.ico file)
• Optional: Code signing certificate for production

macOS

• Template: Included by default
• Requirements (for distribution):
  • macOS machine for final build
  • Apple Developer account ($99/year)
  • Code signing certificate
  • Notarization for Gatekeeper

Linux

• Template: Included by default
• Note: Export on Linux for best results
• Distribution: AppImage, Flatpak, or raw binary

Android

• Android SDK: API level 33+ (Android 13)

  • Download via Android Studio or command-line tools
  • Set path in Godot: Editor → Editor Settings → Export → Android → SDK Path

• Java JDK: Version 17 or later

• Keystore for Signing:

  keytool -genkey -v -keystore code_of_conquest.keystore \
    -alias coc_key -keyalg RSA -keysize 2048 -validity 10000
  

• Package Name: com.codeofconquest.game

iOS

• Requirements:

  • macOS with Xcode installed
  • Apple Developer account ($99/year)
  • Provisioning profile
  • Code signing certificate

• Bundle ID: com.codeofconquest.game

• Export Process:

  1. Export Xcode project from Godot
  2. Open in Xcode
  3. Configure signing
  4. Build for device or App Store

Web (HTML5)

• Template: Included by default

• Server Requirements:

  • HTTPS (for SharedArrayBuffer support)
  • CORS headers for cross-origin resources
  • Proper MIME types for .wasm files

• PWA Configuration (optional):

  • Manifest file for installability
  • Service worker for offline support
  • Icons in multiple sizes

Configuration Steps

Step 1: Open Export Window

In Godot:

1. Project → Export
2. Click "Add..." to add a new preset

Step 2: Configure Each Platform

Windows Export

1. Add → Windows Desktop

2. Configure:

   • Executable Name: CodeOfConquest.exe
   • Export Path: builds/windows/CodeOfConquest.exe
   • Icon: assets/ui/icon.ico (optional)
   • Embed PCK: true (for single-file distribution)

3. Features:

   • 64-bit: Recommended for modern systems
   • 32-bit: Optional for older systems

Linux Export

1. Add → Linux/X11

2. Configure:

   • Executable Name: CodeOfConquest.x86_64
   • Export Path: builds/linux/CodeOfConquest.x86_64
   • Embed PCK: true

3. After export, set executable permissions:

   chmod +x CodeOfConquest.x86_64
   

macOS Export

1. Add → macOS

2. Configure:

   • App Name: Code of Conquest
   • Bundle ID: com.codeofconquest.game
   • Export Path: builds/macos/CodeOfConquest.dmg
   • Icon: assets/ui/icon.icns (optional)

3. For distribution:

   • Set code signing identity
   • Enable hardened runtime
   • Enable notarization

Android Export

1. Add → Android

2. Configure:

   • Package Name: com.codeofconquest.game
   • Version Code: 1 (increment for each release)
   • Version Name: 0.1.0
   • Min SDK: 21 (Android 5.0)
   • Target SDK: 33 (Android 13)

3. Keystore:

   • Debug Keystore: Auto-generated (for testing)
   • Release Keystore: Path to your .keystore file
   • Release User: Keystore alias (e.g., coc_key)
   • Release Password: Your keystore password

4. Permissions (add in export preset):

   • INTERNET - Required for API calls
   • ACCESS_NETWORK_STATE - Check connectivity

5. Screen Orientation:

   • Landscape or Portrait (choose based on game design)

6. Graphics:

   • Renderer: GL Compatibility (best mobile support)

7. Export:

   • APK: For direct installation/testing
   • AAB (Android App Bundle): For Google Play Store

iOS Export

1. Add → iOS

2. Configure:

   • Bundle ID: com.codeofconquest.game
   • Version: 0.1.0
   • Icon: Multiple sizes required (see Xcode)
   • Orientation: Landscape or Portrait

3. Provisioning:

   • Team ID: From Apple Developer account
   • Provisioning Profile: Development or Distribution

4. Export:

   • Export as Xcode project
   • Open in Xcode for final build

5. Capabilities (configure in Xcode):

   • Network requests
   • Push notifications (if needed later)

Web Export

1. Add → HTML5

2. Configure:

   • Export Path: builds/web/index.html
   • Export Type: Regular or PWA
   • Head Include: Custom HTML header (optional)

3. Features:

   • Thread Support: Enable for better performance (requires COOP/COEP headers)
   • SharedArrayBuffer: Requires HTTPS + specific headers

4. Server Configuration:

   • Must serve with proper MIME types:
     • .wasm: application/wasm
     • .pck: application/octet-stream

5. CORS Headers (for threaded builds):

   Cross-Origin-Opener-Policy: same-origin
   Cross-Origin-Embedder-Policy: require-corp
   

6. PWA Manifest (optional):

   {
     "name": "Code of Conquest",
     "short_name": "CoC",
     "start_url": ".",
     "display": "standalone",
     "background_color": "#1a1a2e",
     "theme_color": "#d4af37",
     "icons": [...]
   }
   

Testing Exports

Desktop Testing

1. Export to local directory
2. Run executable directly
3. Test with backend running on localhost
4. Verify:
   • Window sizing and fullscreen
   • Keyboard/mouse input
   • API connectivity
   • Save/load functionality

Mobile Testing

Android

1. Enable USB debugging on device

2. Connect via USB

3. Use adb install to install APK:

   adb install builds/android/CodeOfConquest.apk
   

4. Or export to device directly from Godot (Debug → Deploy)

5. Verify:

   • Touch input responsiveness
   • Screen orientation
   • Battery usage
   • Network connectivity
   • Permissions granted

iOS

1. Configure development provisioning
2. Export Xcode project
3. Open in Xcode
4. Build to connected device
5. Verify same as Android

Web Testing

1. Export to directory
2. Serve locally:

   python3 -m http.server 8000
   

3. Open http://localhost:8000 in browser
4. Verify:
   • Loading performance
   • Browser compatibility (Chrome, Firefox, Safari)
   • WebGL rendering
   • Network requests
   • Mobile browser (responsive)

Distribution

Desktop

Windows:

• Distribute .exe directly
• Or create installer (e.g., Inno Setup, NSIS)
• Upload to Steam, itch.io, etc.

macOS:

• Create .dmg for distribution
• Notarize for Gatekeeper
• Upload to Mac App Store or direct download

Linux:

• Raw binary
• AppImage (self-contained)
• Flatpak (Flathub distribution)
• Snap package

Mobile

Android:

• Google Play Store (requires AAB)
• Amazon Appstore
• F-Droid (open source)
• Direct APK download (sideloading)

iOS:

• App Store (requires App Store Connect)
• TestFlight (beta testing)
• Enterprise distribution (if applicable)

Web

Hosting Options:

• Static hosting: Netlify, Vercel, GitHub Pages
• CDN: Cloudflare, AWS S3 + CloudFront
• Game platforms: itch.io (supports HTML5)

Deployment:

1. Export web build
2. Upload all files (index.html, .wasm, .pck, etc.)
3. Configure COOP/COEP headers if using threads
4. Test on production URL

Performance Optimization

General

• Use compressed textures (ETC2 for mobile, S3TC for desktop)
• Minimize draw calls
• Use LOD (Level of Detail) for 3D
• Profile with Godot profiler

Mobile Specific

• Reduce resolution for lower-end devices
• Limit particle effects
• Use simpler shaders
• Test on low-end devices
• Monitor battery usage

Web Specific

• Optimize asset sizes (compress images, audio)
• Use progressive loading for large assets
• Minimize WASM binary size
• Cache assets with service worker

Platform-Specific Considerations

Windows

• Antivirus may flag unsigned executables
• Consider code signing for production
• Test on Windows 10 and 11

macOS

• Gatekeeper will block unsigned apps
• Notarization required for distribution
• Test on both Intel and Apple Silicon (M1/M2)

Linux

• Provide both 32-bit and 64-bit builds
• Test on multiple distros (Ubuntu, Fedora, Arch)
• Include library dependencies or use static linking

Android

• Target latest API level for Play Store
• Test on multiple screen sizes and densities
• Handle back button properly
• Support safe areas (notches, rounded corners)

iOS

• Follow Apple Human Interface Guidelines
• Support safe areas
• Handle app lifecycle (background/foreground)
• Test on multiple devices (iPhone, iPad)

Web

• Fallback for browsers without WebGL
• Loading screen for asset downloads
• Handle browser resize events
• Support both desktop and mobile browsers

Troubleshooting

"Missing export template"

→ Download templates via Editor → Manage Export Templates

"Android SDK not found"

→ Set SDK path in Editor Settings → Export → Android

"Code signing failed" (macOS/iOS)

→ Verify certificate and provisioning profile

"Web build won't load"

→ Check browser console, verify MIME types, check CORS

"App crashes on mobile"

→ Check device logs (adb logcat for Android, Xcode console for iOS)

Resources

• Godot Export Documentation
• Android Publishing Guide
• iOS App Distribution
• PWA Documentation

Automation (Future)

Consider automating builds with CI/CD:

• GitHub Actions
• GitLab CI
• Jenkins

Example workflow:

1. Commit to main branch
2. Trigger automated export for all platforms
3. Run automated tests
4. Upload builds to distribution channels
5. Tag release with version number