Rpg Maker Developers Group

/*:
 * @target MZ
 * @help Free to use and/or modify for any project.
 */

(function(alias) {
'use strict';

    let isActive = true;

    const getAudioContext = function() {
        return WebAudio._context;
    };

    const pauseAudio = function(context, active) {
        if (active) context.resume();
        else        context.suspend();
    };

    const updateActive = function() {
        pauseAudio(getAudioContext(), isActive);
    };

    SceneManager.updateScene = function() {
        const active = this.isGameActive();
        if (isActive !== active) {
            isActive = active;
            updateActive();
        }
        alias.apply(this, arguments);
    };

})(SceneManager.updateScene);

/*:
 * @target MZ
 * @help Free to use and/or modify for any project.
 */

(function(alias) {
'use strict';

    let isActive = true;

    const getAudioContext = function() {
        return WebAudio._context;
    };

    const getEffekseerHandles = function() {
        return (SceneManager._scene._spriteset?._animationSprites || [])
                .map(s => s._handle)
                .filter(h => h);
    };

    const pauseAudio = function(context, active) {
        if (active) context.resume();
        else        context.suspend();
    };

    const pauseEffekseer = function(handles, active) {
        handles.forEach(h => h.setPaused(!active));
    };

    const updateActive = function() {
        pauseAudio(getAudioContext(), isActive);
        pauseEffekseer(getEffekseerHandles(), isActive);
    };

    SceneManager.updateScene = function() {
        const active = this.isGameActive();
        if (isActive !== active) {
            isActive = active;
            updateActive();
        }
        alias.apply(this, arguments);
    };

})(SceneManager.updateScene);

/*:
 * @target MZ
 * @plugindesc Pause/resume audio (and Effekseer) with the game loop.
 * @author Caethyril
 * @url https://forums.rpgmakerweb.com/index.php?threads/141642/
 * @help Free to use and/or modify for any project. No credit required.
 */

(() => {
'use strict';

    let isActive = true;

    const SHOULD_LOOP = Symbol();

    const getEffekseerHandles = function() {
        return (SceneManager._scene._spriteset?._animationSprites || [])
                .map(s => s._handle)
                .filter(h => h);
    };

    const pauseEffekseer = function(handles, active) {
        handles.forEach(h => h.setPaused(!active));
    };

    const getAudioContext = function() {
        return WebAudio._context;
    };

    const pauseAudio = function(context, active) {
        if (active) context.resume();
        else        context.suspend();
    };

    const updateActive = function() {
        if (true)
            // 1.4.4 core script does not pause audio
            pauseAudio(getAudioContext(), isActive);
        if (!Utils.checkRMVersion("1.4.0"))
            // apply for pre-1.4.0 core script only
            pauseEffekseer(getEffekseerHandles(), isActive);
    };

    const onAudioEnd = function(index) {
        if (this[SHOULD_LOOP]) {
            // This is the original onended event handler, for encrypted audio loops.
            this._createSourceNode(index);
            this._startSourceNode(index);
        } else {
            // This replaces the original setTimeout method
            // so that end timers trigger when they are supposed to.
            const endTime = this._startTime + this._totalTime / this._pitch;
            if (WebAudio._currentTime() >= endTime)
                this.stop();
        }
    };

    // Also update the audio's "active" status.
    const alias = SceneManager.updateScene;
    SceneManager.updateScene = function() {
        const active = this.isGameActive();
        if (isActive !== active) {
            isActive = active;
            updateActive();
        }
        alias.apply(this, arguments);
    };

    // Assign "onended" event handler to onAudioEnd (see above).
    // A new flag (SHOULD_LOOP symbol) is set for looped encrypted audio.
    // This flag determines the behaviour of onAudioEnd.
    WebAudio.prototype._startSourceNode = function(index) {
        delete this[SHOULD_LOOP];                                   // <- edit 1 of 3
        const sourceNode = this._sourceNodes[index];
        const seekPos = this.seek();
        const currentTime = WebAudio._currentTime();
        const loop = this._loop;
        const loopStart = this._loopStartTime;
        const loopLength = this._loopLengthTime;
        const loopEnd = loopStart + loopLength;
        const pitch = this._pitch;
        let chunkStart = 0;
        for (let i = 0; i < index; i++) {
            chunkStart += this._buffers[i].duration;
        }
        const chunkEnd = chunkStart + sourceNode.buffer.duration;
        let when = 0;
        let offset = 0;
        let duration = sourceNode.buffer.duration;
        if (seekPos >= chunkStart && seekPos < chunkEnd - 0.01) {
            when = currentTime;
            offset = seekPos - chunkStart;
        } else {
            when = currentTime + (chunkStart - seekPos) / pitch;
            offset = 0;
            if (loop) {
                if (when < currentTime - 0.01) {
                    when += loopLength / pitch;
                }
                if (seekPos >= loopStart && chunkStart < loopStart) {
                    when += (loopStart - chunkStart) / pitch;
                    offset = loopStart - chunkStart;
                }
            }
        }
        if (loop && loopEnd < chunkEnd) {
            duration = loopEnd - chunkStart - offset;
        }
        if (this._shouldUseDecoder()) {
            if (when >= currentTime && offset < duration) {
                sourceNode.loop = false;
                sourceNode.start(when, offset, duration);
                if (loop && chunkEnd > loopStart) {
                    this[SHOULD_LOOP] = true;                       // <- edit 2 of 3
                    sourceNode.onended = onAudioEnd.bind(this);     // <- edit 3 of 3
                }
            }
        } else {
            if (when >= currentTime && offset < sourceNode.buffer.duration) {
                sourceNode.start(when, offset);
            }
        }
        chunkStart += sourceNode.buffer.duration;
    };
    
    // Rewritten: end timer now fires via "onended" event.
    // This allows it to respect AudioContext timing changes, e.g. pause/resume.
    WebAudio.prototype._createEndTimer = function() {
        if (!this._loop)
            // (Note to self: multiple source nodes are used for encrypted audio.)
            this._sourceNodes.forEach((source, n) => {
                source.onended = onAudioEnd.bind(this, n);
            }, this);
        // original:
        // if (this._sourceNodes.length > 0 && !this._loop) {
        //     const endTime = this._startTime + this._totalTime / this._pitch;
        //     const delay = endTime - WebAudio._currentTime();
        //     this._endTimer = setTimeout(this.stop.bind(this), delay * 1000);
        // }
    };

})();

