Bubbles/audio.js at main · thinkingdev923/Bubbles · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
export const makeAudioManager = () => {
  let hasInitialized = false;
  let audioCTX;
  let pluck1Buffer;
  let pluck2Buffer;
  let pluck3Buffer;
  let pluck4Buffer;
  let pluck5Buffer;
  let pluck6Buffer;
  let pluck7Buffer;
  let pluck8Buffer;
  let pluck9Buffer;
  let fireworks1Buffer;
  let fireworks2Buffer;
  let missBuffer;
  let loseBuffer;
  let level1Buffer;
  let level2Buffer;
  let impactBuffer;
  let silenceAudio;
  let lastPluckIndex;
  let allPlucks;

  async function _loadFile(context, filePath) {
    const response = await fetch(filePath, {
      method: "GET",
      credentials: "include",
      mode: "no-cors",
    });
    const arrayBuffer = await response.arrayBuffer();
    const audioBuffer = await context.decodeAudioData(arrayBuffer);
    return audioBuffer;
  }

  const initialize = () => {
    if (!hasInitialized) {
      hasInitialized = true;

      // Play silence in a loop in the background on instantiation. Playing some
      // audio continuously with the HTML audio API will allow audio via the Web
      // Audio API to play on the main sound channel in iOS, rather than the
      // ringer channel.
      silenceAudio = new Audio("./sounds/silence.mp3");
      silenceAudio.loop = true;
      silenceAudio.play();

      audioCTX = new AudioContext();
      pluck1Buffer = _loadFile(audioCTX, "./sounds/pluck1.mp3");
      pluck2Buffer = _loadFile(audioCTX, "./sounds/pluck2.mp3");
      pluck3Buffer = _loadFile(audioCTX, "./sounds/pluck3.mp3");
      pluck4Buffer = _loadFile(audioCTX, "./sounds/pluck4.mp3");
      pluck5Buffer = _loadFile(audioCTX, "./sounds/pluck5.mp3");
      pluck6Buffer = _loadFile(audioCTX, "./sounds/pluck6.mp3");
      pluck7Buffer = _loadFile(audioCTX, "./sounds/pluck7.mp3");
      pluck8Buffer = _loadFile(audioCTX, "./sounds/pluck8.mp3");
      pluck9Buffer = _loadFile(audioCTX, "./sounds/pluck9.mp3");
      fireworks1Buffer = _loadFile(audioCTX, "./sounds/fireworks1.mp3");
      fireworks2Buffer = _loadFile(audioCTX, "./sounds/fireworks2.mp3");
      missBuffer = _loadFile(audioCTX, "./sounds/miss.mp3");
      loseBuffer = _loadFile(audioCTX, "./sounds/lose.mp3");
      level1Buffer = _loadFile(audioCTX, "./sounds/level1.mp3");
      level2Buffer = _loadFile(audioCTX, "./sounds/level2.mp3");
      impactBuffer = _loadFile(audioCTX, "./sounds/impact.mp3");

      allPlucks = [
        pluck1Buffer,
        pluck2Buffer,
        pluck3Buffer,
        pluck4Buffer,
        pluck5Buffer,
        pluck6Buffer,
        pluck7Buffer,
        pluck8Buffer,
        pluck9Buffer,
      ];
      lastPluckIndex = null;
    }
  };

  async function _playTrack(audioBuffer, loop = true) {
    const playBuffer = (buffer) => {
      const trackSource = new AudioBufferSourceNode(audioCTX, {
        buffer: buffer,
        loop: loop,
      });
      trackSource.connect(audioCTX.destination);
      trackSource.start();
      return trackSource;
    };

    if (hasInitialized) {
      return Promise.all([audioCTX.resume(), audioBuffer]).then((e) =>
        playBuffer(e[1])
      );
    } else {
      return Promise.all([initialize(), audioBuffer]).then((e) =>
        playBuffer(e[1])
      );
    }
  }

  const playSequentialPluck = () => {
    if (lastPluckIndex === null) {
      _playTrack(allPlucks[0], false);
      lastPluckIndex = 0;
    } else {
      const nextIndex =
        lastPluckIndex + 1 < allPlucks.length ? lastPluckIndex + 1 : 0;
      _playTrack(allPlucks[nextIndex], false);
      lastPluckIndex = nextIndex;
    }
  };

  const resetPluckSequence = () => (lastPluckIndex = null);

  const playRandomFireworks = () => {
    _playTrack(
      [fireworks1Buffer, fireworks2Buffer][Math.floor(Math.random() * 2)],
      false
    );
  };

  const playMiss = () => {
    _playTrack(missBuffer, false);
  };

  const playRandomLevel = () => {
    _playTrack(
      [level1Buffer, level2Buffer][Math.floor(Math.random() * 2)],
      false
    );
  };

  const playImpact = () => {
    _playTrack(impactBuffer, false);
  };

  const playLose = () => {
    _playTrack(loseBuffer, false);
  };

  return {
    initialize,
    playSequentialPluck,
    resetPluckSequence,
    playRandomFireworks,
    playMiss,
    playRandomLevel,
    playImpact,
    playLose,
  };
};