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

Playing music

code/core/impl/math.c

@@ -1,8 +1,22 @@
+#include <math.h>
 V2f V2F(F32 x, F32 y) {
 	V2f result = { x, y };
 	return result;
 }
 
+function V2f V2f_Scale(V2f x, F32 scale) {
+  return V2F(x.x * scale, x.y * scale);
+}
+
+V2f NormaliseV2F(V2f x) {
+  F32 magnitude = sqrtf((x.x * x.x) + (x.y * x.y));
+  if(magnitude > 0.0){
+    F32 inverse = 1.0f/magnitude;
+    return V2F(x.x*inverse, x.y*inverse);
+  }
+  return x;
+}
+
 V3f V3F(F32 x, F32 y, F32 z) {
 	V3f result = { x, y, z };
 	return result;
@@ -28,6 +42,16 @@ V3f V3f_Scale(V3f x, F32 s) {
 	return result;
 }
 
+V3f V3f_Sub(V3f a, V3f b) {
+	V3f result = { a.x - b.x, a.y - b.y, a.z - b.z };
+	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;
@@ -140,7 +164,7 @@ Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p) {
 	//
 	V3f ix = V3f_Scale(x, 1.0f / V3f_Dot(x, x));
 	V3f iy = V3f_Scale(y, 1.0f / V3f_Dot(y, y));
-	V3f iz = V3f_Scale(z, 1.0f / V3f_Dot(z, y));
+	V3f iz = V3f_Scale(z, 1.0f / V3f_Dot(z, z));
 
 	// Calculate inverse position
 	//
@@ -203,3 +227,12 @@ F32 Random_Bilateral(Random *rnd) {
 	F32 result = -1.0f + (2.0f * Random_Unilateral(rnd));
 	return result;
 }
+
+V2f V2f_Clip(V2f screen_xy, V2f screen_size) {
+    V2f result;
+    result.x = ((screen_xy.x / screen_size.w) * 2.0f) - 1.0f;
+    result.y = ((screen_xy.y / screen_size.h) * 2.0f) - 1.0f;
+
+    return result;
+}
+

code/core/impl/string.c

@@ -29,6 +29,20 @@ Str8 Str8_WrapZ(U8 *data) {
 	return result;
 }
 
+#define FNV_OFFSET_BIAS ((U64) 0xCBF29CE484222325)
+#define FNV_PRIME       ((U64) 0x100000001B3)
+
+U64 Str8_Hash(Str8 v) {
+	U64 result = FNV_OFFSET_BIAS;
+
+	for (S64 it = 0; it < v.count; ++it) {
+		result ^= v.data[it];
+		result *= FNV_PRIME;
+	}
+
+	return result;
+}
+
 Str8 Str8_Copy(M_Arena *arena, Str8 s) {
 	Str8 result;
 	result.count = s.count;

code/core/macros.h

@@ -36,6 +36,11 @@
 #define SLL_PopN(h, next) (((h) != 0) ? (h) = (h)->next : 0)
 
 #define SLL_Enqueue(h, t, n) SLL_EnqueueN(h, t, n, next)
+#define SLL_EnqueueFront(h, t, n) SLL_EnqueueFrontN(h, t, n, next)
+#define SLL_Dequeue(h, t) SLL_DequeueN(h, t, next)
+
+#define SLL_Push(h, n) SLL_PushN(h, n, next)
+#define SLL_Pop(h) (((h) != 0) ? (h) = (h)->next : 0)
 
 #define function      static
 #define internal      static

code/core/math.h

@@ -4,6 +4,8 @@
 #define PI_F32  (3.14159265358979323846264338f)
 #define TAU_F32 (2.0f * PI_F32)
 
+#define Abs(x) (((x) < 0 ? -(x) : (x)))
+
 typedef struct Random Random;
 struct Random {
 	U64 state;
@@ -98,15 +100,25 @@ struct R2f {
 	V2f max;
 };
 
+typedef struct R3f R3f;
+struct R3f {
+	V3f min;
+	V3f max;
+};
+
 function V2f V2F(F32 x, F32 y);
 function V3f V3F(F32 x, F32 y, F32 z);
 function V4f V4F(F32 x, F32 y, F32 z, F32 w);
 
 function R2f R2F(V2f min, V2f max);
 
+function V2f V2f_Scale(V2f x, F32 s);
+
 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);
 
@@ -119,6 +131,9 @@ function V3f M4x4F_VMul3(Mat4x4F m, V3f v);
 function Mat4x4FInv M4x4F_Perspective(F32 fov, F32 aspect, F32 nearp, F32 farp);
 function Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p);
 
+function V2f NormaliseV2F(V2f x);
+function V2f V2f_Scale(V2f x, F32 scale);
+
 // Random
 
 function Random Random_Seed(U64 seed);
@@ -133,4 +148,6 @@ function U32 Random_U32(Random *rnd, U32 min, U32 max);
 function F32 Random_Unilateral(Random *rnd);
 function F32 Random_Bilateral(Random *rnd);
 
+V2f V2f_Clip(V2f screen_xy, V2f screen_size);
+
 #endif  // LD_CORE_MATH_H_

code/core/string.h

@@ -3,6 +3,7 @@
 
 #define S(x) Str8_Wrap(sizeof(x) - sizeof(*(x)), (U8 *) (x))
 #define Sz(x) Str8_WrapZ((U8 *) (x))
+#define Sl(x) { sizeof(x) - sizeof(*(x)), (U8 *) (x) }
 
 #define Sv(x) (int) (x).count, (x).data
 #define Sf(arena, fmt, ...) Str8_Format(arena, fmt, ##__VA_ARGS__)
@@ -11,6 +12,8 @@ function Str8 Str8_Wrap(S64 count, U8 *data);
 function Str8 Str8_WrapRange(U8 *start, U8 *end);
 function Str8 Str8_WrapZ(U8 *data);
 
+function U64 Str8_Hash(Str8 v);
+
 function Str8 Str8_Copy(M_Arena *arena, Str8 s);
 
 function Str8 Str8_Format(M_Arena *arena, const char *format, ...);

code/core/types.h

@@ -34,4 +34,7 @@ struct Str8 {
 #define U32_MAX ((U32) -1)
 #define U64_MAX ((U64) -1)
 
+#define F32_MAX ((F32) 3.40282346638528859811704183484516925e+038F)
+#define F64_MAX ((F64) 1.79769313486231570814527423731704357e+308L)
+
 #endif  // LD_CORE_TYPES_H_

code/draw/core.c

@@ -1,3 +1,59 @@
+
+U32 D_ImageHandle(D_Context *draw, Str8 name) {
+	U32 result = 0;
+
+	U64 hash  = Str8_Hash(name);
+	U64 index = hash & (D_ASSET_HASH_COUNT - 1);
+
+	D_AssetHash *lookup = draw->lookup[index];
+	while (lookup != 0) {
+		if (lookup->hash == hash && Str8_Equal(lookup->value, name, 0)) {
+			result = lookup->id;
+			break;
+		}
+
+		lookup = lookup->next;
+	}
+
+	return result;
+}
+
+
+void D_AnimationInit(D_Animation *a, U32 id, U32 rows, U32 cols, F32 time) {
+	a->id = id;
+
+	a->rows = rows;
+	a->cols = cols;
+
+	a->time = 0;
+	a->frame_time = time;
+
+	a->frame = V2F(1.0f / (F32) cols, 1.0f / (F32) rows);
+
+	a->index = 0;
+}
+
+R2f D_AnimationFrame(D_Animation *a) {
+	R2f result = { 0 };
+
+	U32 row = a->index / a->cols;
+	U32 col = a->index % a->cols;
+
+	result.min = V2F(a->frame.w * col, a->frame.h * row);
+	result.max = V2F(result.min.x + a->frame.w, result.min.y + a->frame.h);
+	return result;
+}
+
+void D_AnimationUpdate(D_Animation *a, F32 dt) {
+	a->time += dt;
+	if (a->time >= a->frame_time) {
+		a->time   = 0;
+		a->index += 1;
+
+		if (a->index >= (a->rows * a->cols)) { a->index = 0; }
+	}
+}
+
 void D_Begin(D_Context *draw, Vk_Frame *frame, U32 max_rects) {
 	Vk_Buffer *rbo   = &frame->rbo;
 
@@ -30,7 +86,8 @@ void D_End(D_Context *draw, Vk_Frame *frame) {
 		rbo_info.offset = 0;
 		rbo_info.range  = VK_WHOLE_SIZE;
 
-		VkDescriptorImageInfo *image_info = M_ArenaPush(temp.arena, VkDescriptorImageInfo, .count = draw->n_images);
+		U32 total = draw->n_images + draw->n_fonts;
+		VkDescriptorImageInfo *image_info = M_ArenaPush(temp.arena, VkDescriptorImageInfo, .count = total);
 
 		for (U32 it = 0; it < draw->n_images; ++it) {
 			image_info[it].imageView   = draw->images[it].image.view;
@@ -38,6 +95,15 @@ void D_End(D_Context *draw, Vk_Frame *frame) {
 			image_info[it].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 		}
 
+		U32 idx = draw->n_images;
+		for (D_Font *it = draw->fonts; it != 0; it = it->next) {
+			image_info[idx].imageView   = it->image.view;
+			image_info[idx].sampler     = vk.sampler; // @Todo: probably want linear filtering on fonts
+			image_info[idx].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+
+			idx += 1;
+		}
+
 		writes[0].sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writes[0].dstSet          = set;
 		writes[0].dstBinding      = 0;
@@ -48,7 +114,7 @@ void D_End(D_Context *draw, Vk_Frame *frame) {
 		writes[1].sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writes[1].dstSet          = set;
 		writes[1].dstBinding      = 1;
-		writes[1].descriptorCount = draw->n_images;
+		writes[1].descriptorCount = total;
 		writes[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
 		writes[1].pImageInfo      = image_info;
 
@@ -85,6 +151,8 @@ void _D_Rect(D_Context *draw, D_RectOpts *opts) {
 
 		rect->texture = opts->texture;
 
+		F32 w, h;
+
 		rect->x = opts->p.x;
 		rect->y = opts->p.y;
 
@@ -111,22 +179,201 @@ void _D_Rect(D_Context *draw, D_RectOpts *opts) {
 		}
 
 		if (opts->flags & D_RECT_IGNORE_ASPECT) {
-			rect->w = opts->w;
-			rect->h = opts->h;
+			w = opts->dim.w;
+			h = opts->dim.h;
 		}
 		else {
-			Vk_Image *image = &draw->images[opts->texture].image;
-
-			if (image->width > image->height) {
-				rect->w = opts->scale * ((F32) image->width / (F32) image->height);
-				rect->h = opts->scale;
+			Vk_Image *image = 0;
+			if (opts->texture >= draw->n_images) {
+				// @hack: first font texture
+				//
+				image = &draw->fonts->image;
 			}
 			else {
-				rect->w = opts->scale;
-				rect->h = opts->scale * ((F32) image->height / (F32) image->width);
+				image = &draw->images[opts->texture].image;
 			}
+
+			F32 width  = cast(F32) image->width;
+			F32 height = cast(F32) image->height;
+
+			if (opts->flags & D_RECT_UV_ASPECT) {
+				width  *= (opts->uv.max.x - opts->uv.min.x);
+				height *= (opts->uv.max.y - opts->uv.min.y);
+			}
+
+			F32 aspect_w = (width > height) ? 1.0f : (width / height);
+			F32 aspect_h = (width > height) ? (height / width) : 1.0f;
+
+			w = opts->scale * aspect_w;
+			h = opts->scale * aspect_h;
 		}
 
+		if (opts->flags & D_RECT_FLIP_X) { w *= -1.0f; }
+		if (opts->flags & D_RECT_FLIP_Y) { h *= -1.0f; }
+
+		rect->w = w;
+		rect->h = h;
+
 		draw->n_rects += 1;
 	}
 }
+
+void D_Text(D_Context *draw, D_Font *font, Str8 text, F32 x, F32 y) {
+	F32 xoff = x;
+
+	// @Todo: control scale
+	F32 scale = 1.0f / (font->ascent - font->descent);
+
+	for (S64 it = 0; it < text.count; ++it) {
+		if (text.data[it] >= ' ' && text.data[it] <= '~') {
+			D_Glyph *glyph = &font->glyphs[text.data[it] - ' '];
+
+			F32 image_scale = scale * Max(glyph->dim.w, glyph->dim.h);
+			F32 advance     = scale * glyph->advance;
+
+			V2f offset = V2f_Scale(glyph->offset, scale);
+
+			D_Rect(draw, xoff + offset.x, y + offset.y, .texture = font->id, .uv = glyph->box, .scale = image_scale, .flags = D_RECT_UV_ASPECT);
+			xoff += advance;
+		}
+	}
+}
+
+void D_FontLoad(D_Context *draw, Str8 name, F32 size) {
+	M_TempScope(0, 0) {
+		(void) draw;
+
+		Str8 exe_path = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
+		Str8 path = Sf(temp.arena, "%.*s/assets/%.*s.ttf", Sv(exe_path), Sv(name));
+
+		Str8 font_data = FS_ReadEntireFile(temp.arena, path);
+
+		stbtt_fontinfo info = { 0 };
+		stbtt_InitFont(&info, font_data.data, 0);
+
+		F32 scale = stbtt_ScaleForPixelHeight(&info, 256);
+
+		U32 w = 512;
+		U32 h = 512;
+
+		U8 *pixels = M_ArenaPush(temp.arena, U8, .count = (w * h));
+
+		stbtt_pack_context pack = { 0 };
+		stbtt_PackBegin(&pack, pixels, w, h, 0, 1, 0);
+
+		U32 count = '~' - ' ';
+		stbtt_packedchar *packed = M_ArenaPush(temp.arena, stbtt_packedchar, .count = count);
+		stbtt_PackFontRange(&pack, font_data.data, 0, size, ' ', count, packed);
+
+		D_Font *font = M_ArenaPush(draw->arena, D_Font);
+
+		S32 asc, desc, line;
+		stbtt_GetFontVMetrics(&info, &asc, &desc, &line);
+
+		font->line_advance = cast(F32) (scale * line);
+		font->ascent       = cast(F32) (scale * asc);
+		font->descent      = cast(F32) (scale * desc);
+
+		font->glyphs = M_ArenaPush(draw->arena, D_Glyph, .count = count);
+
+		for (U32 it = 0; it < count; ++it) {
+			D_Glyph *glyph = &font->glyphs[it];
+			stbtt_packedchar *chr = &packed[it];
+
+			S32 left, width;
+			stbtt_GetCodepointHMetrics(&info, ' ' + it, &width, &left);
+
+			glyph->box.min = V2F(chr->x0 / (F32) w, chr->y0 / (F32) h);
+			glyph->box.max = V2F(chr->x1 / (F32) w, chr->y1 / (F32) h);
+
+			glyph->advance  = chr->xadvance;
+			glyph->dim.w    = cast(F32) (chr->x1 - chr->x0);
+			glyph->dim.h    = cast(F32) (chr->y1 - chr->y0);
+			glyph->offset.x = (0.5f * glyph->dim.w) + chr->xoff;
+			glyph->offset.y = (0.5f * glyph->dim.h) + chr->yoff;
+		}
+
+		Vk_Buffer *staging = &draw->staging;
+		U32 *px = (U32 *) staging->data;
+		for (U32 y = 0; y < h; ++y) {
+			for (U32 x = 0; x < w; ++x) {
+				*px++ = 0x0 | ((U32) pixels[(y * w) + x] << 24);
+			}
+		}
+
+		Vk_CommandBuffer *cmds = Vk_CommandBufferPush();
+
+		font->id = draw->n_images + draw->n_fonts;
+
+		font->image.width  = w;
+		font->image.height = h;
+
+		font->image.format = VK_FORMAT_R8G8B8A8_SRGB;
+		font->image.usage  = VK_IMAGE_USAGE_SAMPLED_BIT;
+
+		Vk_ImageCreate(&font->image);
+
+		VkBufferImageCopy copy = { 0 };
+
+		copy.bufferOffset      = 0;
+		copy.bufferRowLength   = 0;
+		copy.bufferImageHeight = 0;
+
+		copy.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
+		copy.imageSubresource.mipLevel       = 0;
+		copy.imageSubresource.baseArrayLayer = 0;
+		copy.imageSubresource.layerCount     = 1;
+
+		copy.imageExtent.width  = w;
+		copy.imageExtent.height = h;
+		copy.imageExtent.depth  = 1;
+
+		VkImageMemoryBarrier2 transfer = { 0 };
+		VkImageMemoryBarrier2 shader_read = { 0 };
+
+		transfer.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+		transfer.srcStageMask  = VK_PIPELINE_STAGE_2_NONE;
+		transfer.srcAccessMask = VK_ACCESS_2_NONE;
+		transfer.dstStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+		transfer.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
+		transfer.oldLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
+		transfer.newLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		transfer.image         = font->image.handle;
+
+		transfer.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		transfer.subresourceRange.layerCount = 1;
+		transfer.subresourceRange.levelCount = 1;
+
+		shader_read.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+		shader_read.srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+		shader_read.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
+		shader_read.dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
+		shader_read.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
+		shader_read.oldLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+		shader_read.newLayout     = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+		shader_read.image         = font->image.handle;
+
+		shader_read.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+		shader_read.subresourceRange.layerCount = 1;
+		shader_read.subresourceRange.levelCount = 1;
+
+		VkDependencyInfo dep = { 0 };
+		dep.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+
+		dep.imageMemoryBarrierCount = 1;
+		dep.pImageMemoryBarriers    = &transfer;
+
+		vk.CmdPipelineBarrier2(cmds->handle, &dep);
+
+		vk.CmdCopyBufferToImage(cmds->handle, staging->handle, font->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+
+		dep.pImageMemoryBarriers = &shader_read;
+
+		vk.CmdPipelineBarrier2(cmds->handle, &dep);
+
+		Vk_CommandBufferSubmit(cmds, true);
+
+		SLL_PushN(draw->fonts, font, next);
+		draw->n_fonts += 1;
+	}
+}

code/draw/core.h

@@ -3,6 +3,32 @@
 
 #define D_MAX_RECTS (262144)
 
+typedef struct D_Glyph D_Glyph;
+struct D_Glyph {
+	F32 advance;
+
+	V2f offset;
+	V2f dim;
+
+	R2f box;
+};
+
+typedef struct D_Font D_Font;
+struct D_Font {
+	D_Font *next;
+
+	U32 id;
+
+	F32 line_advance;
+	F32 ascent;
+	F32 descent;
+
+	F32     *kerning; // @incomplete: we don't load this
+	D_Glyph *glyphs;
+
+	Vk_Image image;
+};
+
 typedef struct D_Image D_Image;
 struct D_Image {
 	Str8     name;
@@ -25,11 +51,39 @@ struct D_Rect {
 
 StaticAssert(sizeof(D_Rect) == 64);
 
+typedef struct D_Animation D_Animation;
+struct D_Animation {
+	U32 id;
+
+	U32 rows;
+	U32 cols;
+	F32 frame_time;
+	F32 time;
+
+	V2f frame; // size of one frame
+
+	U32 index;
+};
+
 struct G_Camera;
 
+#define D_ASSET_HASH_COUNT 128
+
+typedef struct D_AssetHash D_AssetHash;
+struct D_AssetHash {
+	D_AssetHash *next;
+
+	Str8 value;
+	U64  hash;
+	U32  id; // texture id
+};
+
 typedef struct D_Context D_Context;
 struct D_Context {
 	Vk_Buffer *rbo;
+	Vk_Buffer staging;
+
+	M_Arena *arena;
 
 	U32 n_pipelines;
 	Vk_Pipeline *pipelines;
@@ -37,6 +91,9 @@ struct D_Context {
 	U32 n_images;
 	D_Image *images;
 
+	U32 n_fonts;
+	D_Font *fonts;
+
 	U32 max_rects;
 	U32 n_rects;
 	D_Rect *rects;
@@ -44,6 +101,8 @@ struct D_Context {
 	U32 window_width;
 	U32 window_height;
 
+	D_AssetHash *lookup[D_ASSET_HASH_COUNT];
+
 	struct G_Camera *camera;
 };
 
@@ -51,6 +110,9 @@ typedef U32 D_RectFlags;
 enum D_RectFlags {
 	D_RECT_IGNORE_ASPECT     = (1 << 0), // by default only width is used as a "dimension"
 	D_RECT_PER_VERTEX_COLOUR = (1 << 1), // split colours per vertex
+	D_RECT_UV_ASPECT         = (1 << 2), // get the aspect from the uv rect rather than the full image
+	D_RECT_FLIP_X            = (1 << 3),
+	D_RECT_FLIP_Y            = (1 << 4)
 };
 
 typedef struct D_RectOpts D_RectOpts;
@@ -65,9 +127,15 @@ struct D_RectOpts {
 	F32 angle;
 
 	union {
-		F32 w, h;
-		F32 scale, _h;
 		V2f dim;
+
+		struct {
+			F32 w, h;
+		};
+
+		struct {
+			F32 scale, _h;
+		};
 	};
 
 	union {
@@ -76,10 +144,20 @@ struct D_RectOpts {
 	};
 };
 
+function U32 D_ImageHandle(D_Context *draw, Str8 name);
+
+function void D_AnimationInit(D_Animation *a, U32 id, U32 rows, U32 cols, F32 time);
+function R2f  D_AnimationFrame(D_Animation *a);
+function void D_AnimationUpdate(D_Animation *a, F32 dt);
+
 function void D_Begin(D_Context *draw, Vk_Frame *frame, U32 max_rects);
 function void D_End(D_Context *draw, Vk_Frame *frame);
 
+function void D_Text(D_Context *draw, D_Font *font, Str8 text, F32 x, F32 y);
+
 function void _D_Rect(D_Context *draw, D_RectOpts *opts);
 #define D_Rect(draw, x, y, ...) _D_Rect(draw, &(D_RectOpts) { .p = V2F(x, y), .uv = R2F(V2F(0, 0), V2F(1, 1)), .scale = 1, .c = V4F(1, 1, 1, 1), ##__VA_ARGS__ })
 
+function void D_FontLoad(D_Context *draw, Str8 path, F32 size);
+
 #endif  // LD_DRAW_CORE_H_

code/first.c

@@ -1,13 +1,19 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <SDL3/SDL.h>
+#include <SDL3/SDL_keycode.h>
 
 #define STB_IMAGE_IMPLEMENTATION 1
 #include <stb_image.h>
 
+#define STB_RECT_PACK_IMPLEMENTATION 1
+#include <stb_rect_pack.h>
+
+#define STB_TRUETYPE_IMPLEMENTATION 1
+#include <stb_truetype.h>
+
 #include "core/core.h"
 #include "core/types.h"
-#include "game/npc.h"
 #include "os/core.h"
 
 #include "vulkan/core.h"
@@ -17,14 +23,15 @@
 
 #include "game/impl/world.c"
 #include "game/impl/npc.c"
-#include "game/testnavmesh.h"
+#include "game/impl/bandit.c"
+#include "game/impl/outfit.c"
 
 int main(int argc, char **argv)
 {
-	(void)argc;
-	(void)argv;
+	(void) argc;
+	(void) argv;
 
-	if (!SDL_Init(SDL_INIT_VIDEO))
+	if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO))
 	{
 		printf("[Error] :: Failed to initialise SDL3 (%s)\n", SDL_GetError());
 		return 1;
@@ -44,10 +51,22 @@ int main(int argc, char **argv)
 		M_Arena *arena = M_ArenaAlloc(GB(64), .initial = MB(4));
 		game = M_ArenaPush(arena, G_State);
 
-		game->arena = arena;
+		game->arena      = arena;
+		game->draw.arena = arena;
 
 		G_ImagesLoad(game);
+		//D_FontLoad(&game->draw, S("ubuntu"), 60);
+
 		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;
 
@@ -63,44 +82,150 @@ int main(int argc, char **argv)
 
 		game->draw.camera = camera;
 		World *world = M_ArenaPush(arena, World);
-		game->world = world;
-		world->random = Random_Seed(29237489723847);
-		world->npcCount = 2;
-		NPC *npc1 = &world->npcs[0];
-		npc1->collision.pos.x = 15;
-		npc1->collision.pos.y = 15;
-		npc1->collision.size.x = 10;
-		npc1->collision.size.y = 10;
-		npc1->name = S("Matt");
-		npc1->mode = NPC_ACTION_WAITING;
-		npc1->waitTime = 0;
-		npc1->maxWaitTime = 5;
-		npc1->currentNavNode = 87;
-		npc1->collision.pos.x = 15;
-		npc1->collision.pos.y = 15;
-		npc1->collision.size.x = 10;
-		npc1->collision.size.y = 10;
+    LoadWorld(arena, world);
+    game->world = world;
 
-		NPC *npc2 = &world->npcs[1];
-		npc2->collision.pos.x = 15;
-		npc2->collision.pos.y = 15;
-		npc2->collision.size.x = 10;
-		npc2->collision.size.y = 10;
-		npc2->name = S("James");
-		npc2->mode = NPC_ACTION_WAITING;
-		npc2->waitTime = 0;
-		npc2->maxWaitTime = 10;
-		npc2->currentNavNode = 0;
+		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;
+    for(U32 i = 0; i < world->npcCount; i++) {
+      NPC *npc1 = &world->npcs[i];
+      npc1->collision.pos.x = 0;
+      npc1->collision.pos.y = 0;
+      npc1->collision.size.x = 1;
+      npc1->collision.size.y = 2;
+      npc1->name = S("Matt");
+      npc1->mode = NPC_ACTION_WAITING;
+      npc1->currentArea = WORLD_AREA_OUTSIDE;
+      npc1->waitTime = 0;
+      npc1->maxWaitTime = 1;
+      npc1->currentNavNode = 0;
+      GenOutfit(&npc1->outfit,world,game);
+    }
+
+    Bandit *badman = &world->bandit;
+		badman->collision.pos.x = 15;
+		badman->collision.pos.y = 15;
+		badman->collision.size.x = 1;
+		badman->collision.size.y = 2;
+		badman->name = S("Leroy Brown");
+		badman->mode = BANDIT_WAITING;
+		badman->waitTime = 0;
+		badman->maxWaitTime = 2;
+		badman->poiCount = 2;
+		badman->shootoutTimer = 1.5;
+		badman->agroRadius = 6.0;
+    badman->bullets = 6;
+    badman->shootDelay = 1;
+    badman->accuracyRange = 0.25;
+    badman->reloadTime = 2.5;
+    badman->reloadTimer = 0;
+    badman->pointsOfInterest[0] = 937;
+    badman->pointsOfInterest[1] = 12;
+    badman->outfitChoices = GenOutfit(&badman->outfit, world, game);
+    badman->currentArea = WORLD_AREA_OUTSIDE;
 
-		world->navMesh = &TestNavMesh;
 		world->npcPOI[0] = 100;
-		world->player.pos.x = 0;
-		world->player.pos.y = 0;
+
+		PlayerInit(game, &world->player);
+
+    world->tileTypes = M_ArenaPush(arena, World_Tile, .count=WORLD_TILE_TYPE_MAX);
+    world->tileTypes[0].rotation=0;
+    world->tileTypes[0].tag=S("tile_dirt_0");
+    world->tileTypes[1].rotation=0,
+    world->tileTypes[1].tag=S("path_middle");
+    world->tileTypes[2].rotation=0;
+    world->tileTypes[2].tag=S("path_middle_edge");
+    world->tileTypes[3].rotation=PI_F32/2;
+    world->tileTypes[3].tag=S("path_middle_edge");
+    world->tileTypes[4].rotation=PI_F32;
+    world->tileTypes[4].tag=S("path_middle_edge");
+    world->tileTypes[5].rotation=-PI_F32/2;
+    world->tileTypes[5].tag=S("path_middle_edge");
+    world->tileTypes[6].rotation=0;
+    world->tileTypes[6].tag=S("path_middle");
+    world->tileTypes[7].rotation=PI_F32/2;
+    world->tileTypes[7].tag=S("path_middle");
+    world->tileTypes[8].rotation=-PI_F32;
+    world->tileTypes[8].tag=S("path_middle");
+    world->tileTypes[9].rotation=-PI_F32/2;
+    world->tileTypes[9].tag=S("path_middle");
+    world->tileTypes[10].rotation=0;
+    world->tileTypes[10].tag=S("path_corner");
+    world->tileTypes[11].rotation=PI_F32/2;
+    world->tileTypes[11].tag=S("path_corner");
+    world->tileTypes[12].rotation=-PI_F32/2;
+    world->tileTypes[12].tag=S("path_corner");
+    world->tileTypes[13].rotation=PI_F32;
+    world->tileTypes[13].tag=S("path_corner");
+    world->tileTypes[14].rotation=0;
+    world->tileTypes[14].tag=S("tile_dirt_1");
+
+    world->propTypes = M_ArenaPush(arena, World_PropType, .count=WORLD_PROP_TYPE_MAX);
+    world->propTypes[0].tag=S("rug0");
+    world->propTypes[0].scale=3;
+    world->propTypes[1].tag=S("rug1");
+    world->propTypes[1].scale=3;
+    world->propTypes[2].tag=S("skull");
+    world->propTypes[2].scale=1;
+    world->propTypes[3].tag = S("table");
+    world->propTypes[3].scale=2;
+    world->propTypes[4].tag = S("barrel");
+    world->propTypes[4].scale=1;
+    world->propTypes[5].tag = S("can");
+    world->propTypes[5].scale=0.5;
+    world->propTypes[6].tag = S("candle");
+    world->propTypes[6].scale=0.5;
+    world->propTypes[7].tag = S("clock");
+    world->propTypes[7].scale=1.5;
+    world->propTypes[8].tag = S("log_pile");
+    world->propTypes[8].scale=1;
+    world->propTypes[9].tag = S("nightstand");
+    world->propTypes[9].scale=1;
+    world->propTypes[10].tag = S("pool_table");
+    world->propTypes[10].scale=3;
+    world->propTypes[11].tag = S("saloon_ext");
+    world->propTypes[11].scale=6.875f;
+    world->propTypes[12].tag = S("saloon_int");
+    world->propTypes[12].scale=2*6.875f;
+    world->propTypes[13].tag = S("house");
+    world->propTypes[13].scale=6.875f;
+    world->propTypes[14].tag = S("house_int");
+    world->propTypes[14].scale=12.875f;
+    world->propTypes[15].tag=S("tile_detail_0");
+    world->propTypes[15].scale=1;
+    world->propTypes[16].tag =  S("tile_detail_1");
+    world->propTypes[16].scale=1;
+    world->propTypes[17].tag = S("tile_detail_2");
+    world->propTypes[17].scale=1;
+    world->propTypes[18].tag= S("tile_detail_3");
+    world->propTypes[18].scale=1;
+    world->propTypes[19].tag= S("tile_detail_4");
+    world->propTypes[19].scale=1;
+    world->propTypes[20].tag=S("tile_detail_5");
+    world->propTypes[20].scale=1;
+    world->propTypes[21].tag=S("tile_detail_6");
+    world->propTypes[21].scale=1;
+    world->propCount = 0;
+    world->props = M_ArenaPush(arena, World_Prop, .count=WORLD_PROP_MAX);
+    world->hitboxes = M_ArenaPush(arena, World_Hitbox, .count=WORLD_HITBOX_MAX);
+    world->portals = M_ArenaPush(arena, World_Portal, .count=64);
+    world->portalCount=0;
+    GenerateNavMesh(arena, world);
 	}
+  game->editor.enabled = true;
+  game->editor.mode = G_EDITOR_MODE_TILE;
+  game->editor.currentLevel = WORLD_AREA_OUTSIDE;
+  game->editor.selectedNode = 0;
 
 	bool running = true;
 
-	printf("%zu size in bytes\n", sizeof(TestNavMesh));
+	const int width  = 1280;
+	const int height = 720;
 
 	while (running)
 	{
@@ -111,9 +236,146 @@ int main(int argc, char **argv)
 			{
 				running = false;
 			}
-			ProcessEvents(&e, game->world);
+			else if (e.type == SDL_EVENT_KEY_DOWN) {
+				Player *player = &game->world->player;
+				switch (e.key.key) {
+					case SDLK_R:  { PlayerInit(game, player); } break;
+          case SDLK_F: {game->world->showPoster=!game->world->showPoster;}break;
+				}
+			}
+
+      V3f projection = G_CameraUnproject(&game->camera, V2f_Clip(
+        V2F(e.button.x, e.button.y),
+        V2F((F32) width, (F32) height)
+      ));
+      game->world->mouseProjected = V2F(projection.x, projection.y);
+      if(e.type==SDL_EVENT_MOUSE_MOTION) {
+        game->editor.cursor = V2F(projection.x, projection.y);
+      }
+      if (!game->editor.enabled) {
+        ProcessEvents(&e, game->world);
+      } else {
+        if(e.type==SDL_EVENT_MOUSE_BUTTON_DOWN && e.button.button == SDL_BUTTON_LEFT) {
+          switch(game->editor.mode){
+            case G_EDITOR_MODE_TILE: {
+              F32 tilex = (F32) (S32)(game->editor.cursor.x+TILE_SIZE/2);
+              F32 tiley = (F32) (S32)(game->editor.cursor.y+TILE_SIZE/2);
+              game->world->map[(S32)tilex + (S32)tiley * 96] = game->editor.currentAsset;
+              break;
+            }
+            case G_EDITOR_MODE_PROP: {
+              game->world->props[game->world->propCount].propType = game->editor.currentAsset;
+              game->world->props[game->world->propCount].area = game->editor.currentLevel;
+              game->world->props[game->world->propCount].pos = game->editor.cursor;
+              game->world->propCount++;
+              break;
+            }
+            case G_EDITOR_MODE_HITBOX: {
+            case G_EDITOR_MODE_PORTAL: {
+              game->editor.dragStart = game->editor.cursor;
+              break;
+            }
+          }
+        }} else if(e.type==SDL_EVENT_MOUSE_BUTTON_UP && e.button.button == SDL_BUTTON_LEFT && game->editor.mode == G_EDITOR_MODE_HITBOX) {
+          // Add hitbox
+          V2f topLeft = V2F(Min(game->editor.cursor.x, game->editor.dragStart.x), Min(game->editor.cursor.y, game->editor.dragStart.y));
+          game->world->hitboxes[game->world->hitboxCount].box.pos = topLeft;
+          game->world->hitboxes[game->world->hitboxCount].box.size = V2F(
+            Abs(game->editor.cursor.x-game->editor.dragStart.x),
+            Abs(game->editor.cursor.y-game->editor.dragStart.y)
+          );
+          game->world->hitboxes[game->world->hitboxCount].area = game->editor.currentAsset;
+          game->world->hitboxCount++;
+          GenerateNavMesh(game->arena, game->world);
+        } else if(e.type==SDL_EVENT_MOUSE_BUTTON_UP && e.button.button == SDL_BUTTON_LEFT && game->editor.mode == G_EDITOR_MODE_PORTAL) {
+          // Add portal
+          V2f topLeft = V2F(Min(game->editor.cursor.x, game->editor.dragStart.x), Min(game->editor.cursor.y, game->editor.dragStart.y));
+          game->world->portals[game->world->portalCount].box.pos = topLeft;
+          game->world->portals[game->world->portalCount].box.size = V2F(
+            Abs(game->editor.cursor.x-game->editor.dragStart.x),
+            Abs(game->editor.cursor.y-game->editor.dragStart.y)
+          );
+          game->world->portals[game->world->portalCount].area = game->editor.currentAsset;
+          game->world->portalCount++;
+          GenerateNavMesh(game->arena, game->world);
+        }
+      }
+
+      if (e.type == SDL_EVENT_KEY_DOWN) {
+        switch(e.key.key) {
+          case SDLK_F10: {
+            game->editor.enabled = !game->editor.enabled;
+            break;
+          }
+          case SDLK_RIGHT: {
+            game->editor.currentAsset = Min(game->editor.currentAsset+1, 64);
+            printf("editing with %d\n", game->editor.currentAsset);
+            break;
+          }
+          case SDLK_LEFT: {
+            game->editor.currentAsset = Max(game->editor.currentAsset-1, 0);
+            printf("editing with %d\n", game->editor.currentAsset);
+            break;
+          }
+          case SDLK_A: {
+            game->camera.p.x -= 5;
+            break;
+          }
+          case SDLK_D: {
+            game->camera.p.x += 5;
+            break;
+          }
+          case SDLK_W: {
+            game->camera.p.y -= 5;
+            break;
+          }
+          case SDLK_S: {
+            game->camera.p.y += 5;
+            break;
+          }
+          case SDLK_UP: {
+            game->editor.currentLevel++;
+            game->world->player.currentArea++;
+            break;
+          }
+          case SDLK_DOWN: {
+            game->editor.currentLevel--;
+            game->world->player.currentArea--;
+            break;
+          }
+          case SDLK_E: {
+            game->editor.selectedNode++;
+            printf("selected %d\n", game->editor.selectedNode);
+            break;
+          }
+          case SDLK_Q: {
+            game->editor.selectedNode--;
+            printf("selected %d\n", game->editor.selectedNode);
+            break;
+          }
+          case SDLK_SPACE: {
+            game->editor.mode = (game->editor.mode + 1) % 4;
+            printf("EDITOR MODE %d\n", game->editor.mode);
+            break;
+          }
+          case SDLK_U: {
+            switch(game->editor.mode) {
+              case G_EDITOR_MODE_PROP: {game->world->propCount--;}
+              case G_EDITOR_MODE_HITBOX: {game->world->hitboxCount--;}
+              case G_EDITOR_MODE_PORTAL: {game->world->portalCount--;}
+            }
+            break;
+          }
+        }
+      }
 		}
-		UpdateWorld(1.0 / 60.0, game->world);
+
+    if(!game->editor.enabled) {
+		  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;
+    }
 
 		int w, h;
 		SDL_GetWindowSizeInPixels(window, &w, &h);
@@ -127,7 +389,7 @@ int main(int argc, char **argv)
 		VkCommandBuffer cmd = frame->cmd;
 
 		VkClearValue clear_colour;
-		clear_colour.color.float32[0] = 1.0f;
+		clear_colour.color.float32[0] = 0.0f;
 		clear_colour.color.float32[1] = 0.0f;
 		clear_colour.color.float32[2] = 0.0f;
 		clear_colour.color.float32[3] = 1.0f;
@@ -151,10 +413,103 @@ int main(int argc, char **argv)
 
 		D_Begin(&game->draw, frame, D_MAX_RECTS);
 
-		D_Rect(&game->draw, 0.0f, 0.0f, .texture = 1);
-		D_Rect(&game->draw, -8.0f, 0.0f, .texture = 2, .scale = 2.0f);
-		D_Rect(&game->draw, 6.0f, 0.0f, .texture = 3);
 
+    RenderWorld(game->world, &game->draw);
+
+		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 (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);
+
+    if(game->editor.enabled) {
+      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 (U32 i = 0; i < game->world->navMesh->nodeCount; i++) {
+        NavNode n = game->world->navMesh->nodes[i];
+        D_Rect(
+          &game->draw,
+          n.pos.x,
+          n.pos.y,
+          .texture = 0,
+          .scale = 0.2f,
+        );
+      }
+      for (U32 i = 0; i < game->world->navMesh->nodeCount; i++) {
+        NavNode n = game->world->navMesh->nodes[i];
+        if(i == editor.selectedNode) {
+          D_Rect(
+            &game->draw,
+            n.pos.x,
+            n.pos.y,
+            .texture = 0,
+            .scale = 0.2f,
+            .c = V4F(100, 255, 0, 100),
+          );
+          for(int j = 0; j < n.connectionCount; j++) {
+            D_Rect(
+              &game->draw,
+              game->world->navMesh->nodes[n.connections[j].NodeIndex].pos.x,
+              game->world->navMesh->nodes[n.connections[j].NodeIndex].pos.y,
+              .texture = 0,
+              .scale = 0.2f,
+              .c = V4F(0, 100, 0, 100),
+            );
+          }
+        }
+      }
+      switch(game->editor.mode) {
+        case G_EDITOR_MODE_TILE: {
+          World_Tile asset = game->world->tileTypes[editor.currentAsset];
+		      D_Rect(&game->draw, tilex, tiley, .texture=D_ImageHandle(&game->draw, asset.tag), .angle=asset.rotation);
+          break;
+        }
+        case G_EDITOR_MODE_PROP: {
+          World_PropType prop = game->world->propTypes[editor.currentAsset];
+		      D_Rect(&game->draw, editor.cursor.x, editor.cursor.y, .texture=D_ImageHandle(&game->draw, prop.tag), .scale=prop.scale);
+          break;
+        }
+        case G_EDITOR_MODE_HITBOX: {
+          for(U32 i = 0; i < game->world->hitboxCount; i++) {
+            if(game->world->player.currentArea == game->world->hitboxes[i].area) {
+              V2f centre = AABB_Centre(game->world->hitboxes[i].box);
+              D_Rect(
+                &game->draw,
+                centre.x,
+                centre.y,
+                .texture=0,
+                .dim=game->world->hitboxes[i].box.size,
+                .flags=D_RECT_IGNORE_ASPECT,
+                .c=V4F(100,0,0,0.7f),
+              );
+            }
+          }
+          break;
+        }
+        case G_EDITOR_MODE_PORTAL: {
+          for(U32 i = 0; i < game->world->portalCount; i++) {
+            V2f centre = AABB_Centre(game->world->portals[i].box);
+		        D_Rect(
+              &game->draw,
+              centre.x,
+              centre.y,
+              .texture=0,
+              .dim=game->world->portals[i].box.size,
+              .flags=D_RECT_IGNORE_ASPECT,
+              .c=V4F(0,0,100,0.7f),
+            );
+          }
+          break;
+        }
+      }
+    }
 		D_End(&game->draw, frame);
 
 		vk.CmdEndRendering(cmd);

code/game/aabb.h

@@ -13,5 +13,7 @@ struct AABB
 function bool AABB_Collide(AABB a, AABB b);
 function bool AABB_Point(AABB a, V2f v);
 function bool AABB_Slab(V2f origin, V2f point, AABB a);
+function V2f AABB_Centre(AABB a);
+function bool AABB_Circle(F32 rad, V2f radOrigin, AABB a);
 
 #endif // LD_GAME_AABB_H_

code/game/bandit.h

@@ -1,11 +1,14 @@
 #if !defined(LD_GAME_BANDIT_H_)
 #define LD_GAME_BANDIT_H_
+#include "outfit.h"
 
 typedef enum BANDIT_ACTION BANDIT_ACTION;
-enum BANDIT_ACTION {
+enum BANDIT_ACTION
+{
   BANDIT_WAITING,
   BANDIT_WALKING,
   BANDIT_RUNNING,
+  BANDIT_SHOOTING,
   BANDIT_SHOOTOUT,
 };
 
@@ -14,6 +17,7 @@ struct Bandit {
   //// Personal
   AABB collision;
   Str8 name;
+  World_Area currentArea;
 
   //// Actions
   BANDIT_ACTION mode;
@@ -22,6 +26,7 @@ struct Bandit {
   // How long they will wait in this location.
   F32 maxWaitTime;
 
+  U32 poiCount;
   // Places the bandit walks to / from
   // E.g. hide outs, home, saloon
   U32 pointsOfInterest[12];
@@ -48,12 +53,22 @@ struct Bandit {
   F32 shootDelay;
   // After each shot this is set to shootDelay;
   F32 shootCooldownTimer;
+  // Countdown to shootout
+  F32 shootoutTimer;
   // How long it takes them to reload.
   F32 reloadTime;
+  // When gun is empty this is set to reloadTime.
+  F32 reloadTimer;
   // Accuracy, their shots can vary between this angle either side (rads)
   F32 accuracyRange;
   // A the circle around the bandit where they will trigger the quicktime reaction scene
   F32 agroRadius;
+  // What the bandit is wearing
+  G_Outfit outfit;
+  // What the bandit's outfit id's are
+  U32 *outfitChoices;
 };
 
+function V2f ShootTowards(Bandit* bandit, V2f target, Random* r);
+function void BanditDraw(D_Context *draw, Bandit *bandit);
 #endif  // LD_GAME_BANDIT_H_

code/game/core.c

@@ -1,5 +1,18 @@
 // @Todo:  These should move to draw/core.c
 //
+internal void G_AssetNameHash(D_Context *draw, Str8 name, U32 id) {
+	D_AssetHash *result = M_ArenaPush(draw->arena, D_AssetHash);
+
+	U64 hash  = Str8_Hash(name);
+	U64 index = hash & (D_ASSET_HASH_COUNT - 1);
+
+	result->value = name;
+	result->hash  = hash;
+	result->id    = id;
+
+	SLL_Push(draw->lookup[index], result);
+}
+
 void G_ImagesLoad(G_State *game) {
 	M_TempScope(0, 0) {
 		D_Context *draw = &game->draw;
@@ -9,14 +22,14 @@ void G_ImagesLoad(G_State *game) {
 
 		FS_List assets = FS_PathList(temp.arena, path);
 
-		Vk_Buffer staging = { 0 };
-		staging.size         = MB(256);
-		staging.usage        = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-		staging.host_visible = true;
+		Vk_Buffer *staging = &draw->staging;
+		staging->size         = MB(256);
+		staging->usage        = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+		staging->host_visible = true;
 
-		Vk_BufferCreate(&staging);
+		Vk_BufferCreate(staging);
 
-		U8 *base   = staging.data;
+		U8 *base   = staging->data;
 		U64 offset = 0;
 
 		Vk_CommandBuffer *cmds = Vk_CommandBufferPush();
@@ -59,6 +72,9 @@ void G_ImagesLoad(G_State *game) {
 
 			white->name = S("_WHITE");
 
+			// This doesn't _really_ need one because its just zero and always will be zero
+			G_AssetNameHash(draw, white->name, 0);
+
 			white->image.width  = 2;
 			white->image.height = 2;
 			white->image.format = VK_FORMAT_R8G8B8A8_SRGB;
@@ -71,7 +87,7 @@ void G_ImagesLoad(G_State *game) {
 			// and submitting them in one go. It doesn't really matter for now
 			//
 
-			VkImageMemoryBarrier2 transfer = { 0 };
+			VkImageMemoryBarrier2 transfer    = { 0 };
 			VkImageMemoryBarrier2 shader_read = { 0 };
 
 			transfer.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
@@ -108,7 +124,7 @@ void G_ImagesLoad(G_State *game) {
 
 			vk.CmdPipelineBarrier2(cmds->handle, &dep);
 
-			vk.CmdCopyBufferToImage(cmds->handle, staging.handle, white->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+			vk.CmdCopyBufferToImage(cmds->handle, staging->handle, white->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
 
 			dep.pImageMemoryBarriers = &shader_read;
 
@@ -145,12 +161,13 @@ void G_ImagesLoad(G_State *game) {
 					base   += image_sz;
 					offset += image_sz;
 
-					Assert(offset <= staging.size);
-
-					draw->n_images += 1;
+					Assert(offset <= staging->size);
 
 					image->name = Str8_Copy(game->arena, Str8_RemoveAfterLast(it->basename, '.'));
 
+					G_AssetNameHash(draw, image->name, draw->n_images);
+
+					draw->n_images += 1;
 					printf("[Info] :: Loaded %.*s from %.*s\n", Sv(image->name), Sv(it->basename));
 
 					image->image.width  = w;
@@ -198,7 +215,7 @@ void G_ImagesLoad(G_State *game) {
 
 					vk.CmdPipelineBarrier2(cmds->handle, &dep);
 
-					vk.CmdCopyBufferToImage(cmds->handle, staging.handle, image->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+					vk.CmdCopyBufferToImage(cmds->handle, staging->handle, image->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
 
 					dep.pImageMemoryBarriers = &shader_read;
 
@@ -251,7 +268,7 @@ void G_PipelinesLoad(G_State *game) {
 
 		bindings[1].binding         = 1;
 		bindings[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-		bindings[1].descriptorCount = game->draw.n_images;
+		bindings[1].descriptorCount = game->draw.n_images + game->draw.n_fonts;
 		bindings[1].stageFlags      = VK_SHADER_STAGE_FRAGMENT_BIT;
 
 		VkDescriptorSetLayoutCreateInfo set_info = { 0 };
@@ -290,6 +307,22 @@ void G_PipelinesLoad(G_State *game) {
 	Vk_PipelineCreate(basic);
 }
 
+void G_AudioLoad(G_State *game) {
+	(void) game;
+
+	M_TempScope(0, 0) {
+		Str8 exe_path = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
+		Str8 path     = Sf(temp.arena, "%.*s/assets", Sv(exe_path));
+
+		FS_List assets = FS_PathList(temp.arena, path);
+
+		// @Incomplete: finish this
+
+		for (FS_Entry *it = assets.first; it != 0; it = it->next) {
+		}
+	}
+}
+
 void G_CalculateCamera(G_Camera *camera, F32 aspect) {
 	Mat4x4FInv proj = M4x4F_Perspective(camera->fov, aspect, camera->nearp, camera->farp);
 	Mat4x4FInv view = M4x4F_CameraView(camera->x, camera->y, camera->z, camera->p);
@@ -298,6 +331,32 @@ void G_CalculateCamera(G_Camera *camera, F32 aspect) {
 	camera->proj.inv = M4x4F_Mul(view.inv, proj.inv);
 }
 
+V3f G_CameraUnprojectAt(G_Camera *camera, V2f clip, F32 z) {
+	V3f dir    = V3f_Sub(camera->p, V3f_Scale(camera->z, z));
+	V4f z_dist = V4F(dir.x, dir.y, dir.z, 1.0f);
+	V4f persp  = M4x4F_VMul4(camera->proj.fwd, z_dist);
+
+	clip = V2f_Scale(clip, persp.w);
+
+	V4f world = M4x4F_VMul4(camera->proj.inv, V4F(clip.x, clip.y, persp.z, persp.w));
+
+	V3f result = world.xyz;
+	return result;
+}
+
+V3f G_CameraUnproject(G_Camera *camera, V2f clip) {
+	V3f result = G_CameraUnprojectAt(camera, clip, camera->p.z);
+	return result;
+}
+
+R3f G_CameraBounds(G_Camera *camera) {
+	R3f result;
+	result.min = G_CameraUnproject(camera, V2F(-1, -1));
+	result.max = G_CameraUnproject(camera, V2F( 1,  1));
+
+	return result;
+}
+
 #include "impl/aabb.c"
 #include "impl/nav.c"
 #include "impl/player.c"

code/game/core.h

@@ -1,6 +1,7 @@
 #if !defined(LD_GAME_CORE_H_)
 #define LD_GAME_CORE_H_
-#include "world.h"
+
+typedef struct World World;
 
 typedef struct G_Camera G_Camera;
 struct G_Camera {
@@ -13,6 +14,27 @@ struct G_Camera {
 	Mat4x4FInv proj;
 };
 
+#define TILE_SIZE 1.0
+
+typedef enum G_EDITOR_MODE G_EDITOR_MODE;
+enum G_EDITOR_MODE {
+  G_EDITOR_MODE_TILE,
+  G_EDITOR_MODE_PROP,
+  G_EDITOR_MODE_HITBOX,
+  G_EDITOR_MODE_PORTAL,
+};
+
+typedef struct G_Editor G_Editor;
+struct G_Editor {
+  bool enabled;
+  U32 currentLevel;
+  S32 currentAsset;
+  G_EDITOR_MODE mode;
+  V2f cursor;
+  V2f dragStart;
+  U32 selectedNode;
+};
+
 typedef struct G_State G_State;
 struct G_State {
 	M_Arena *arena;
@@ -20,14 +42,65 @@ struct G_State {
 	D_Context draw;
 	G_Camera camera;
 
+  G_Editor editor;
   World *world;
 };
 
+typedef U32 G_OutfitDirection;
+enum {
+	G_OUTFIT_DIR_FRONT = 0,
+	G_OUTFIT_DIR_SIDE,
+	G_OUTFIT_DIR_BACK,
+
+	G_OUTFIT_DIR_FLIPPED = (1 << 16)
+};
+
+typedef union G_OutfitSet G_OutfitSet;
+union G_OutfitSet {
+	struct {
+		U32 base;
+		U32 eyes;
+		U32 face;
+		U32 hair;
+		U32 hat;
+		U32 shirt;
+		U32 shoes;
+		U32 trousers;
+	};
+
+	U32 e[8];
+};
+
+typedef struct G_Outfit G_Outfit;
+struct G_Outfit {
+	D_Animation state; // .id in here isn't used for drawing
+
+	G_OutfitDirection dir;
+
+	union {
+		struct {
+			G_OutfitSet front;
+			G_OutfitSet side;
+			G_OutfitSet back;
+		};
+
+		G_OutfitSet e[3];
+	};
+};
+
 function void G_ImagesLoad(G_State *game);
 function void G_PipelinesLoad(G_State *game);
+function void G_AudioLoad(G_State *game);
 
 function void G_CalculateCamera(G_Camera *camera, F32 aspect);
 
+// Assumes 'calculate' has been called
+function V3f G_CameraUnprojectAt(G_Camera *camera, V2f clip, F32 z);
+function V3f G_CameraUnproject(G_Camera *camera, V2f clip);
+
+function R3f G_CameraBounds(G_Camera *camera);
+
+#include "world.h"
 #include "aabb.h"
 #include "player.h"
 #include "nav.h"

code/game/impl/aabb.c

@@ -11,7 +11,7 @@ bool AABB_Collide(AABB a, AABB b)
 bool AABB_Point(AABB a, V2f v)
 {
   bool collision_x = a.pos.x + a.size.x >= v.x && a.pos.x <= v.x;
-  bool collision_y = a.pos.x + a.size.y >= v.y && a.pos.y <= v.y;
+  bool collision_y = a.pos.y + a.size.y >= v.y && a.pos.y <= v.y;
   return collision_x && collision_y;
 }
 
@@ -23,14 +23,26 @@ bool AABB_Slab(V2f origin, V2f point, AABB a)
   // x
   F32 tLow = (start.x - origin.x) * invdirection.x;
   F32 tHigh = (finish.x - origin.x) * invdirection.x;
-  F32 tMin = min(tLow, tHigh);
-  F32 tMax = max(tLow, tHigh);
+  F32 tMin = Min(tLow, tHigh);
+  F32 tMax = Max(tLow, tHigh);
   // y
   tLow = (start.y - origin.y) * invdirection.y;
   tHigh = (finish.y - origin.y) * invdirection.y;
 
-  tMin = max(tMin, min(tLow, tHigh));
-  tMax = min(tMax, max(tLow, tHigh));
+  tMin = Max(tMin, Min(tLow, tHigh));
+  tMax = Min(tMax, Max(tLow, tHigh));
 
   return tMax >= tMin;
-}
+}
+
+V2f AABB_Centre(AABB a) {
+  return V2F(a.pos.x + a.size.x/2, a.pos.y + a.size.y/2);
+}
+
+bool AABB_Circle(F32 rad, V2f radOrigin, AABB a)
+{
+  V2f aCentre = AABB_Centre(a);
+  F32 xSq = (Abs(aCentre.x) - Abs(radOrigin.x)) * (Abs(aCentre.x) - Abs(radOrigin.x));
+  F32 ySq = (Abs(aCentre.y) - Abs(radOrigin.y)) * (Abs(aCentre.y) - Abs(radOrigin.y));
+  return SDL_sqrt(xSq + ySq) < rad;
+}

code/game/impl/bandit.c

@@ -0,0 +1,107 @@
+#include "game/world.h"
+#include "game/bandit.h"
+
+V2f ShootTowards(Bandit *bandit, V2f target, Random* r)
+{
+  V2f shooterV2 = bandit->collision.pos;
+  F32 randX = Random_F32(r, -bandit->accuracyRange, bandit->accuracyRange);
+  F32 randY = Random_F32(r, -bandit->accuracyRange, bandit->accuracyRange);
+  return V2F(shooterV2.x + (target.x - shooterV2.x) * (1 + randX), shooterV2.x + (target.y - shooterV2.y) * (1 + randY));
+}
+
+void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
+  for(U32 i = 0; i < world->portalCount; i++) {
+    if(AABB_Collide(world->portals[0].box, bandit->collision)) {
+      bandit->currentArea = world->portals[0].area;
+    }
+  }
+  if (
+      world->player.controls.shot && AABB_Slab(world->player.collision.pos, world->player.shotPos, bandit->collision) && bandit->currentArea == world->player.currentArea)
+  {
+    bandit->health--;
+  }
+  if (AABB_Circle(bandit->agroRadius, AABB_Centre(bandit->collision), world->player.collision) && !(bandit->mode == BANDIT_SHOOTING || bandit->mode == BANDIT_SHOOTOUT))
+  {
+    // shootout time o.o
+    bandit->mode = BANDIT_SHOOTOUT;
+  }
+  switch (bandit->mode) {
+    case BANDIT_WAITING:
+      bandit->waitTime+=delta;
+      if(bandit->waitTime > bandit->maxWaitTime) {
+        bandit->mode = BANDIT_WALKING;
+        do {
+          U32 randomChoice = Random_U32(&world->random, 0, bandit->poiCount);
+          bandit->targetNavNode = bandit->pointsOfInterest[randomChoice];
+        } while(bandit->targetNavNode == bandit->currentNavNode);
+        bandit->path = Nav_Path(world->navMesh, bandit->currentNavNode, bandit->targetNavNode);
+        bandit->walkTimer = 0;
+      }
+    break;
+    case BANDIT_WALKING:
+      bandit->walkTimer+=delta;
+      if(bandit->walkTimer >= NPC_SPEED){
+        bandit->walkTimer = 0;
+        if(bandit->path.nodeCount == bandit->pathIndex+1){
+          bandit->mode = BANDIT_WAITING;
+          bandit->maxWaitTime = Random_F32(&world->random, 20, 140);
+          bandit->waitTime = 0;
+          bandit->currentNavNode = bandit->targetNavNode;
+          bandit->pathIndex = 0;
+          return;
+        }
+        bandit->currentNavNode = bandit->path.indexes[bandit->pathIndex];
+        bandit->pathIndex+=1;
+      }
+      NavNode cNav = world->navMesh->nodes[bandit->currentNavNode];
+      NavNode tNav = world->navMesh->nodes[bandit->path.indexes[bandit->pathIndex]];
+      bandit->collision.pos.x = cNav.pos.x * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.x * bandit->walkTimer/NPC_SPEED;
+      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;
+      if(bandit->shootoutTimer < 0){
+        bandit->mode=BANDIT_SHOOTING;
+      }
+    break;
+    case BANDIT_SHOOTING:
+      bandit->shootCooldownTimer -= delta;
+      bandit->reloadTimer -= delta;
+      if (bandit->shootCooldownTimer < 0 && bandit->reloadTimer < 0)
+      {
+        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
+          world->player.health--;
+        }
+        if(bandit->bullets == 0){
+          bandit->bullets = 6;
+          bandit->reloadTimer = bandit->reloadTime;
+        }
+      }
+    break;
+      // TODO Running away
+  }
+}
+
+void BanditDraw(D_Context *draw, Bandit *bandit)
+{
+  G_Outfit *outfit = &bandit->outfit;
+
+  R2f pframe = D_AnimationFrame(&outfit->state);
+
+  for (U32 it = 0; it < G_OUTFIT_COMPONENT_COUNT; ++it)
+  {
+    U32 flipped = (outfit->dir & G_OUTFIT_DIR_FLIPPED) != 0;
+    U32 dir = (outfit->dir & ~G_OUTFIT_DIR_FLIPPED);
+
+    U32 tid = outfit->e[dir].e[it];
+    if (tid != 0)
+    {
+      U32 flags = D_RECT_UV_ASPECT | (flipped ? D_RECT_FLIP_X : 0);
+      D_Rect(draw, bandit->collision.pos.x, bandit->collision.pos.y, .texture = tid, .uv = pframe, .flags = flags);
+    }
+  }
+}

code/game/impl/nav.c

@@ -9,7 +9,7 @@ typedef struct navSearchNodeState navSearchNodeState;
 struct navSearchNodeState
 {
   bool visited;
-  U64 distance;
+  F64 distance;
   U32 shortest;
   bool addedToUnvisited;
 };
@@ -27,7 +27,7 @@ navSearchState initState(U32 start, U32 meshSize)
   {
     state.nodeStates[i].visited = false;
     state.nodeStates[i].addedToUnvisited = false;
-    state.nodeStates[i].distance = U64_MAX;
+    state.nodeStates[i].distance = F64_MAX;
     state.nodeStates[i].shortest = 0;
   }
   state.nodeStates[start].distance = 0;
@@ -61,8 +61,13 @@ U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchSta
 }
 
 // Generate a path to follow between the start and end node.
-NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
-{
+NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
+  // This is a stupid fix, since it's easier to work backwards
+  // to generate a path, I'm swapping the start / end, to generate
+  // it backwards
+  U32 tmp = end;
+  end = start;
+  start = tmp;
   navSearchState state = initState(start, mesh->nodeCount);
   U32 unfinishedCount = 1;
   U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
@@ -73,21 +78,15 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
   U32 unfinishedOffset = 0;
   U32 lowestNodeIndex = start;
   bool found = false;
-  while (!found)
-  {
-    for (int connectionI = 0; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++)
-    {
-      NavConnection *connection = &mesh->nodes[lowestNodeIndex].connections[connectionI];
-      navSearchNodeState *testNode = &state.nodeStates[connection->NodeIndex];
-      if (testNode->visited)
-      {
-        continue;
-      }
-      U32 distance = cast(U32)(state.nodeStates[lowestNodeIndex].distance + connection->Cost);
-      distance += cast(U32)(mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x);
-      distance += cast(U32)(mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y);
-      if (testNode->distance > distance)
-      {
+  while(!found) {
+    for(int connectionI = 0 ; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++) {
+      NavConnection      *connection = &mesh->nodes[lowestNodeIndex].connections[connectionI];
+      navSearchNodeState *testNode   = &state.nodeStates[connection->NodeIndex];
+      if(testNode->visited) {continue;}
+      F64 distance = cast(F64) (state.nodeStates[lowestNodeIndex].distance + connection->Cost);
+      distance += cast(F64) Abs((mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x));
+      distance += cast(F64) Abs((mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y));
+      if(testNode->distance > distance) {
         testNode->distance = distance;
         testNode->shortest = lowestNodeIndex;
       }

code/game/impl/npc.c

@@ -3,21 +3,25 @@
 #include "core/types.h"
 #include "core/math.h"
 
-#include <stdio.h>
-
-void updateNPC(F32 delta, NPC *npc, World *world) {
+void UpdateNPC(F32 delta, NPC *npc, World *world) {
+  for(U32 i = 0; i < world->portalCount; i++) {
+    if(AABB_Collide(world->portals[0].box, npc->collision)) {
+      npc->currentArea = world->portals[0].area;
+    }
+  }
   switch (npc->mode) {
     case NPC_ACTION_WAITING:
       npc->waitTime+=delta;
       if(npc->waitTime > npc->maxWaitTime) {
         npc->mode = NPC_ACTION_WALKING;
         // TODO change targets to poi's rather than just random nodes
-        npc->targetNavNode = Random_U32(&world->random, 0, world->navMesh->nodeCount);
-        printf("Starting to nav path\n");
+        // TODO choose either global POI's or use NPC custom poi if
+        // customPOI is true
+        do {
+          npc->targetNavNode = Random_U32(&world->random, 0, world->navMesh->nodeCount);
+        } while(npc->targetNavNode == npc->currentNavNode);
         npc->path = Nav_Path(world->navMesh, npc->currentNavNode, npc->targetNavNode);
-        printf("done\n");
         npc->walkTimer = 0;
-        printf("%.*s started walking to %d\n", Sv(npc->name), npc->targetNavNode);
       }
     break;
     case NPC_ACTION_WALKING:
@@ -25,20 +29,40 @@ void updateNPC(F32 delta, NPC *npc, World *world) {
       if(npc->walkTimer >= NPC_SPEED){
         npc->walkTimer = 0;
         if(npc->path.nodeCount == npc->pathIndex+1){
-          printf("Finished! so I'm waiting\n");
           npc->mode = NPC_ACTION_WAITING;
-          npc->maxWaitTime = Random_F32(&world->random, 10, 40);
+          npc->maxWaitTime = Random_F32(&world->random, 20, 140);
           npc->waitTime = 0;
+          npc->currentNavNode = npc->targetNavNode;
           npc->pathIndex = 0;
           return;
         }
-        npc->pathIndex+=1;
         npc->currentNavNode = npc->path.indexes[npc->pathIndex];
+        npc->pathIndex+=1;
       }
       NavNode cNav = world->navMesh->nodes[npc->currentNavNode];
-      NavNode tNav = world->navMesh->nodes[npc->pathIndex];
+      NavNode tNav = world->navMesh->nodes[npc->path.indexes[npc->pathIndex]];
       npc->collision.pos.x = cNav.pos.x * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.x * npc->walkTimer/NPC_SPEED;
       npc->collision.pos.y = cNav.pos.y * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.y * npc->walkTimer/NPC_SPEED;
     break;
   }
 }
+
+void NPCDraw(D_Context *draw, NPC *npc)
+{
+  G_Outfit *outfit = &npc->outfit;
+
+  R2f pframe = D_AnimationFrame(&outfit->state);
+
+  for (U32 it = 0; it < G_OUTFIT_COMPONENT_COUNT; ++it)
+  {
+    U32 flipped = (outfit->dir & G_OUTFIT_DIR_FLIPPED) != 0;
+    U32 dir = (outfit->dir & ~G_OUTFIT_DIR_FLIPPED);
+
+    U32 tid = outfit->e[dir].e[it];
+    if (tid != 0)
+    {
+      U32 flags = D_RECT_UV_ASPECT | (flipped ? D_RECT_FLIP_X : 0);
+      D_Rect(draw, npc->collision.pos.x, npc->collision.pos.y, .texture = tid, .uv = pframe, .flags = flags);
+    }
+  }
+}

code/game/impl/outfit.c

@@ -0,0 +1,31 @@
+
+
+U32* GenOutfit(G_Outfit *o, World *world, G_State *game)
+{
+    U32 *outfitChoices = M_ArenaPush(world->arena, U32, .count = 8);
+    G_Outfit *outfit = o;
+
+    D_AnimationInit(&outfit->state, 0, 1, 4, 1.0f / 6.0f);
+
+    M_TempScope(0, 0)
+    {
+        for (U32 it = 0; it < G_OUTFIT_COMPONENT_COUNT; ++it)
+        {
+            U32 idx = Random_Next(&world->random) % __outfit_counts[it];
+
+            // We just allow face, hair and hat to default to 0 meaning the player doesn't have one
+            if (idx != 0 || it < 2 || it > 4)
+            {
+                outfit->front.e[it] = OUTFIT_IMG(front, idx);
+                outfit->side.e[it] = OUTFIT_IMG(side, idx);
+
+                if ((idx + 1) <= __outfit_counts[it])
+                {
+                    outfit->back.e[it] = OUTFIT_IMG(back, idx);
+                }
+            }
+            outfitChoices[it] = idx;
+        }
+    }
+    return outfitChoices;
+}

code/game/impl/player.c

@@ -1,37 +1,173 @@
 #include "../player.h"
+#include <SDL3/SDL_events.h>
 #include <SDL3/SDL_keycode.h>
 #include <stdio.h>
+#include "../outfit.h"
+#include "../npc.h"
 
-void PlayerUpdate(SDL_Event *event, Player *player)
+
+void PlayerInit(G_State *game, Player *player) {
+	World *world  = game->world;
+	player->world = world;
+
+	player->bulletsLoaded = PLAYER_BULLET_COUNT;
+	player->currentArea   = WORLD_AREA_OUTSIDE;
+
+	player->health = 3;
+
+	player->collision.size.x = 1;
+	player->collision.size.x = 2;
+
+	G_Outfit *outfit = &player->outfit;
+
+	D_AnimationInit(&outfit->state, 0, 1, 4, 1.0f / 6.0f);
+
+	M_TempScope(0, 0) {
+		for (U32 it = 0; it < G_OUTFIT_COMPONENT_COUNT; ++it) {
+			U32 idx = Random_Next(&world->random) % __outfit_counts[it];
+
+			// We just allow face, hair and hat to default to 0 meaning the player doesn't have one
+			if (idx != 0 || it < 2 || it > 4) {
+				outfit->front.e[it] = OUTFIT_IMG(front, idx);
+				outfit->side.e[it]  = OUTFIT_IMG(side,  idx);
+
+				if ((idx + 1) <= __outfit_counts[it]) {
+					outfit->back.e[it]  = OUTFIT_IMG(back, idx);
+				}
+			}
+		}
+	}
+}
+
+void PlayerInput(SDL_Event *event, Player *player)
 {
   SDL_KeyboardEvent key = event->key;
   SDL_MouseButtonEvent mouseBtn = event->button;
-  switch (key.key)
-  {
-  case SDLK_W:
-  {
-    player->pos.y += 10;
-    break;
+  if(event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
+    bool val = event->type == SDL_EVENT_KEY_DOWN;
+    switch (key.key)
+    {
+      case SDLK_W:
+      {
+        player->controls.upDown = val;
+        break;
+      }
+      case SDLK_A:
+      {
+        player->controls.leftDown = val;
+        break;
+      }
+      case SDLK_D:
+      {
+        player->controls.rightDown = val;
+        break;
+      }
+      case SDLK_S:
+      {
+        player->controls.downDown = val;
+        break;
+      }
+      case SDLK_E:
+      {
+        for(int i = 0; player->world->npcCount; i++){
+          NPC *npc = &player->world->npcs[i];
+          if(AABB_Circle(npc->interationRadius, npc->collision.pos, player->collision) && !npc->infoGiven){
+            npc->infoGiven=true;
+            player->knownDetails[player->detailCount] = player->world->bandit.outfitChoices[player->detailCount];
+          }
+        }
+      }
+    }
   }
-  case SDLK_A:
-  {
-    player->pos.x -= 10;
-    break;
-  }
-  case SDLK_D:
-  {
-    player->pos.x += 10;
-    break;
-  }
-  case SDLK_S:
-  {
-    player->pos.y -= 10;
-    break;
-  }
-  }
-  if (mouseBtn.clicks == 1)
-  {
-    // shooting
-    player->bulletsLoaded -= 1;
+  if (
+    event->type == SDL_EVENT_MOUSE_BUTTON_DOWN
+    && mouseBtn.button == SDL_BUTTON_LEFT
+  ) {
+    if(player->bulletsLoaded > 0) {
+      // shooting
+      player->bulletsLoaded -= 1;
+      player->controls.shot = true;
+      player->shotPos = player->world->mouseProjected;
+      printf("shot %f %f\n", player->shotPos.x, player->shotPos.y);
+    } else if(player->reloadTimer == 0) {
+      player->reloadTimer = PLAYER_RELOAD_TIME;
+      printf("reloading\n");
+  };
   }
 }
+
+void PlayerUpdate(F32 delta, Player *player) {
+  player->controls.shot = false;
+  V2f dir = V2F(0, 0);
+  if(player->health == 0){
+    player->health = 3;
+  }
+  if(player->controls.upDown) {
+    dir.y -= 1;
+		player->outfit.dir = G_OUTFIT_DIR_BACK;
+  }
+  if(player->controls.downDown) {
+    dir.y += 1;
+		player->outfit.dir = G_OUTFIT_DIR_FRONT;
+  }
+  if(player->controls.leftDown) {
+    dir.x -= 1;
+		player->outfit.dir = G_OUTFIT_DIR_SIDE | G_OUTFIT_DIR_FLIPPED;
+  }
+  if(player->controls.rightDown) {
+    dir.x += 1;
+		player->outfit.dir = G_OUTFIT_DIR_SIDE;
+  }
+
+	if (dir.x != 0 || dir.y != 0) {
+		D_AnimationUpdate(&player->outfit.state, delta);
+	}
+	else {
+		player->outfit.state.index = 0;
+	}
+
+  if(player->reloadTimer > 0) {
+    player->reloadTimer-=delta;
+    if(player->reloadTimer <= 0) {
+      player->bulletsLoaded = PLAYER_BULLET_COUNT;
+      player->reloadTimer = 0;
+    }
+  }
+  dir = V2f_Scale(NormaliseV2F(dir), PLAYER_SPEED*delta);
+  player->collision.pos.x += dir.x;
+  player->collision.pos.y += dir.y;
+
+  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) {
+	G_Outfit *outfit = &player->outfit;
+
+	R2f pframe = D_AnimationFrame(&outfit->state);
+
+	for (U32 it = 0; it < G_OUTFIT_COMPONENT_COUNT; ++it) {
+		U32 flipped = (outfit->dir & G_OUTFIT_DIR_FLIPPED) != 0;
+		U32 dir = (outfit->dir & ~G_OUTFIT_DIR_FLIPPED);
+
+		U32 tid = outfit->e[dir].e[it];
+		if (tid != 0) {
+			U32 flags = D_RECT_UV_ASPECT | (flipped ? D_RECT_FLIP_X : 0);
+			D_Rect(draw, player->collision.pos.x, player->collision.pos.y, .texture = tid, .uv = pframe, .flags = flags);
+		}
+	}
+}

code/game/impl/world.c

@@ -1,22 +1,304 @@
 #include "../world.h"
 #include "../npc.h"
 #include "../player.h"
+#include "../aabb.h"
 #include <SDL3/SDL_events.h>
+#include <SDL3/SDL_keycode.h>
+#include <SDL3/SDL_oldnames.h>
+#include "../map.h"
 
 void UpdateWorld(F32 delta, World *world)
 {
+  if(world->bandit.mode == BANDIT_SHOOTOUT){
+    delta = delta/4;
+  }
+  UpdateBandit(delta, &world->bandit, world);
   UpdateNPCs(delta, world);
+  PlayerUpdate(delta, &world->player);
 }
 
 void UpdateNPCs(F32 delta, World *world)
 {
   for (U32 i = 0; i < world->npcCount; i++)
   {
-    updateNPC(delta, &world->npcs[i], world);
+    NPC *npc = &world->npcs[i];
+    UpdateNPC(delta, npc, world);
+    if (
+        world->player.controls.shot && AABB_Slab(world->player.collision.pos, world->player.shotPos, npc->collision) && npc->currentArea == world->player.currentArea)
+    {
+      printf("You shot %*.s\n", Sv(world->npcs[i].name));
+    }
   }
 }
 
 void ProcessEvents(SDL_Event *event, World *world)
 {
-  PlayerUpdate(event, &world->player);
+  PlayerInput(event, &world->player);
+  if(event->type == SDL_EVENT_KEY_DOWN && event->key.key == SDLK_F5){
+    SaveWorld(world);
+  }
+  if(event->type == SDL_EVENT_KEY_DOWN && event->key.key == SDLK_F6){
+    LoadWorld(world->arena, world);
+  }
+}
+
+void RenderWorld(World *world, D_Context *draw) {
+  if(world->player.currentArea == WORLD_AREA_OUTSIDE) {
+    for (int i = 0; i < 4800; i++) {
+      D_Rect(
+        draw,
+        (F32) (i % 96), (F32) (i / 96),
+        .texture = D_ImageHandle(draw,world->tileTypes[world->map[i]].tag),
+        .angle = (F32) world->tileTypes[world->map[i]].rotation,
+      );
+    }
+  }
+  for (U32 i = 0; i < world->propCount; i++) {
+    if(world->props[i].area == world->player.currentArea) {
+      D_Rect(
+        draw,
+        world->props[i].pos.x,
+        world->props[i].pos.y,
+        .texture = D_ImageHandle(draw,world->propTypes[world->props[i].propType].tag),
+        .scale = world->propTypes[world->props[i].propType].scale,
+      );
+    }
+  }
+  for(U32 i = 0; i < world->npcCount; i++) {
+    NPC npc = world->npcs[i];
+    if(npc.currentArea == world->player.currentArea) {
+      NPCDraw(draw, &world->npcs[i]);
+    }
+  }
+
+  BanditDraw(draw, &world->bandit);
+	PlayerDraw(draw, &world->player);
+}
+
+#define WRITE(v) FS_FileWrite(file, &(v), sizeof(v), offset); offset += sizeof(v)
+#define WRITEN(v, n) FS_FileWrite(file, v, (n) * sizeof(*(v)), offset); offset += ((n) * sizeof(*(v)))
+
+void SaveWorld(World *world) {
+  printf("--- Saving World ---\n");
+	printf("  - %d props\n", world->propCount);
+	printf("  - %d hitboxes\n", world->hitboxCount);
+
+  OS_Handle file = FS_FileOpen(S("world.sgdat"), FS_ACCESS_WRITE);
+  U64 offset = 0;
+
+  for (U32 i = 0; i < WORLD_TILE_TYPE_MAX; i++) {
+		World_Tile *tile = &world->tileTypes[i];
+
+		WRITE(tile->tag.count);
+		WRITEN(tile->tag.data, tile->tag.count);
+		WRITE(tile->rotation);
+  }
+
+  for (U32 i = 0; i < WORLD_PROP_TYPE_MAX; i++) {
+		World_PropType *type = &world->propTypes[i];
+
+		WRITE(type->tag.count);
+		WRITEN(type->tag.data, type->tag.count);
+		WRITE(type->scale);
+  }
+
+	WRITE(world->propCount);
+	WRITEN(world->props, WORLD_PROP_MAX);
+
+	WRITE(world->hitboxCount);
+	WRITEN(world->hitboxes, WORLD_HITBOX_MAX);
+
+	WRITEN(world->map, WORLD_MAP_MAX);
+
+  WRITE(world->portalCount);
+  WRITEN(world->portals, WORLD_PORTAL_MAX);
+  FS_FileClose(file);
+
+  printf("--- World Saved ---\n");
+}
+
+void LoadWorld(M_Arena *arena, World *world) {
+	printf("--- Loading World ---\n");
+
+	M_TempScope(0, 0) {
+		Str8 data = FS_ReadEntireFile(temp.arena, S("world.sgdat"));
+
+		U8 *base = data.data;
+
+		// Load tile types
+		//
+		world->tileTypes = M_ArenaPush(arena, World_Tile, .count = WORLD_TILE_TYPE_MAX);
+		for (U32 it = 0; it < WORLD_TILE_TYPE_MAX; ++it) {
+			World_Tile *type = &world->tileTypes[it];
+
+			Str8 name;
+			name.count = *(S64 *) base;
+			name.data  = base + 8;
+
+			base += 8;
+			base += name.count;
+
+			if (name.count != 0) {
+				// Means we likely got a vaild tag
+				type->tag      = Str8_Copy(arena, name);
+				type->rotation = *(F32 *) base;
+			}
+
+			base += 4;
+		}
+
+		// Load prop types
+		//
+		world->propTypes = M_ArenaPush(arena, World_PropType, .count = WORLD_PROP_TYPE_MAX);
+		for (U32 it = 0; it < WORLD_PROP_TYPE_MAX; ++it) {
+			World_PropType *type = &world->propTypes[it];
+
+			Str8 name;
+			name.count = *(S64 *) base;
+			name.data  = base + 8;
+
+			base += 8;
+			base += name.count;
+
+			if (name.count != 0) {
+				type->tag    = Str8_Copy(arena, name);
+				type->scale  = *(F32 *) base;
+			}
+
+			base += 4;
+		}
+
+		// Prop locations
+		{
+			U32 n_props = *(U32 *) base; base += 4;
+			World_Prop *props = (World_Prop *) base;
+
+			world->propCount = n_props;
+			world->props     = M_ArenaPush(arena, World_Prop, .count = WORLD_PROP_MAX);
+
+			M_CopySize(world->props, props, n_props * sizeof(World_Prop));
+
+			base += (WORLD_PROP_MAX * sizeof(World_Prop));
+		}
+
+		// Hitboxes
+		//
+		{
+			U32 n_hitbox = *(U32 *) base; base += 4;
+			World_Hitbox *boxes  = (World_Hitbox *) base;
+
+			world->hitboxCount = n_hitbox;
+			world->hitboxes    = M_ArenaPush(arena, World_Hitbox, .count = WORLD_HITBOX_MAX);
+
+			M_CopySize(world->hitboxes, boxes, n_hitbox * sizeof(World_Hitbox));
+
+			base += (WORLD_HITBOX_MAX * sizeof(World_Hitbox));
+		}
+
+		// Map
+		//
+		{
+			U32 *__map = (U32 *) base;
+
+			world->map = M_ArenaPush(arena, U32, .count = WORLD_MAP_MAX);
+			M_CopySize(world->map, __map, WORLD_MAP_MAX * sizeof(U32));
+
+			base += (WORLD_MAP_MAX * sizeof(U32));
+		}
+		{
+			U32 n_portals = *(U32 *) base; base += 4;
+			World_Portal *portals  = (World_Portal *) base;
+
+			world->portalCount = n_portals;
+			world->portals    = M_ArenaPush(arena, World_Portal, .count = WORLD_PORTAL_MAX);
+
+			M_CopySize(world->portals, portals, n_portals * sizeof(World_Portal));
+
+			base += (WORLD_PORTAL_MAX * sizeof(World_Portal));
+		}
+
+		if (base != (data.data + data.count)) {
+			printf("--- OFFSET MISMATCH ---\n");
+		}
+
+    printf("loaded world\n");
+
+		printf("  - %d props\n", world->propCount);
+		printf("  - %d hitboxes\n", world->hitboxCount);
+
+		printf("--- Loaded World ---\n");
+	}
+}
+
+void GenerateNavMesh(M_Arena *arena, World *world) {
+  world->navMesh = M_ArenaPush(arena, NavMesh);
+  world->navMesh->nodeCount = 0;
+  for(int i = 0; i < WORLD_MAP_MAX; i++) {
+    U32 x = (i % 96);
+    U32 y = (i / 96);
+    bool skip = false;
+    for(U32 hi = 0; hi < world->hitboxCount; hi++) {
+      if(AABB_Point(world->hitboxes[hi].box, V2F((F32) x, (F32) y))) {
+        skip = true;
+        break;
+      }
+    }
+    if(skip) {continue;}
+    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++){
+        if(nx==0 && ny==0) {continue;}
+        if(x+nx < 0 || x+nx > 95) {
+          continue;
+        }
+        if(y+ny < 0 || y+ny > 49) {
+          continue;
+        }
+        // It's quad for loop time :D
+        for(U32 hi = 0; hi < world->hitboxCount; hi++) {
+          if(AABB_Point(world->hitboxes[hi].box, V2F((F32) (x + nx), (F32) (y + ny)))) {
+            skip = true;
+            break;
+          }
+        }
+        U32 nCount = world->navMesh->nodeCount;
+        S32 index = -1;
+        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;
+          }
+        }
+        F32 cost = 20;
+        if(ny+nx == 2) {
+          cost = 40;
+        };
+        if(Str8_Equal(world->tileTypes[world->map[i]].tag, S("path_middle"), STR8_EQUAL_IGNORE_CASE)) {
+          cost = 1;
+          if(Abs(ny+nx) == 2) {
+            cost = 4;
+          };
+        }
+        if(index < 0) {continue;}
+        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;
+        world->navMesh->nodes[index].connections[world->navMesh->nodes[index].connectionCount].NodeIndex = nCount;
+        world->navMesh->nodes[index].connections[world->navMesh->nodes[index].connectionCount].Cost = cost;
+        world->navMesh->nodes[nCount].connectionCount++;
+        world->navMesh->nodes[index].connectionCount++;
+      }
+    }
+    world->navMesh->nodeCount++;
+  }
+  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].pathIndex = 0;
+  }
 }

code/game/map.h

@@ -0,0 +1,54 @@
+#include "world.h"
+
+U32 map[] = {
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,6,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4,4,4,9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,9,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,5,3,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,7,2,2,2,2,2,6,7,2,2,2,2,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,5,3,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,7,2,2,2,2,2,6,7,2,2,2,2,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,5,3,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,7,2,2,2,2,2,6,7,2,2,2,2,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+};

code/game/nav.h

@@ -6,7 +6,7 @@
 
 #define NAV_MAX_PATH 1024
 #define NAV_MAX_CONNECTIONS 8
-#define NAV_MAX_NODES 4096
+#define NAV_MAX_NODES 4800
 
 typedef struct NavNode NavNode;
 

code/game/npc.h

@@ -5,7 +5,7 @@
 #include "npc_look.h"
 #include "../core/types.h"
 
-#define NPC_SPEED 0.2f
+#define NPC_SPEED 1.0f
 
 typedef enum NPC_ACTION NPC_ACTION;
 enum NPC_ACTION {
@@ -22,6 +22,11 @@ struct NPC {
   AABB collision;
   Str8 name;
   NPC_LOOK look;
+  World_Area currentArea;
+
+  bool customPOI;
+  U32 customPOICount;
+  U32 npcPOI[16];
 
   //// Actions
   NPC_ACTION mode;
@@ -41,10 +46,15 @@ struct NPC {
   U32 targetNavNode;
   // How long the npc has been walking to the next index
   F32 walkTimer;
-
+  // Space within you can interact with the NPC.
+  F32 interationRadius;
   //// Knowledge
   // What the NPC knows about the bandit.
   NPC_LOOK banditKnowledge;
+  // NPC clothes
+  G_Outfit outfit;
+  // if the NPC has given info
+  bool infoGiven;
 };
-
+function void NPCDraw(D_Context *draw, NPC *npc);
 #endif  // LD_GAME_NPC_H_

code/game/outfit.h

@@ -0,0 +1,45 @@
+
+#if !defined(LD_GAME_OUTFIT_H)
+#define LD_GAME_OUTFIT_H
+
+#define G_OUTFIT_COMPONENT_COUNT 8
+
+global_var Str8 __outfit_names[] = {
+    Sl("npc_%s_base_%d"),
+    Sl("npc_%s_eyes_%d"),
+    Sl("npc_%s_face_%d"),
+    Sl("npc_%s_hair_%d"),
+    Sl("npc_%s_hat_%d"),
+    Sl("npc_%s_shirt_%d"),
+    Sl("npc_%s_shoes_%d"),
+    Sl("npc_%s_trousers_%d")};
+
+global_var U32 __outfit_counts[] = {
+    2, // base
+    3, // eyes
+    5, // face
+    4, // hair
+    3, // hat
+    2, // shirt
+    1, // shoes
+    2  // trousers
+};
+
+global_var U32 __outfit_back_counts[] = {
+    2, // base
+    0, // eyes
+    3, // face
+    4, // hair
+    3, // hat
+    2, // shirt
+    1, // shoes
+    2  // trousers
+};
+
+StaticAssert(ArraySize(__outfit_names) == ArraySize(__outfit_counts));
+
+#define OUTFIT_IMG(dir, n) D_ImageHandle(&game->draw, Sf(temp.arena, (const char *)__outfit_names[it].data, #dir, n))
+
+function U32* GenOutfit(G_Outfit *o, World *world, G_State *game);
+
+#endif // LD_GAME_OUTFIT_H

code/game/player.h

@@ -5,14 +5,44 @@
 #include "../core/macros.h"
 
 #include <SDL3/SDL_events.h>
+#include "aabb.h"
+
+#define PLAYER_SPEED 10.0f
+#define PLAYER_RELOAD_TIME 1.5f
+#define PLAYER_BULLET_COUNT 6
+
+typedef struct ControlState ControlState;
+struct ControlState {
+  bool rightDown;
+  bool leftDown;
+  bool upDown;
+  bool downDown;
+  bool shot;
+};
 
 typedef struct Player Player;
 struct Player
 {
-    V2f pos;
+    World *world;
+    AABB collision;
+    World_Area currentArea;
     U32 bulletsLoaded;
+    ControlState controls;
+    V2f shotPos;
+
+		G_Outfit outfit;
+
+    U32 health;
+    F32 reloadTimer;
+
+    U32 *knownDetails;
+    U32 detailCount;
 };
 
-function void PlayerUpdate(SDL_Event *event, Player *player);
+function void PlayerInit(G_State *game, Player *player);
+function void PlayerDraw(D_Context *draw, Player *player);
+
+function void PlayerInput(SDL_Event *event, Player *player);
+function void PlayerUpdate(F32 delta, Player *player);
 
 #endif  // LD_GAME_PLAYER_H_

code/game/world.h

@@ -1,26 +1,82 @@
 #if !defined(LD_GAME_WORLD_H_)
 #define LD_GAME_WORLD_H_
 
-#include "player.h"
-#include "npc.h"
-#include "bandit.h"
 #include "../core/math.h"
+#include "./aabb.h"
+
+#define WORLD_HITBOX_MAX 4096
+#define WORLD_PROP_MAX 2048
+#define WORLD_PROP_TYPE_MAX 64
+#define WORLD_TILE_TYPE_MAX 64
+#define WORLD_MAP_MAX 4800
+#define WORLD_PORTAL_MAX 64
 
 // Areas are which
 typedef U32 World_Area;
-enum World_Area {
-  WORLD_AREA_OUTSIDE = (1 << 0),
-  WORLD_AREA_SALOON  = (1 << 1),
+enum World_Area
+{
+  WORLD_AREA_OUTSIDE = 1,
+  WORLD_AREA_SALOON = 2,
 };
 
+typedef struct World_Tile World_Tile;
+struct World_Tile {
+  Str8 tag;
+  F32 rotation;
+};
+
+typedef struct World_PropType World_PropType;
+struct World_PropType {
+  Str8 tag;
+  F32 scale;
+};
+
+typedef struct World_Prop World_Prop;
+struct World_Prop
+{
+  U32 propType;
+  World_Area area;
+  V2f pos;
+};
+
+typedef struct World_Portal World_Portal;
+struct World_Portal
+{
+  AABB box;
+  World_Area area;
+};
+typedef World_Portal World_Hitbox;
+
+
 typedef struct World World;
+#include "player.h"
+#include "npc.h"
+#include "bandit.h"
+
 struct World {
+  //// Utils
+  M_Arena *arena;
   //// Static stuff
   NavMesh *navMesh;
   Random random;
+  V2f mouseProjected;
+  //// Loaded from world file
+  World_Tile *tileTypes;
+  World_PropType *propTypes;
+  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;
+  Player player;
 
   //// NPCs
   U32 npcCount;
@@ -35,8 +91,14 @@ struct World {
 };
 
 function void UpdateWorld(F32 delta, World *world);
+function void RenderWorld(World *world, D_Context *drawContext);
 function void ProcessEvents(SDL_Event *event, World *world);
 function void UpdateNPCs(F32 delta, World *world);
-function void updateNPC(F32 delta, NPC *npc, World *world);
+function void UpdateNPC(F32 delta, NPC *npc, World *world);
+function void UpdateBandit(F32 delta, Bandit *bandit, World *world);
+
+function void LoadWorld(M_Arena *arena, World *world);
+function void SaveWorld(World *world);
+function void GenerateNavMesh(M_Arena *arena, World *world);
 
 #endif  // LD_GAME_WORLD_H_

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_