/*:
 * @target MZ
 * @plugindesc v1.1 - Pause/resume audio (and video/Effekseer) with the game loop.
 * @author Caethyril
 * @url https://forums.rpgmakerweb.com/threads/141642/
 * @help Free to use and/or modify for any RMMZ project. No credit required.
 *
 * Update log:
 *   2024-05-20: now accounts for minimise/maximise.
 *               now also affects video.
 *               tidied up the code a little.
 */

// While testing, if I left it some time the audio (BGM, BGS)
//   resumed correctly but was extremely quiet/inaudible.
// Problem stopped on disabling my system's audio driver "enhancements".

void (() => {
'use strict';

    /** Tracks game active status, for applying pause. */
    let isActive = true;

    /**
     * New non-conflicting `WebAudio` property identifier.
     *
     * - The original `setTimeout` end timer system has been replaced by the
     * native `AudioContext` timing, providing improved precision and central
     * control.
     * <br>
     * - The core scripts already attach an `onended` context event handler
     * for software-decoded sources (`libs/vorbisdecoder.js`), because they
     * are decoded in chunks.
     *
     * This property is used as a flag for a new `onended` handler
     * that incorporates both mechanics.
     */
    const SHOULD_LOOP = Symbol();

    /** `true` iff should apply audio pause. */
    const PAUSE_AUDIO = true;

    /**
     * `true` iff should apply Effekseer pause.\
     * This is handled by the core scripts since v1.4.0.
     */
    const PAUSE_FX = !Utils.checkRMVersion("1.4.0");

    /** `true` iff should apply video pause. */
    const PAUSE_VIDEO = true;

    /** @returns {AudioContext} game audio context */
    const getAudioContext = function() {
        return WebAudio._context;
    };

    /** @returns {EffekseerHandle} Effekseer animation handle */
    const getEffekseerHandles = function() {
        return Array.from(
            SceneManager._scene._spriteset?._animationSprites ?? [],
            s => s._handle
        ).filter(h => h);
    };

    /**
     * Pauses/resumes all audio under `context` based on `active` value.
     * @param {boolean} active `false` iff game is currently paused
     * @param {AudioContext} context reference audio context
     */
    const pauseAudio = function(active, context = getAudioContext()) {
        const running = context.state === 'running';
        if (active && !running)
            context.resume().then(() => isActive = true);
        else if (running)
            context.suspend().then(() => isActive = false);
    };

    /**
     * Pauses/resumes all active Effekseer `handles` based on `active` value.
     * @param {boolean} active `false` iff game is currently paused
     * @param {EffekseerHandle[]} handles Effekseer handles to affect
     */
    const pauseEffekseer = function(active, handles = getEffekseerHandles()) {
        for (const h of handles)
            h.setPaused(!active);
    };

    /**
     * Pauses/resumes core video element based on `active` value.
     * @param {boolean} active `false` iff game is currently paused
     */
    const pauseVideo = function(active) {
        // rely on core resume functionality (valid user gesture, e.g. click)
        if (!active && Video.isPlaying())
            Video._element.pause();
    };

    /** Updates audio/fx/video pause status. */
    const update = function() {
        const active = SceneManager.isGameActive();
        if (active !== isActive) {
            if (PAUSE_AUDIO)
                pauseAudio(active);
            if (PAUSE_FX)
                pauseEffekseer(active);
        }
        if (PAUSE_VIDEO)
            pauseVideo(active);
    };

    /**
     * Runs when an applicable source node ends.
     * @this {WebAudio}
     * @param {number} index source node index
     */
    const onAudioEnd = function(index) {
        if (SHOULD_LOOP in this) {
            // This is the original onended event handler, for script-decoded loops.
            this._createSourceNode(index);
            this._startSourceNode(index);
        } else {
            // This replaces the original setTimeout method
            // so that end timers trigger when they are supposed to.
            const endTime = this._startTime + this._totalTime / this._pitch;
            if (WebAudio._currentTime() >= endTime)
                this.stop();
        }
    };

    // Patch - visibility change pause/resume hooks, e.g. minimise window.
    void (alias => {
        WebAudio._onHide = function() {
            alias.apply(this, arguments);
            update();
        };
    })(WebAudio._onHide);
    void (alias => {
        WebAudio._onShow = function() {
            alias.apply(this, arguments);
            update();
        };
    })(WebAudio._onShow);

    // Patch - focus change pause/resume hook, e.g. focus different window.
    void (alias => {
        SceneManager.update = function(deltaTime) {
            alias.apply(this, arguments);
            update();
        };
    })(SceneManager.update);

    // Assign "onended" event handler to onAudioEnd (see above).
    // A new flag (SHOULD_LOOP symbol) is set for software decoding (libs/vorbisdecoder.js).
    // This flag determines the behaviour of onAudioEnd.
    WebAudio.prototype._startSourceNode = function(index) {
        delete this[SHOULD_LOOP];                                       // <- edit 1 of 3
        const sourceNode = this._sourceNodes[index];
        const seekPos = this.seek();
        const currentTime = WebAudio._currentTime();
        const loop = this._loop;
        const loopStart = this._loopStartTime;
        const loopLength = this._loopLengthTime;
        const loopEnd = loopStart + loopLength;
        const pitch = this._pitch;
        let chunkStart = 0;
        for (let i = 0; i < index; i++) {
            chunkStart += this._buffers[i].duration;
        }
        const chunkEnd = chunkStart + sourceNode.buffer.duration;
        let when = 0;
        let offset = 0;
        let duration = sourceNode.buffer.duration;
        if (seekPos >= chunkStart && seekPos < chunkEnd - 0.01) {
            when = currentTime;
            offset = seekPos - chunkStart;
        } else {
            when = currentTime + (chunkStart - seekPos) / pitch;
            offset = 0;
            if (loop) {
                if (when < currentTime - 0.01) {
                    when += loopLength / pitch;
                }
                if (seekPos >= loopStart && chunkStart < loopStart) {
                    when += (loopStart - chunkStart) / pitch;
                    offset = loopStart - chunkStart;
                }
            }
        }
        if (loop && loopEnd < chunkEnd) {
            duration = loopEnd - chunkStart - offset;
        }
        if (this._shouldUseDecoder()) {
            if (when >= currentTime && offset < duration) {
                sourceNode.loop = false;
                sourceNode.start(when, offset, duration);
                if (loop && chunkEnd > loopStart) {
                    this[SHOULD_LOOP] = true;                           // <- edit 2 of 3
                    sourceNode.onended = onAudioEnd.bind(this, index);  // <- edit 3 of 3
                }
            }
        } else {
            if (when >= currentTime && offset < sourceNode.buffer.duration) {
                sourceNode.start(when, offset);
            }
        }
        chunkStart += sourceNode.buffer.duration;
    };

    // Rewritten: end timer now fires via "onended" event.
    // This allows it to respect AudioContext timing changes, e.g. pause/resume.
    WebAudio.prototype._createEndTimer = function() {
        if (!this._loop) {
            const S = this._sourceNodes;
            for (let n = S.length; n--;)
                S[n].onended = onAudioEnd.bind(this, n);
        }
    };

})();