pokecenter fix (#126)

src/core/ChipAudio.lua

@@ -230,6 +230,25 @@ function ChipAudio.ensureMusicPlaying()
   end
 end
 
+-- Threaded playMusic returns an empty QueueableSource and only calls
+-- Source:play once the first worker buffer lands (~1 frame later).  Until
+-- then Source:isPlaying is false -- callers that treat that as "song over"
+-- (Music.oneShotPlaying / pendingRestore) must wait here instead, or a
+-- playOnce jingle like Music_PkmnHealed is cut off before it starts.
+local forceAwaitingFirstBuffer -- test-only override (see _simulate*)
+
+function ChipAudio.awaitingFirstBuffer()
+  if forceAwaitingFirstBuffer then return true end
+  local m = currentMusic
+  if not (m and m.threaded and not m.started and not m.finished) then
+    return false
+  end
+  -- a dead worker will never deliver the first buffer
+  if workerReady == false then return false end
+  if worker and worker.getError and worker:getError() then return false end
+  return true
+end
+
 function ChipAudio.stopMusic()
   if currentMusic and currentMusic.source then
     pcall(currentMusic.source.stop, currentMusic.source)
@@ -240,6 +259,7 @@ function ChipAudio.stopMusic()
   end
   pendingBuf = nil
   currentMusic = nil
+  forceAwaitingFirstBuffer = nil
 end
 
 -- hot reload: the next play re-reads programs.bin (a mod may have swapped the
@@ -302,6 +322,20 @@ end
 -- test hooks (headless): synchronous synthesis straight through ChipSynth
 -- ---------------------------------------------------------------------------
 
+-- Force the "threaded, first buffer not yet queued" window so Music's
+-- playOnce / pendingRestore race can be asserted without love.thread.
+-- Returns a clear() that drops the override (call after the assertion).
+function ChipAudio._simulateAwaitingFirstBufferForTest()
+  local m = currentMusic
+  if not m or not m.source then return nil end
+  m.threaded = true
+  m.started = false
+  m.finished = false
+  pcall(function() m.source.playing = false end)
+  forceAwaitingFirstBuffer = true
+  return function() forceAwaitingFirstBuffer = nil end
+end
+
 function ChipAudio._renderMusicForTest(data, header, seconds)
   local engine = ChipSynth.newEngine(data, header, { allowLoops = true })
   return ChipSynth.soundData(engine, math.floor(seconds * SAMPLE_RATE), 2)

src/core/Music.lua

@@ -254,6 +254,7 @@ function Music.stop()
   require("src.core.ChipAudio").stopMusic()
   state.current, state.source, state.loopSource, state.fade = nil, nil, nil, nil
   state.chip = false
+  state.pendingRestore = nil
   if previous and Runtime.wants("music.stopped") then
     Runtime.emit("music.stopped", { song = previous })
   end
@@ -347,14 +348,24 @@ end
 function Music.playOnce(data, song)
   if not songDef(data, song) then return false end
   Music.play(data, song, false, { reason = "once" })
+  -- play() can no-op (hook silence, failed def); only arm restore when
+  -- the jingle actually became current
+  if state.current ~= song then return false end
   state.pendingRestore = true
   return true
 end
 
+local function chipAwaitingFirstBuffer()
+  return state.chip
+     and require("src.core.ChipAudio").awaitingFirstBuffer()
+end
+
 -- is a playOnce jingle still sounding?  (AnimateHealingMachine's
 -- .waitLoop2 holds the healing machine until MUSIC_PKMN_HEALED ends)
 function Music.oneShotPlaying()
   if not state.pendingRestore then return false end
+  -- threaded chip songs start silent for ~1 frame; that gap is not "over"
+  if chipAwaitingFirstBuffer() then return true end
   local src = state.source
   if not src then return false end
   local ok, playing = pcall(src.isPlaying, src)
@@ -441,8 +452,10 @@ function Music.update(data)
     state.source = loopSrc
     pcall(loopSrc.play, loopSrc)
   end
+  -- do not treat "threaded source still waiting on its first buffer" as
+  -- ended, or playOnce jingles get restored over before they can sound
   if state.pendingRestore and sourceStopped(state.source)
-     and not state.loopSource then
+     and not state.loopSource and not chipAwaitingFirstBuffer() then
     Music.restoreMap(data)
   end
 end