Audio framework. (#32)

karnkaul · web-flow · commit 4557121ab4fc · 2024-04-20T22:33:46.000+05:30
* Add audio service.

* Groundwork for weapon fire and enemy death SFX.

* Fix Android CI.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -57,6 +57,6 @@ jobs:
             tar xvzf jdk-17_linux-x64_bin.tar.gz -C /opt
       - name: build
         run: |
-            export JAVA_HOME=/opt/jdk-17.0.10
+            export JAVA_HOME=$(find /opt -name "jdk-17.*")
             cd src/android
             ./gradlew assembleDebug
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -11,7 +11,7 @@ include(FetchContent)
 FetchContent_Declare(
   bave
   GIT_REPOSITORY https://github.com/karnkaul/bave
-  GIT_TAG 8717d1eafd2ac581c7b90fa3af384eb66cd7896a # v0.4.8
+  GIT_TAG ff3978f8431649007d3309db513d3de3e72fe823 # v0.4.9
   SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ext/bave"
 )
 
diff --git a/assets/sfx/bubble.wav b/assets/sfx/bubble.wav
diff --git a/assets/worlds/playground.json b/assets/worlds/playground.json
@@ -15,7 +15,10 @@
       ],
       "spawn_rate": 2,
       "initial_health": 2,
-      "death_emitter": "particles/explode.json"
+      "death_emitter": "particles/explode.json",
+      "death_sfx": [
+        "sfx/bubble.wav"
+      ]
     }
   ]
 }
diff --git a/src/spaced/spaced/game/asset_list.cpp b/src/spaced/spaced/game/asset_list.cpp
@@ -31,6 +31,12 @@ auto AssetList::add_particle_emitter(std::string uri) -> AssetList& {
 	return *this;
 }
 
+auto AssetList::add_audio_clip(std::string uri) -> AssetList& {
+	if (uri.empty()) { return *this; }
+	m_audio_clips.insert(std::move(uri));
+	return *this;
+}
+
 auto AssetList::read_world_spec(std::string_view const uri) -> WorldSpec {
 	if (uri.empty()) { return {}; }
 
@@ -51,6 +57,7 @@ auto AssetList::read_world_spec(std::string_view const uri) -> WorldSpec {
 
 	for (auto const& enemy_factory : json["enemy_factories"].array_view()) {
 		add_particle_emitter(enemy_factory["death_emitter"].as<std::string>());
+		for (auto const& death_sfx : enemy_factory["death_sfx"].array_view()) { add_audio_clip(death_sfx.as<std::string>()); }
 		ret.enemy_factories.push_back(enemy_factory);
 	}
 
@@ -70,6 +77,7 @@ auto AssetList::build_stage_0(AssetLoader& asset_loader) const -> AsyncExec::Sta
 	auto ret = AsyncExec::Stage{};
 	for (auto const& texture : m_textures) { ret.push_back(asset_loader.make_load_texture(texture.uri, texture.mip_map)); }
 	for (auto const& font : m_fonts) { ret.push_back(asset_loader.make_load_font(font)); }
+	for (auto const& audio_clip : m_audio_clips) { ret.push_back(asset_loader.make_load_audio_clip(audio_clip)); }
 	return ret;
 }
 
diff --git a/src/spaced/spaced/game/asset_list.hpp b/src/spaced/spaced/game/asset_list.hpp
@@ -16,6 +16,7 @@ class AssetList {
 	auto add_texture(std::string uri, bool mip_map = false) -> AssetList&;
 	auto add_font(std::string uri) -> AssetList&;
 	auto add_particle_emitter(std::string uri) -> AssetList&;
+	auto add_audio_clip(std::string uri) -> AssetList&;
 
 	auto read_world_spec(std::string_view uri) -> WorldSpec;
 
@@ -40,5 +41,6 @@ class AssetList {
 	std::set<Tex> m_textures{};
 	std::set<std::string> m_fonts{};
 	std::set<std::string> m_emitters{};
+	std::set<std::string> m_audio_clips{};
 };
 } // namespace spaced
diff --git a/src/spaced/spaced/game/asset_loader.cpp b/src/spaced/spaced/game/asset_loader.cpp
@@ -53,6 +53,11 @@ auto AssetLoader::make_load_particle_emitter(std::string uri, bool const reload)
 	return make_load_task(std::move(uri), reload, load);
 }
 
