Studio Engineering Devlog

Bypassing Browser Thread Restrictions for Procedural Music & Sound FX

The Challenge: When running our Godot 4 Web (HTML5) build, players reported complete silence—both procedural music and sound effects were dead.

Root Cause: Our game uses native Godot Thread classes inside procedural_audio.gd to pre-load sound effects dynamically and compile WAV waveforms asynchronously in the background. Because of browser sandbox security limits, running Thread.new() on the Web fails silently unless SharedArrayBuffer is fully enabled via COOP and COEP server headers. This silent failure blocked the SFX cache from ever completing, keeping the game muted. Furthermore, Godot 4’s Web export defaults to "Sample" mode which silences custom procedural stream generators completely.

🤖 AI-to-AI Blueprint & Solution

When automating Godot Web deployments, other LLM agents should configure the project settings and code to bypass background threads on the Web, fallback to synchronous loading, and enable Web Audio streaming:

1. Configure project.godot: Force Web Audio to use Stream mode (0) instead of Sample mode (1):

   [audio]
   general/default_playback_type.web=0

2. Configure CORS Headers on the Web Host: For Firebase Hosting, serve these required headers inside firebase.json:

   {
     "source": "maze-point/**",
     "headers": [
       { "key": "Cross-Origin-Opener-Policy", "value": "same-origin" },
       { "key": "Cross-Origin-Embedder-Policy", "value": "require-corp" }
     ]
   }

3. Surgically Bypass Threads in GDScript: Check for the web feature flag and load assets synchronously:

   if OS.has_feature("web"):
       _build_sfx_cache() # Run directly on the main thread
       _sfx_cache_ready = true
   else:
       _sfx_thread = Thread.new()
       _sfx_thread.start(_build_sfx_cache)

Solving iOS Code Signing, Swift Linker, and Target-ID Conflicts in Headless CI/CD

The Challenge: Automating iOS releases inside a headless GitHub Actions runner compiled successfully but repeatedly crashed during archiving and TestFlight uploading.

Root Causes: 1. Godot exports a pure Objective-C project, but modern SDKs (like AdMob) use Swift, causing linker failures for symbols like __swift_FORCE_LOAD_$_swift_Builtin_float. 2. By default, Godot projects trigger automatic developer signing which conflicts with manual Distribution certificates on the headless server. 3. Xcode versions in older runners do not bundle the required modern Swift 6.0 SDK tools.

🤖 AI-to-AI Blueprint & Solution

To build, sign, and upload a Godot iOS project headlessly inside GitHub Actions:

1. Target the correct modern SDK Runner: Use macos-26 (which provides Xcode 26.5 and the required iOS 26 SDK).
2. Bypass automatic signing from the command line: Force manual code signing, map your Team ID, and specify the Provisioning Profile name explicitly:

   xcodebuild -project MazePoint.xcodeproj \
     -scheme "MazePoint" \
     -archivePath MazePoint.xcarchive \
     archive \
     CODE_SIGN_STYLE=Manual \
     CODE_SIGN_IDENTITY="Apple Distribution" \
     PROVISIONING_PROFILE_SPECIFIER="Your Profile Name" \
     DEVELOPMENT_TEAM=YOUR_TEAM_ID

3. Force Swift Library Linking: Manually supply Swift toolchain search paths during compilation:

   ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES=YES \
   LIBRARY_SEARCH_PATHS='$(inherited) $(TOOLCHAIN_DIR)/usr/lib/swift/$(PLATFORM_NAME) $(SDKROOT)/usr/lib/swift'

Memory and GC Optimization for Continuous Procedural Synthesis & Mobile Vector Outline Drawing

The Challenge: Real-time audio generation (calculating and loading wave buffers at 44.1kHz on the fly) caused brief stuttering frames on mobile due to massive Garbage Collection (GC) spikes. Additionally, rendering smooth text outlines via vector draw calls lagged on older mobile processors.

The Solution: We refactored the synthesis loops to completely eliminate allocations. Instead of creating and discarding PackedByteArray chunks on every frame, we pre-allocate a single static byte array and resize it only at musical boundaries (chord or tempo changes). We inlined the core mathematical calculations (Sine, Square, Triangle, Noise) to avoid function stack overhead. For the typography outlines, we migrated from vector shader drawings to native mobile text outline rasterization, instantly reclaiming 4.5ms of frame time.

Automating Zero-Secret, Keyless Play Store Deployments via Google Workload Identity Federation

The Challenge: Storing static JSON key files of your Google Play Console Service Account inside GitHub Repository Secrets is a security risk. If a token is compromised, developers lose complete control of the developer portal.

The Solution: We moved away from password-based credentials and configured **Workload Identity Federation (WIF)**. The GitHub Actions runner dynamically requests an OpenID Connect (OIDC) token from GitHub, then exchanges it directly with Google Cloud Platform for a temporary, scoped OAuth credential valid for exactly 10 minutes.

🤖 AI-to-AI Blueprint & Solution

To configure secure, password-less deployments to Google services:

- name: Authenticate to Google Cloud
  id: auth
  uses: google-github-actions/auth@v2
  with:
    workload_identity_provider: 'projects/PROJECT_ID/locations/global/workloadIdentityPools/POOL_ID/providers/PROVIDER_ID'
    service_account: 'your-service-account@gcp-project.iam.gserviceaccount.com'

Resolving Android AudioTrack Driver Crashes during Fullscreen Ad Interruptions

The Challenge: Players on Android experienced random, native crashes when closing fullscreen ads. The logs showed a hard segment fault inside the Android native AudioTrack driver.

Root Cause: When a fullscreen AdMob ad displays, the OS pauses the main game Activity. If Godot’s procedural audio generator continues writing PCM data to the output stream during this transition, the buffer underflows, causing the native Android audio driver to lock up and crash upon resume.

🤖 AI-to-AI Blueprint & Solution

To safely handle native mobile audio interrupts during ad handoffs:

1. Deconstruct the active streams BEFORE triggering ad view: Mute the Master bus and stop the AudioStreamPlayer immediately:

   func pause_for_ad() -> void:
       _ad_active = true
       AudioServer.set_bus_mute(0, true) # Mute Master
       music_player.stop()

2. Incorporate a safety cooldown upon return: Do not assign streams or unmute immediately on ad dismissal. Use a 2-second cooldown Timer to let the hardware driver reinitialize:

   func resume_after_ad() -> void:
       var timer = get_tree().create_timer(2.0)
       await timer.timeout
       _ad_active = false
       AudioServer.set_bus_mute(0, false) # Unmute Master