Merge branch 'main' of yibble.dev:bulmanator/ld58

Playing music

code/core/impl/math.c

@@ -47,6 +47,11 @@ V3f V3f_Sub(V3f a, V3f b) {
 	return result;
 }
 
+F32 V2f_Dot(V2f a, V2f b) {
+	F32 result = (a.x * b.x) + (a.y * b.y);
+	return result;
+}
+
 F32 V3f_Dot(V3f a, V3f b) {
 	F32 result = (a.x * b.x) + (a.y * b.y) + (a.z * b.z);
 	return result;

code/core/math.h

@@ -118,6 +118,7 @@ function V3f V3f_Neg(V3f x);
 function V3f V3f_Scale(V3f x, F32 s);
 function V3f V3f_Sub(V3f a, V3f b);
 
+function F32 V2f_Dot(V2f a, V2f b);
 function F32 V3f_Dot(V3f a, V3f b);
 function F32 V4f_Dot(V4f a, V4f b);
 

code/first.c

@@ -44,30 +44,6 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	SDL_AudioStream *austream;
-	Str8 audio_data;
-	M_TempScope(0, 0) {
-		SDL_AudioSpec spec;
-		spec.format   = SDL_AUDIO_S16LE;
-		spec.channels = 2;
-		spec.freq     = 44100;
-
-		austream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, 0, 0);
-
-		if (!austream) {
-			printf("Failed to open audio stream (%s)\n", SDL_GetError());
-		}
-
-		Str8 exec = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
-		Str8 path = Sf(temp.arena, "%.*s/assets/outside_ambience.wav", Sv(exec));
-
-		SDL_AudioSpec wav_spec;
-		U32 count;
-
-		SDL_LoadWAV((const char *) path.data, &wav_spec, &audio_data.data, &count);
-		audio_data.count = count;
-	}
-
 	Vk_Setup(window);
 
 	G_State *game = 0;
@@ -84,6 +60,14 @@ int main(int argc, char **argv)
 		G_PipelinesLoad(game);
 		G_AudioLoad(game);
 
+		Audio_Context *audio = M_ArenaPush(game->arena, Audio_Context);
+		Audio_Init(game->arena, audio, 0.0f); // disabled audio
+
+		U32 bgm = Audio_Play(audio, 0);
+		U32 saloon_music = Audio_Play(audio, 1);
+
+		SDL_ResumeAudioStreamDevice(audio->stream);
+
 		G_Camera *camera = &game->camera;
 
 		camera->x = V3F(1, 0, 0);
@@ -100,6 +84,11 @@ int main(int argc, char **argv)
 		World *world = M_ArenaPush(arena, World);
     LoadWorld(arena, world);
     game->world = world;
+
+		world->audio = audio;
+		world->audio_handles[0] = bgm;
+		world->audio_handles[1] = saloon_music;
+
     world->arena = arena;
     world->random = Random_Seed(29237489723847);
     world->npcCount = 12;