+auto AssetLoader::make_load_audio_clip(std::string uri, bool const reload) -> LoadTask {
+	auto const load = [](Loader const& loader, std::string_view const uri) { return loader.load_audio_clip(uri); };
+	return make_load_task(std::move(uri), reload, load);
+}
+
 template <typename FuncT>
 auto AssetLoader::make_load_task(std::string uri, bool reload, FuncT load) const -> LoadTask {
 	return [impl = m_impl, uri = std::move(uri), reload, load] {
diff --git a/src/spaced/spaced/game/asset_loader.hpp b/src/spaced/spaced/game/asset_loader.hpp
@@ -16,6 +16,7 @@ class AssetLoader {
 	[[nodiscard]] auto make_load_texture(std::string uri, bool mip_map = false, bool reload = false) -> LoadTask;
 	[[nodiscard]] auto make_load_texture_atlas(std::string uri, bool mip_map = false, bool reload = false) -> LoadTask;
 	[[nodiscard]] auto make_load_particle_emitter(std::string uri, bool reload = false) -> LoadTask;
+	[[nodiscard]] auto make_load_audio_clip(std::string uri, bool reload = false) -> LoadTask;
 
   private:
 	template <typename FuncT>
diff --git a/src/spaced/spaced/game/enemies/basic_creep_factory.cpp b/src/spaced/spaced/game/enemies/basic_creep_factory.cpp
@@ -13,17 +13,18 @@ using bave::random_in_range;
 using bave::Seconds;
 
 BasicCreepFactory::BasicCreepFactory(NotNull<Services const*> services, NotNull<IEnemyDeathListener*> listener, dj::Json const& json)
-	: m_services(services), m_listener(listener) {
+	: IEnemyFactory(services), m_listener(listener) {
 	for (auto const& tint : json["tints"].array_view()) { tints.push_back(tint.as<std::string>()); }
 	if (auto const in_death_emitter = services->get<Resources>().get<ParticleEmitter>(json["death_emitter"].as_string())) { death_emitter = *in_death_emitter; }
 	spawn_rate = Seconds{json["spawn_rate"].as<float>(spawn_rate.count())};
 	initial_health = json["initial_health"].as<float>(initial_health);
+	for (auto const& death_sfx : json["death_sfx"].array_view()) { m_death_sfx.push_back(death_sfx.as<std::string>()); }
 }
 
 auto BasicCreepFactory::spawn_enemy() -> std::unique_ptr<Enemy> {
-	auto ret = std::make_unique<Creep>(*m_services, m_listener);
+	auto ret = std::make_unique<Creep>(get_services(), m_listener);
 	if (!tints.empty()) {
-		auto const& rgbas = m_services->get<Styles>().rgbas;
+		auto const& rgbas = get_services().get<Styles>().rgbas;
 		auto const tint_index = random_in_range(std::size_t{}, tints.size() - 1);
 		ret->shape.tint = rgbas[tints.at(tint_index)];
 		ret->health = initial_health;
diff --git a/src/spaced/spaced/game/enemies/basic_creep_factory.hpp b/src/spaced/spaced/game/enemies/basic_creep_factory.hpp
@@ -23,7 +23,6 @@ class BasicCreepFactory : public IEnemyFactory {
   private:
 	void do_inspect() final;
 
-	bave::NotNull<Services const*> m_services;
 	bave::NotNull<IEnemyDeathListener*> m_listener;
 	bave::Seconds m_elapsed{};
 };
diff --git a/src/spaced/spaced/game/enemy_factory.cpp b/src/spaced/spaced/game/enemy_factory.cpp
@@ -0,0 +1,10 @@
+#include <spaced/game/enemy_factory.hpp>
+#include <spaced/services/audio.hpp>
+
+namespace spaced {
+using bave::NotNull;
+
+IEnemyFactory::IEnemyFactory(NotNull<Services const*> services) : m_services(services), m_audio(&services->get<IAudio>()) {}
+
+void IEnemyFactory::play_death_sfx() { m_audio->play_any_sfx(m_death_sfx); }
+} // namespace spaced
diff --git a/src/spaced/spaced/game/enemy_factory.hpp b/src/spaced/spaced/game/enemy_factory.hpp
@@ -1,21 +1,37 @@
 #pragma once
 #include <bave/graphics/particle_system.hpp>
 #include <spaced/game/enemy.hpp>
+#include <string>
+#include <vector>
 
 namespace spaced {
+class IAudio;
+
 class IEnemyFactory : public bave::Polymorphic {
   public:
+	explicit IEnemyFactory(bave::NotNull<Services const*> services);
+
 	[[nodiscard]] virtual auto get_type_name() const -> std::string_view = 0;
 	[[nodiscard]] virtual auto spawn_enemy() -> std::unique_ptr<Enemy> = 0;
 	[[nodiscard]] virtual auto get_death_emitter() const -> bave::ParticleEmitter const& = 0;
 
+	void play_death_sfx();
+
 	virtual auto tick(bave::Seconds dt) -> bool = 0;
 
 	void inspect() {
 		if constexpr (bave::debug_v) { do_inspect(); }
 	}
 
+  protected:
+	[[nodiscard]] auto get_services() const -> Services const& { return *m_services; }
+
+	std::vector<std::string> m_death_sfx{};
+
   private:
 	virtual void do_inspect() {}
+
+	bave::NotNull<Services const*> m_services;
+	bave::NotNull<IAudio*> m_audio;
 };
 } // namespace spaced
diff --git a/src/spaced/spaced/game/enemy_spawner.cpp b/src/spaced/spaced/game/enemy_spawner.cpp
@@ -42,6 +42,7 @@ void EnemySpawner::explode_at(glm::vec2 const position) {
 	auto& emitter = m_death_emitters.emplace_back(m_factory->get_death_emitter());
 	emitter.config.respawn = false;
 	emitter.set_position(position);
+	m_factory->play_death_sfx();
 }
 
 void EnemySpawner::do_inspect() {
diff --git a/src/spaced/spaced/game/player.cpp b/src/spaced/spaced/game/player.cpp
@@ -73,6 +73,7 @@ void Player::setup(WorldSpec::Player const& spec) {
 	m_exhaust.pre_warm();
 
 	if (auto const death = resources.get<ParticleEmitter>(spec.death_emitter)) { m_death_source = *death; }
+	m_death_source.config.respawn = false;
 }
 
 void Player::set_y(float const y) { ship.transform.position.y = y; }
@@ -99,7 +100,6 @@ void Player::on_death() {
 	health = 0.0f;
 	m_death = m_death_source;
 	m_death->set_position(ship.transform.position);
-	m_death->config.respawn = false;
 }
 
 void Player::do_inspect() {
diff --git a/src/spaced/spaced/game/weapon.cpp b/src/spaced/spaced/game/weapon.cpp
@@ -1,9 +1,18 @@
 #include <bave/imgui/im_text.hpp>
 #include <spaced/game/weapon.hpp>
+#include <spaced/services/audio.hpp>
 
 namespace spaced {
 using bave::im_text;
 
+Weapon::Weapon(Services const& services, std::string name) : m_log{std::move(name)}, m_layout(&services.get<ILayout>()), m_audio(&services.get<IAudio>()) {}
+
+auto Weapon::fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
+	auto ret = do_fire(muzzle_position);
+	if (ret) { m_audio->play_any_sfx(m_fire_sfx); }
+	return ret;
+}
+
 void Weapon::do_inspect() {
 	if constexpr (bave::imgui_v) { im_text("rounds remaining: {}", get_rounds_remaining()); }
 }
diff --git a/src/spaced/spaced/game/weapon.hpp b/src/spaced/spaced/game/weapon.hpp
@@ -6,15 +6,17 @@
 #include <spaced/services/services.hpp>
 
 namespace spaced {
+class IAudio;
+
 class Weapon : public bave::Polymorphic {
   public:
 	using Round = IWeaponRound;
 
-	explicit Weapon(Services const& services, std::string name) : m_log{std::move(name)}, m_layout(&services.get<ILayout>()) {}
+	explicit Weapon(Services const& services, std::string name);
 
 	[[nodiscard]] auto get_rounds_remaining() const -> int { return rounds < 0 ? 1 : rounds; }
 
-	virtual auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> = 0;
+	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round>;
 	[[nodiscard]] virtual auto is_idle() const -> bool = 0;
 
 	virtual void tick(bave::Seconds dt) = 0;
@@ -28,11 +30,14 @@ class Weapon : public bave::Polymorphic {
   protected:
 	[[nodiscard]] auto get_layout() const -> ILayout const& { return *m_layout; }
 
+	virtual auto do_fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> = 0;
 	virtual void do_inspect();
 
 	bave::Logger m_log{};
+	std::vector<std::string> m_fire_sfx{};
 
   private:
 	bave::NotNull<ILayout const*> m_layout;
+	bave::NotNull<IAudio*> m_audio;
 };
 } // namespace spaced
diff --git a/src/spaced/spaced/game/weapons/gun_beam.cpp b/src/spaced/spaced/game/weapons/gun_beam.cpp
@@ -102,15 +102,6 @@ GunBeam::GunBeam(Services const& services) : Weapon(services, "GunBeam") {
 	config.beam_tint = rgbas.get_or("gun_beam", rgbas["grey"]);
 }
 
-auto GunBeam::fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
-	if (!is_idle() || m_reload_remain > 0s || rounds == 0) { return {}; }
-
-	if (rounds > 0) { --rounds; }
-	m_fire_remain = config.fire_duration;
-	m_reload_remain = 0s;
-	return std::make_unique<LaserCharge>(&get_layout(), config, muzzle_position);
-}
-
 void GunBeam::tick(Seconds const dt) {
 	if (m_fire_remain > 0s) {
 		m_fire_remain -= dt;
@@ -122,6 +113,15 @@ void GunBeam::tick(Seconds const dt) {
 	if (m_reload_remain > 0s) { m_reload_remain -= dt; }
 }
 
+auto GunBeam::do_fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
+	if (!is_idle() || m_reload_remain > 0s || rounds == 0) { return {}; }
+
+	if (rounds > 0) { --rounds; }
+	m_fire_remain = config.fire_duration;
+	m_reload_remain = 0s;
+	return std::make_unique<LaserCharge>(&get_layout(), config, muzzle_position);
+}
+
 void GunBeam::do_inspect() {
 	if constexpr (bave::imgui_v) {
 		im_text("type: GunBeam");
diff --git a/src/spaced/spaced/game/weapons/gun_beam.hpp b/src/spaced/spaced/game/weapons/gun_beam.hpp
@@ -14,13 +14,13 @@ class GunBeam final : public Weapon {
 
 	explicit GunBeam(Services const& services);
 
-	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	[[nodiscard]] auto is_idle() const -> bool final { return m_fire_remain <= 0s; }
 	void tick(bave::Seconds dt) final;
 
 	Config config{};
 
   private:
+	auto do_fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	void do_inspect() final;
 
 	bave::Seconds m_fire_remain{};
diff --git a/src/spaced/spaced/game/weapons/gun_kinetic.cpp b/src/spaced/spaced/game/weapons/gun_kinetic.cpp
@@ -7,20 +7,22 @@ using bave::im_text;
 using bave::Rgba;
 using bave::Seconds;
 
-GunKinetic::GunKinetic(Services const& services) : Weapon(services, "GunKinetic") { projectile_config.tint = services.get<Styles>().rgbas["black"]; }
+GunKinetic::GunKinetic(Services const& services) : Weapon(services, "GunKinetic"), m_audio(&services.get<IAudio>()) {
+	projectile_config.tint = services.get<Styles>().rgbas["black"];
+}
+
+void GunKinetic::tick(Seconds const dt) {
+	if (m_reload_remain > 0s) { m_reload_remain -= dt; }
+}
 
-auto GunKinetic::fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
+auto GunKinetic::do_fire(glm::vec2 const muzzle_position) -> std::unique_ptr<Round> {
 	if (m_reload_remain > 0s || rounds == 0) { return {}; }
 
 	if (rounds > 0) { --rounds; }
 	m_reload_remain = reload_delay;
 	return std::make_unique<Projectile>(&get_layout(), projectile_config, muzzle_position);
 }
 
-void GunKinetic::tick(Seconds const dt) {
-	if (m_reload_remain > 0s) { m_reload_remain -= dt; }
-}
-
 void GunKinetic::do_inspect() {
 	if constexpr (bave::imgui_v) {
 		im_text("type: GunKinetic");
diff --git a/src/spaced/spaced/game/weapons/gun_kinetic.hpp b/src/spaced/spaced/game/weapons/gun_kinetic.hpp
@@ -1,13 +1,13 @@
 #pragma once
 #include <spaced/game/weapon.hpp>
 #include <spaced/game/weapons/projectile.hpp>
+#include <spaced/services/audio.hpp>
 
 namespace spaced {
 class GunKinetic final : public Weapon {
   public:
 	explicit GunKinetic(Services const& services);
 
-	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	[[nodiscard]] auto is_idle() const -> bool final { return m_reload_remain <= 0s; }
 
 	void tick(bave::Seconds dt) final;
@@ -16,8 +16,10 @@ class GunKinetic final : public Weapon {
 	bave::Seconds reload_delay{0.25s};
 
   private:
+	auto do_fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
 	void do_inspect() final;
 
 	bave::Seconds m_reload_remain{};
+	bave::NotNull<IAudio*> m_audio;
 };
 } // namespace spaced
diff --git a/src/spaced/spaced/resource_map.hpp b/src/spaced/spaced/resource_map.hpp
@@ -17,13 +17,15 @@ class ResourceMap {
 
 	template <typename Type>
 	[[nodiscard]] auto contains(std::string_view const uri) const -> bool {
+		if (uri.empty()) { return false; }
 		auto const it = m_resources.find(uri);
 		if (it == m_resources.end()) { return false; }
 		return it->second->type_index == typeid(Type);
 	}
 
 	template <typename Type>
 	[[nodiscard]] auto get(std::string_view const uri, std::shared_ptr<Type> const& fallback = {}) const -> std::shared_ptr<Type> {
+		if (uri.empty()) { return fallback; }
 		auto const it = m_resources.find(uri);
 		if (it == m_resources.end()) { return fallback; }
 		auto const& resource = it->second;
diff --git a/src/spaced/spaced/services/audio.hpp b/src/spaced/spaced/services/audio.hpp
@@ -0,0 +1,28 @@
+#pragma once
+#include <bave/core/random.hpp>
+#include <bave/core/time.hpp>
+#include <spaced/services/service.hpp>
+#include <span>
+#include <string_view>
+
+namespace spaced {
+class IAudio : public IService {
+  public:
+	[[nodiscard]] virtual auto get_sfx_gain() const -> float = 0;
+	virtual void set_sfx_gain(float gain) = 0;
+
+	[[nodiscard]] virtual auto get_music_gain() const -> float = 0;
+	virtual void set_music_gain(float gain) = 0;
+
+	virtual void play_sfx(std::string_view uri) = 0;
+	virtual void play_music(std::string_view uri, bave::Seconds crossfade = 1s) = 0;
+	virtual void stop_music() = 0;
+
+	void play_any_sfx(std::span<std::string const> uris) {
+		if (uris.empty()) { return; }
+		if (uris.size() == 1) { return play_sfx(uris.front()); }
+		auto const index = bave::random_in_range(std::size_t{}, uris.size() - 1);
+		play_sfx(uris[index]);
+	}
+};
+} // namespace spaced
diff --git a/src/spaced/spaced/spaced.cpp b/src/spaced/spaced/spaced.cpp
diff --git a/src/spaced/spaced/spaced.hpp b/src/spaced/spaced/spaced.hpp

Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ include(FetchContent)`
`11`	`11`	`FetchContent_Declare(`
`12`	`12`	`bave`
`13`	`13`	`GIT_REPOSITORY https://github.com/karnkaul/bave`
`14`		`- GIT_TAG 8717d1eafd2ac581c7b90fa3af384eb66cd7896a # v0.4.8`
	`14`	`+ GIT_TAG ff3978f8431649007d3309db513d3de3e72fe823 # v0.4.9`
`15`	`15`	`SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ext/bave"`
`16`	`16`	`)`
`17`	`17`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,10 @@`
`15`	`15`	`],`
`16`	`16`	`"spawn_rate": 2,`
`17`	`17`	`"initial_health": 2,`
`18`		`- "death_emitter": "particles/explode.json"`
	`18`	`+ "death_emitter": "particles/explode.json",`
	`19`	`+ "death_sfx": [`
	`20`	`+ "sfx/bubble.wav"`
	`21`	`+ ]`
`19`	`22`	`}`
`20`	`23`	`]`
`21`	`24`	`}`