@@ -382,7 +371,7 @@ int main(int argc, char **argv)
 		}
 
     if(!game->editor.enabled) {
-		  UpdateWorld(1.0f / 60.0f, game->world);
+		  UpdateWorld(1.0f / 250.0f, game->world);
 
       game->camera.p.x = game->world->player.collision.pos.x;
       game->camera.p.y = game->world->player.collision.pos.y;
@@ -424,12 +413,17 @@ int main(int argc, char **argv)
 
 		D_Begin(&game->draw, frame, D_MAX_RECTS);
 
+
     RenderWorld(game->world, &game->draw);
-    if(game->world->showPoster){
-      D_Rect(&game->draw, G_CameraBounds(&game->camera).min.x+4.8, G_CameraBounds(&game->camera).min.y+6.4, .texture=D_ImageHandle(&game->draw, S("poster")), .scale=12.0);
+
+		R3f bounds = G_CameraBounds(&game->camera);
+
+    if (game->world->showPoster) {
+      D_Rect(&game->draw, bounds.min.x + 4.8f, bounds.min.y + 6.4f, .texture = D_ImageHandle(&game->draw, S("poster")), .scale = 12.0f);
     }
-    for(int i = 0; i < game->world->player.health; i++){
-      D_Rect(&game->draw, (G_CameraBounds(&game->camera).max.x-3)+i, G_CameraBounds(&game->camera).min.y+1.0, .texture=D_ImageHandle(&game->draw, S("heart")), .scale=1.0);
+
+    for (U32 i = 0; i < game->world->player.health; i++) {
+      D_Rect(&game->draw, (bounds.max.x - 3) + i, bounds.min.y + 1, .texture = D_ImageHandle(&game->draw, S("heart")));
     }
 
 		//D_Text(&game->draw, game->draw.fonts, S("Small Test"), 0, 0);
@@ -438,7 +432,7 @@ int main(int argc, char **argv)
       G_Editor editor = game->editor;
       F32 tilex = cast(F32) floor(editor.cursor.x+TILE_SIZE/2);
       F32 tiley = cast(F32) floor(editor.cursor.y+TILE_SIZE/2);
-      for (int i = 0; i < game->world->navMesh->nodeCount; i++) {
+      for (U32 i = 0; i < game->world->navMesh->nodeCount; i++) {
         NavNode n = game->world->navMesh->nodes[i];
         D_Rect(
           &game->draw,
@@ -448,7 +442,7 @@ int main(int argc, char **argv)
           .scale = 0.2f,
         );
       }
-      for (int i = 0; i < game->world->navMesh->nodeCount; i++) {
+      for (U32 i = 0; i < game->world->navMesh->nodeCount; i++) {
         NavNode n = game->world->navMesh->nodes[i];
         if(i == editor.selectedNode) {
           D_Rect(
@@ -509,7 +503,7 @@ int main(int argc, char **argv)
               .texture=0,
               .dim=game->world->portals[i].box.size,
               .flags=D_RECT_IGNORE_ASPECT,
-              .c=V4F(0,0,100,0.7),
+              .c=V4F(0,0,100,0.7f),
             );
           }
           break;

code/game/impl/bandit.c

@@ -10,7 +10,7 @@ V2f ShootTowards(Bandit *bandit, V2f target, Random* r)
 }
 
 void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
-  for(int i = 0; i < world->portalCount; i++) {
+  for(U32 i = 0; i < world->portalCount; i++) {
     if(AABB_Collide(world->portals[0].box, bandit->collision)) {
       bandit->currentArea = world->portals[0].area;
     }
@@ -18,12 +18,10 @@ void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
   if (
       world->player.controls.shot && AABB_Slab(world->player.collision.pos, world->player.shotPos, bandit->collision) && bandit->currentArea == world->player.currentArea)
   {
-    printf("You shot the bandit %*.s\n", Sv(bandit->name));
     bandit->health--;
   }
   if (AABB_Circle(bandit->agroRadius, AABB_Centre(bandit->collision), world->player.collision) && !(bandit->mode == BANDIT_SHOOTING || bandit->mode == BANDIT_SHOOTOUT))
   {
-    printf("begin shootout\n");
     // shootout time o.o
     bandit->mode = BANDIT_SHOOTOUT;
   }
@@ -61,7 +59,7 @@ void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
       bandit->collision.pos.y = cNav.pos.y * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.y * bandit->walkTimer/NPC_SPEED;
     break;
     case BANDIT_SHOOTOUT:
-      bandit->shootoutTimer-=delta; 
+      bandit->shootoutTimer-=delta;
       if(bandit->shootoutTimer < 0){
         bandit->mode=BANDIT_SHOOTING;
       }
@@ -71,17 +69,14 @@ void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
       bandit->reloadTimer -= delta;
       if (bandit->shootCooldownTimer < 0 && bandit->reloadTimer < 0)
       {
-        printf("\nshoot at player");
         bandit->bullets--;
         bandit->shootCooldownTimer = bandit->shootDelay;
         V2f banditShot = ShootTowards(bandit, world->player.collision.pos, &world->random);
         if(AABB_Slab(bandit->collision.pos, banditShot, world->player.collision)){
           // gets shot lmao
-          printf("\nhit");
           world->player.health--;
         }
         if(bandit->bullets == 0){
-          printf("\nenemy reload");
           bandit->bullets = 6;
           bandit->reloadTimer = bandit->reloadTime;
         }
@@ -109,4 +104,4 @@ void BanditDraw(D_Context *draw, Bandit *bandit)
       D_Rect(draw, bandit->collision.pos.x, bandit->collision.pos.y, .texture = tid, .uv = pframe, .flags = flags);
     }
   }
-}
+}

code/game/impl/npc.c

@@ -4,7 +4,7 @@
 #include "core/math.h"
 
 void UpdateNPC(F32 delta, NPC *npc, World *world) {
-  for(int i = 0; i < world->portalCount; i++) {
+  for(U32 i = 0; i < world->portalCount; i++) {
     if(AABB_Collide(world->portals[0].box, npc->collision)) {
       npc->currentArea = world->portals[0].area;
     }

code/game/impl/player.c

@@ -100,7 +100,6 @@ void PlayerUpdate(F32 delta, Player *player) {
   player->controls.shot = false;
   V2f dir = V2F(0, 0);
   if(player->health == 0){
-    printf("dead :(");
     player->health = 3;
   }
   if(player->controls.upDown) {
@@ -137,11 +136,23 @@ void PlayerUpdate(F32 delta, Player *player) {
   dir = V2f_Scale(NormaliseV2F(dir), PLAYER_SPEED*delta);
   player->collision.pos.x += dir.x;
   player->collision.pos.y += dir.y;
-  for(int i = 0; i < player->world->portalCount; i++) {
-    if(AABB_Collide(player->world->portals[0].box, player->collision)) {
-      player->currentArea = player->world->portals[0].area;
+
+  for(U32 i = 0; i < player->world->portalCount; i++) {
+    if(AABB_Collide(player->world->portals[i].box, player->collision)) {
+      player->currentArea = player->world->portals[i].area;
     }
   }
+
+	V2f test;
+	test.x = player->collision.pos.x - 14;
+	test.y = player->collision.pos.y - 14;
+
+	F32 len = V2f_Dot(test, test);
+	F32 vol = Max(0.0f, 1.0f - (len / 25.0f));
+
+	Audio_ChangeVolume(player->world->audio, player->world->audio_handles[1], vol);
+	Audio_ChangeVolume(player->world->audio, player->world->audio_handles[0], 1.0f - vol);
+
 }
 
 void PlayerDraw(D_Context *draw, Player *player) {

code/game/impl/world.c

@@ -244,8 +244,8 @@ void GenerateNavMesh(M_Arena *arena, World *world) {
       }
     }
     if(skip) {continue;}
-    world->navMesh->nodes[world->navMesh->nodeCount].pos.x = x;
-    world->navMesh->nodes[world->navMesh->nodeCount].pos.y = y;
+    world->navMesh->nodes[world->navMesh->nodeCount].pos.x = cast(F32) x;
+    world->navMesh->nodes[world->navMesh->nodeCount].pos.y = cast(F32) y;
     world->navMesh->nodes[world->navMesh->nodeCount].connectionCount = 0;
     for(int nx = -1; nx < 2; nx++){
       for(int ny = -1; ny < 2; ny++){
@@ -265,7 +265,7 @@ void GenerateNavMesh(M_Arena *arena, World *world) {
         }
         U32 nCount = world->navMesh->nodeCount;
         S32 index = -1;
-        for(int ohgod = 0; ohgod < nCount; ohgod++) {
+        for (U32 ohgod = 0; ohgod < nCount; ohgod++) {
           if(world->navMesh->nodes[ohgod].pos.x == nx+x&& world->navMesh->nodes[ohgod].pos.y == y+ny) {
             index=ohgod;
             break;
@@ -282,7 +282,7 @@ void GenerateNavMesh(M_Arena *arena, World *world) {
           };
         }
         if(index < 0) {continue;}
-        skip |= index > nCount;
+        skip |= (index > (S32) nCount);
         if(skip) {continue;}
         world->navMesh->nodes[nCount].connections[world->navMesh->nodes[nCount].connectionCount].NodeIndex = index;
         world->navMesh->nodes[nCount].connections[world->navMesh->nodes[nCount].connectionCount].Cost = cost;
@@ -294,11 +294,11 @@ void GenerateNavMesh(M_Arena *arena, World *world) {
     }
     world->navMesh->nodeCount++;
   }
-  for(int i = 0; i < world->npcCount; i++) {
+  for(U32 i = 0; i < world->npcCount; i++) {
       world->npcs[i].mode = NPC_ACTION_WAITING;
       world->npcs[i].maxWaitTime = Random_F32(&world->random, 20, 140);
       world->npcs[i].waitTime = 0;
-      world->npcs[i].currentNavNode=0; 
+      world->npcs[i].currentNavNode=0;
       world->npcs[i].pathIndex = 0;
   }
 }

code/game/world.h

@@ -63,15 +63,17 @@ struct World {
   //// Loaded from world file
   World_Tile *tileTypes;
   World_PropType *propTypes;
-  World_Prop *props; 
-  World_Hitbox *hitboxes; 
-  World_Portal *portals; 
+  World_Prop *props;
+  World_Hitbox *hitboxes;
+  World_Portal *portals;
   U32 *map;
   bool showPoster;
   U32 propCount;
   U32 portalCount;
   U32 hitboxCount;
 
+	Audio_Context *audio;
+	U32 audio_handles[2];
 
   //// Player
   Player player;

code/os/audio.h

@@ -0,0 +1,43 @@
+#if !defined(LD_OS_AUDIO_H_)
+#define LD_OS_AUDIO_H_
+
+typedef struct Audio_Data Audio_Data;
+struct Audio_Data {
+	S16 *samples;
+	U32 n_frames;
+};
+
+typedef struct Audio_Track Audio_Track;
+struct Audio_Track {
+	B32 playing;
+
+	Audio_Data *data;
+
+	F32 volume;
+
+	U32 n_played;
+	U32 next; // to play if playing, free otherwise
+};
+
+typedef struct Audio_Context Audio_Context;
+struct Audio_Context {
+	SDL_AudioStream *stream;
+
+	U32 n_tracks;
+	Audio_Track tracks[16];
+
+	U32 head;
+	U32 free;
+
+	F32 volume;
+
+	U32 n_sounds;
+	Audio_Data *sounds;
+};
+
+function void Audio_Init(M_Arena *arena, Audio_Context *audio, F32 volume);
+function U32  Audio_Play(Audio_Context *audio, U32 index);
+
+function void Audio_ChangeVolume(Audio_Context *audio, U32 handle, F32 volume);
+
+#endif  // LD_OS_AUDIO_H_

code/os/core.c

@@ -4,7 +4,6 @@
 	#include "impl/linux/core.c"
 #endif
 
-
 Str8 FS_ReadEntireFile(M_Arena *arena, Str8 path) {
 	Str8 result = { 0 };
 
@@ -19,3 +18,164 @@ Str8 FS_ReadEntireFile(M_Arena *arena, Str8 path) {
 
 	return result;
 }
+
+internal void SDL_SubmitAudio(void *user, SDL_AudioStream *stream, int needed, int total) {
+	Audio_Context *audio = cast(Audio_Context *) user;
+
+	(void) total;
+
+	M_TempScope(0, 0) {
+		U32 prev = 0;
+		U32 it   = audio->head;
+
+		U32 n_samples = needed    >> 1;
+		U32 n_frames  = n_samples >> 1;
+
+		F32 *left_f32  = M_ArenaPush(temp.arena, F32, .count = n_frames);
+		F32 *right_f32 = M_ArenaPush(temp.arena, F32, .count = n_frames);
+
+		while (it != 0) {
+			Audio_Track *track = &audio->tracks[it];
+			U32 next = track->next;
+
+			F32 *l0 = left_f32;
+			F32 *r0 = right_f32;
+
+			Assert(track->playing);
+
+			U32 remain = track->data->n_frames - track->n_played;
+			U32 play   = Min(n_frames, remain);
+			U32 off    = track->n_played << 1; // played n frames, thus double to n samples
+
+			for (U32 f = 0; f < play; ++f) {
+				*l0++ += cast(F32) (track->data->samples[off + (2 * f) + 0]) * track->volume * audio->volume;
+				*r0++ += cast(F32) (track->data->samples[off + (2 * f) + 1]) * track->volume * audio->volume;
+			}
+
+			track->n_played += play;
+
+			if (track->n_played == track->data->n_frames) {
+				if (prev == 0) {
+					// Head has finished playing
+					//
+					audio->head = track->next;
+					track->next = audio->free;
+					audio->free = it;
+				}
+				else {
+					// We're in the middle somewhere so prev->next == it->next
+					//
+					audio->tracks[prev].next = track->next;
+					track->next = audio->free;
+					audio->free = it;
+				}
+
+				track->playing = false;
+			}
+
+			it = next;
+		}
+
+		F32 *l0 = left_f32;
+		F32 *r0 = right_f32;
+
+		S16 *interleaved = M_ArenaPush(temp.arena, S16, .count = n_samples);
+		S16 *i0 = interleaved;
+
+		for (U32 n = 0; n < n_frames; ++n) {
+			*i0++ = cast(S16) (l0[n] + 0.5f);
+			*i0++ = cast(S16) (r0[n] + 0.5f);
+		}
+
+		SDL_PutAudioStreamData(stream, interleaved, needed);
+	}
+}
+
+void Audio_Init(M_Arena *arena, Audio_Context *audio, F32 volume) {
+	SDL_AudioSpec spec = { 0 };
+	spec.format   = SDL_AUDIO_S16LE;
+	spec.channels = 2;
+	spec.freq     = 44100;
+
+	audio->stream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, SDL_SubmitAudio, audio);
+
+	if (audio->stream) {
+		M_TempScope(0, 0) {
+			Str8 exec = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
+			Str8 path = Sf(temp.arena, "%.*s/assets", Sv(exec));
+
+			FS_List files = FS_PathList(temp.arena, path);
+
+			U32 n_audio = 0;
+			for (FS_Entry *it = files.first; it != 0; it = it->next) {
+				if (Str8_EndsWith(it->basename, S("wav"))) {
+					n_audio += 1;
+				}
+			}
+
+			audio->n_sounds = 0;
+			audio->sounds   = M_ArenaPush(arena, Audio_Data, .count = n_audio);
+
+			for (FS_Entry *it = files.first; it != 0; it = it->next) {
+				if (Str8_EndsWith(it->basename, S("wav"))) {
+					Audio_Data *sound = &audio->sounds[audio->n_sounds];
+
+					U8 *data;
+					U32 count;
+					SDL_AudioSpec wav;
+
+					SDL_LoadWAV((const char *) it->path.data, &wav, &data, &count);
+
+					Assert(wav.freq == 44100);
+
+					sound->samples  = (S16 *) data;
+					sound->n_frames = (count >> 2);
+
+					audio->n_sounds += 1;
+				}
+			}
+
+			audio->n_tracks = 16;
+
+			for (U32 it = 1; it < audio->n_tracks; ++it) {
+				audio->tracks[it].next = it + 1;
+			}
+
+			audio->tracks[audio->n_tracks - 1].next = 0;
+
+			audio->volume = volume;
+			audio->head   = 0;
+			audio->free   = 1;
+
+			printf("--- Loaded %d sounds ---\n", audio->n_sounds);
+		}
+	}
+}
+
+U32 Audio_Play(Audio_Context *audio, U32 index) {
+	U32 result = 0;
+	if (audio->free != 0 && SDL_LockAudioStream(audio->stream)) {
+		result = audio->free;
+
+		Audio_Track *track = &audio->tracks[result];
+		audio->free = track->next;
+
+		track->playing  = true;
+		track->data     = &audio->sounds[index];
+		track->n_played = 0;
+		track->volume   = 1.0f;
+		track->next     = audio->head;
+		audio->head     = result;
+
+		SDL_UnlockAudioStream(audio->stream);
+	}
+
+	return result;
+}
+
+void Audio_ChangeVolume(Audio_Context *audio, U32 handle, F32 volume) {
+	if (SDL_LockAudioStream(audio->stream)) {
+		audio->tracks[handle].volume = volume;
+		SDL_UnlockAudioStream(audio->stream);
+	}
+}

code/os/core.h

@@ -17,5 +17,6 @@ function void  VM_Decommit(void *base, U64 size);
 function void  VM_Release(void *base, U64 size);
 
 #include "filesystem.h"
+#include "audio.h"
 
 #endif  // LD_OS_CORE_H_