Commit b4d0ad9

Structural refactor

Author	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-04-30 19:19:27 +0200
Committer	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-04-30 19:44:07 +0200
Commit	`b4d0ad9e95226d225d5361b1182866884aaa6366` (patch)

`-rw-r--r--`	Makefile	2
`-rw-r--r--`	all.h	159
`-rw-r--r--`	assets.c	81
`-rw-r--r--`	config.h	5
`-rw-r--r--`	game.c	349
`-rw-r--r--`	interface.c	6
`-rw-r--r--`	main.c	123
`-rw-r--r--`	map.c	573
`-rw-r--r--`	menu.c	39
`-rw-r--r--`	player.c	184

10 files changed, 781 insertions, 740 deletions

diff --git a/Makefile b/Makefile
...
16	GAME := bin/stalag	16	GAME := bin/stalag
17	HEXDUMP := bin/hexdump	17	HEXDUMP := bin/hexdump
18	PACKER := bin/packer	18	PACKER := bin/packer
19	SOURCES := main.c map.c game.c player.c interface.c	19	SOURCES := main.c map.c game.c player.c interface.c assets.c menu.c
20		20
21	ifeq ($(SYSTEM), linux_amd64)	21	ifeq ($(SYSTEM), linux_amd64)
22	LDFLAGS += -lX11	22	LDFLAGS += -lX11
...

 #include <stdbool.h>
 #include <stddef.h>
-// --- Map Structures ---
+#ifndef PLAYER_FOV
+#define PLAYER_FOV 90.0f
+#endif
 typedef struct {
-    Vector3 p[3];
+	Vector3 p[3];
-    char texture[64];
+	char texture[64];
-    float shift[2];
+	float shift[2];
-    float rotate;
+	float rotate;
-    float scale[2];
+	float scale[2];
 } MapPlane;
 typedef struct {
-    MapPlane *planes;
+	MapPlane *planes;
-    int plane_count;
+	int plane_count;
 } MapBrush;
 typedef struct {
-    char key[64];
+	char key[64];
-    char value[256];
+	char value[256];
 } MapProperty;
 typedef struct {
-    MapProperty *properties;
+	MapProperty *properties;
-    int property_count;
+	int property_count;
-    MapBrush *brushes;
+	MapBrush *brushes;
-    int brush_count;
+	int brush_count;
 } MapEntity;
 typedef struct {
-    MapEntity *entities;
+	MapEntity *entities;
-    int entity_count;
+	int entity_count;
 } Map;
 typedef struct {
-    const char *data;
+	const char *data;
-    size_t length;
+	size_t length;
-    size_t pos;
+	size_t pos;
 } MapParser;
 typedef struct {
-    Vector3 normal;
+	Vector3 normal;
-    float dist;
+	float dist;
 } Plane;
 typedef struct {
-    Vector3 *verts;
+	Vector3 *verts;
-    int count;
+	int count;
 } Polygon;
 typedef struct {
-    char texture[64];
+	char texture[64];
-    array(float) vertices;
+	array(float) vertices;
-    array(float) texcoords;
+	array(float) texcoords;
-    array(float) normals;
+	array(float) normals;
 } TextureGroup;
 typedef struct {
-    char name[64];
+	char name[64];
-    Texture2D tex;
+	Texture2D tex;
 } CachedTexture;
-// --- Game State ---
+// Asset Module
+Texture2D GetTexture(const char *name);
+void UnloadAssets(void);
+Font LoadFontVFS(const char *path, int fontSize);
+// Map Module
+typedef struct {
+	Model *models;
+	int count;
+} MapState;
+bool LoadMap(const char *filename);
+void UnloadMap(void);
+bool CheckMapCollision(Vector3 start, Vector3 end, RayCollision *outCollision);
+Map ParseMap(const char *filename);
+void FreeMap(Map map);
+// Menu Module
+void UpdateMenu(void);
+void DrawMenu(void);
+// Player Module
 typedef enum {
-    MOVE_NORMAL,
+	MOVE_NORMAL,
-    MOVE_FLY
+	MOVE_FLY
 } MovementMode;
+typedef struct {
+	MovementMode move_mode;
+	Vector3 pos;
+	Vector3 velocity;
+	bool is_grounded;
+	float yaw;
+	float pitch;
+	float lean_amount;
+	float crouch_amount;
+	float horizontal_speed;
+} PlayerState;
+void UpdatePlayer(void);
+// Game State Module
 typedef enum {
-    STATE_TITLE,
+	STATE_MENU,
-    STATE_PLAYING
+	STATE_PLAYING
 } GameStateMode;
 typedef struct {
-    GameStateMode mode;
+	GameStateMode mode;
-    char map_path[256];
+	char map_path[256];
-    Camera camera;
+	Camera camera;
-    Model *world_models;
+	bool cursor_captured;
-    int world_model_count;
+	bool vsync;
-    bool cursor_captured;
+	Font font_ui;
-    bool vsync;
-    Font font_ui;
-    MovementMode move_mode;
+	PlayerState player;
-    Vector3 pos;
+	MapState map;
-    Vector3 velocity;
-    bool is_grounded;
-    float yaw;
-    float pitch;
-    float lean_amount;
-    float crouch_amount;
-    float horizontal_speed;
 } GameState;
 extern GameState game;
-// --- Prototypes ---
+void InitGame(void);
+void SetMap(const char *path);
+void UpdateGame(void);
+void DrawGame(void);
-// Map
+// Geometry Helpers
-char map_peek(MapParser *p);
-char map_get(MapParser *p);
-void map_skip_whitespace(MapParser *p);
-bool map_expect(MapParser *p, char expected);
-void map_parse_token(MapParser *p, char *buffer, int size);
-Vector3 map_parse_vector(MapParser *p);
-Map ParseMap(const char *filename);
-void FreeMap(Map map);
-// Geometry
 Plane PlaneFromPoints(Vector3 p1, Vector3 p2, Vector3 p3);
 void PolyFree(Polygon p);
 Polygon PolyClip(Polygon poly, Plane plane);
 Polygon CreateLargeQuad(Plane plane);
 Vector2 GetUV(Vector3 p, MapPlane *mp, Plane plane);
-// Game
-Texture2D GetTexture(const char *name);
-void InitGame(void);
-void SetMap(const char *path);
-void UpdateGame(void);
-void DrawGame(void);
-bool LoadMap(const char *filename);
-void UnloadMap(void);
 // Interface
 void DrawCrosshair(void);
 void DrawDebugInfo(void);
-// Player
-void UpdatePlayer(void);
 #endif

diff --git a/assets.c b/assets.c
	1	#include "all.h"
	2
	3	#include <stdio.h>
	4	#include <string.h>
	5	#include <ctype.h>
	6
	7	static array(CachedTexture) texture_cache;
	8
	9	Texture2D GetTexture(const char *name) {
	10	if (texture_cache.data == NULL) {
	11	array_init(texture_cache);
	12	}
	13
	14	for (int i = 0; i < texture_cache.length; i++) {
	15	if (strcmp(texture_cache.data[i].name, name) == 0) return texture_cache.data[i].tex;
	16	}
	17
	18	char lname[256];
	19	strncpy(lname, name, sizeof(lname));
	20	lname[sizeof(lname)-1] = '\0';
	21	for (int i = 0; lname[i]; i++) lname[i] = tolower(lname[i]);
	22
	23	char path[256];
	24	void *data = NULL;
	25	size_t size = 0;
	26	const char *ext = ".png";
	27
	28	snprintf(path, sizeof(path), "textures/%s.png", lname);
	29	data = vfs_read(path, &size);
	30	if (!data) {
	31	snprintf(path, sizeof(path), "textures/%s.jpg", lname);
	32	data = vfs_read(path, &size);
	33	ext = ".jpg";
	34	}
	35
	36	Texture2D tex = { 0 };
	37	if (data) {
	38	Image img = LoadImageFromMemory(ext, data, (int)size);
	39	if (img.data) {
	40	tex = LoadTextureFromImage(img);
	41	UnloadImage(img);
	42	}
	43	vfs_free(data);
	44	}
	45
	46	if (tex.id == 0) {
	47	TraceLog(LOG_WARNING, "Failed to load texture: '%s'", name);
	48	Image img = GenImageChecked(64, 64, 8, 8, (Color){128, 128, 128, 255}, (Color){200, 200, 200, 255});
	49	tex = LoadTextureFromImage(img);
	50	UnloadImage(img);
	51	} else {
	52	GenTextureMipmaps(&tex);
	53	SetTextureFilter(tex, TEXTURE_FILTER_BILINEAR);
	54	SetTextureWrap(tex, TEXTURE_WRAP_REPEAT);
	55	}
	56
	57	CachedTexture cached;
	58	strncpy(cached.name, name, sizeof(cached.name));
	59	cached.tex = tex;
	60	array_push(texture_cache, cached);
	61
	62	return tex;
	63	}
	64
	65	void UnloadAssets(void) {
	66	for (int i = 0; i < texture_cache.length; i++) {
	67	UnloadTexture(texture_cache.data[i].tex);
	68	}
	69	array_clear(texture_cache);
	70	}
	71
	72	Font LoadFontVFS(const char *path, int fontSize) {
	73	size_t size = 0;
	74	void *data = vfs_read(path, &size);
	75	if (data) {
	76	Font font = LoadFontFromMemory(".ttf", data, (int)size, fontSize, NULL, 0);
	77	vfs_free(data);
	78	return font;
	79	}
	80	return GetFontDefault();
	81	}

 #define WINDOW_HEIGHT 720
 #define WINDOW_TITLE "Stalag"
+#define VFS_DATA_PAK "data.pak"
+#define UI_FONT_PATH "fonts/LiberationSans-Bold.ttf"
+#define UI_FONT_SIZE 20
 #define PLAYER_MOVE_SPEED 200.0f
 #define PLAYER_FLY_SPEED 400.0f
 #define PLAYER_ROTATION_SPEED 0.05f


#include "all.h"
  
#include <string.h>
  
  
GameState game;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
void InitGame(void) {
	memset(&game, 0, sizeof(game));
  
  
  
  
  
  
  
  
  
  
  
  
  
	game.font_ui = LoadFontVFS(UI_FONT_PATH, UI_FONT_SIZE);
	game.mode = STATE_MENU;
	game.cursor_captured = false;
	EnableCursor();
  
	game.player.move_mode = MOVE_NORMAL;
	game.player.pos = (Vector3){ 0, 0, 0 };
	game.player.velocity = (Vector3){ 0, 0, 0 };
	game.player.is_grounded = false;
  
	// Camera setup
	game.camera.up = (Vector3){ 0, 1, 0 };
	game.camera.fovy = PLAYER_FOV;
	game.camera.projection = CAMERA_PERSPECTIVE;
}
  
void SetMap(const char *path) {
	strncpy(game.map_path, path, sizeof(game.map_path) - 1);
	game.map_path[sizeof(game.map_path) - 1] = '\0';
}
  
void UpdateGame(void) {
	if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {
		game.cursor_captured = !game.cursor_captured;
		if (game.cursor_captured) DisableCursor();
		else EnableCursor();
	}
  
  
  
  
  
  
  
  
  
  
  
  
  
  
	if (IsKeyPressed(KEY_V)) {
		game.vsync = !game.vsync;
		if (game.vsync) {
			SetWindowState(FLAG_VSYNC_HINT);
			SetTargetFPS(GetMonitorRefreshRate(GetCurrentMonitor()));
		} else {
			ClearWindowState(FLAG_VSYNC_HINT);
			SetTargetFPS(0);
		}
	}
  
	UpdatePlayer();
}
  
void DrawGame(void) {
	BeginDrawing();
	ClearBackground(DARKGRAY);
  
	BeginMode3D(game.camera);
  
  
  
	rlEnableBackfaceCulling();
	for (int i = 0; i < game.map.count; i++) {
		DrawModel(game.map.models[i], (Vector3){ 0, 0, 0 }, 1.0f, WHITE);
	}
  
  
	EndMode3D();
  
  
  
  
  
  
  
  
	DrawCrosshair();
	DrawDebugInfo();
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
	EndDrawing();
}

diff --git a/interface.c b/interface.c
...
8	}	8	}
9		9
10	void DrawDebugInfo(void) {	10	void DrawDebugInfo(void) {
11	DrawTextEx(game.font_ui, TextFormat("%i FPS", GetFPS()), (Vector2){ 10, 10 }, 20, 2, GREEN);	11	DrawTextEx(game.font_ui, TextFormat("%i FPS", GetFPS()), (Vector2){ 10, 10 }, 20, 2, GREEN);
12	DrawTextEx(game.font_ui, TextFormat("VSync: %s", game.vsync ? "ON" : "OFF"), (Vector2){ 10, 35 }, 20, 2, GREEN);	12	DrawTextEx(game.font_ui, TextFormat("VSync: %s", game.vsync ? "ON" : "OFF"), (Vector2){ 10, 35 }, 20, 2, GREEN);
13	DrawTextEx(game.font_ui, TextFormat("Speed: %.0f", game.horizontal_speed), (Vector2){ 10, 60 }, 20, 2, GREEN);	13	DrawTextEx(game.font_ui, TextFormat("Speed: %.0f", game.player.horizontal_speed), (Vector2){ 10, 60 }, 20, 2, GREEN);
14	}	14	}


  
#define NONSTD_IMPLEMENTATION
#define VFS_IMPLEMENTATION
#include "all.h"
  
#include <getopt.h>
  
  
int main(int argc, char *argv[]) {
	stringb map_path;
	sb_init(&map_path, 256);
	sb_append_cstr(&map_path, "maps/demo3.map");
  
	bool skip_title = false;
  
  
  
  
	static struct option long_options[] = {
		{"map", required_argument, 0, 'm'},
		{0, 0, 0, 0}
	};
  
  
  
  
  
  
  
	int opt;
	int option_index = 0;
	while ((opt = getopt_long_only(argc, argv, "m:", long_options, &option_index)) != -1) {
		switch (opt) {
			case 'm':
				sb_free(&map_path);
				sb_init(&map_path, 256);
				sb_append_cstr(&map_path, optarg);
				skip_title = true;
				break;
		}
	}
  
	SetConfigFlags(FLAG_VSYNC_HINT | FLAG_WINDOW_RESIZABLE | FLAG_WINDOW_HIGHDPI);
	InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE);
  
	int monitor = GetCurrentMonitor();
	SetWindowPosition((GetMonitorWidth(monitor) - GetScreenWidth()) / 2, (GetMonitorHeight(monitor) - GetScreenHeight()) / 2);
	SetTargetFPS(GetMonitorRefreshRate(monitor));
  
	vfs_init(VFS_DATA_PAK);
	InitGame();
	SetMap(map_path.data);
  
	if (skip_title) {
		if (LoadMap(game.map_path)) {
			game.mode = STATE_PLAYING;
			game.cursor_captured = true;
			DisableCursor();
		}
	}
  
	game.vsync = true;
  
  
  
  
  
  
  
	while (!WindowShouldClose()) {
		// Global Map Switching (Debug/Demo)
		if (IsKeyPressed(KEY_ONE)) {
			if (LoadMap("maps/demo1.map")) {
				game.mode = STATE_PLAYING;
				game.cursor_captured = true;
				DisableCursor();
			}
		}
		if (IsKeyPressed(KEY_TWO)) {
			if (LoadMap("maps/demo2.map")) {
				game.mode = STATE_PLAYING;
				game.cursor_captured = true;
				DisableCursor();
			}
		}
		if (IsKeyPressed(KEY_THREE)) {
			if (LoadMap("maps/demo3.map")) {
				game.mode = STATE_PLAYING;
				game.cursor_captured = true;
				DisableCursor();
			}
		}
  
		// Game State Switcher
		switch (game.mode) {
			case STATE_MENU:
				UpdateMenu();
				DrawMenu();
				break;
			case STATE_PLAYING:
				UpdateGame();
				DrawGame();
				break;
		}
	}
  
	UnloadMap();
	UnloadAssets();
	vfs_shutdown();
	CloseWindow();
	sb_free(&map_path);
  
	return 0;
}

 #include "all.h"
 #include <ctype.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
+#include <float.h>
 char map_peek(MapParser *p) {
-    if (p->pos >= p->length) return 0;
+	if (p->pos >= p->length) return 0;
-    return p->data[p->pos];
+	return p->data[p->pos];
 }
 char map_get(MapParser *p) {
-    if (p->pos >= p->length) return 0;
+	if (p->pos >= p->length) return 0;
-    return p->data[p->pos++];
+	return p->data[p->pos++];
 }
 void map_skip_whitespace(MapParser *p) {
-    while (true) {
+	while (true) {
-        char c = map_peek(p);
+		char c = map_peek(p);
-        if (isspace(c)) {
+		if (isspace(c)) {
-            map_get(p);
+			map_get(p);
-        } else if (c == '/' && p->data[p->pos + 1] == '/') {
+		} else if (c == '/' && p->data[p->pos + 1] == '/') {
-            while (map_peek(p) != '\n' && map_peek(p) != 0) map_get(p);
+			while (map_peek(p) != '\n' && map_peek(p) != 0) map_get(p);
-        } else {
+		} else {
-            break;
+			break;
-        }
+		}
-    }
+	}
 }
 bool map_expect(MapParser *p, char expected) {
-    map_skip_whitespace(p);
+	map_skip_whitespace(p);
-    if (map_get(p) == expected) return true;
+	if (map_get(p) == expected) return true;
-    return false;
+	return false;
 }
 void map_parse_token(MapParser *p, char *buffer, int size) {
-    map_skip_whitespace(p);
+	map_skip_whitespace(p);
-    int i = 0;
+	int i = 0;
-    bool quoted = false;
+	bool quoted = false;
-    if (map_peek(p) == '"') {
+	if (map_peek(p) == '"') {
-        quoted = true;
+		quoted = true;
-        map_get(p);
+		map_get(p);
-    }
+	}
-    while (true) {
+	while (true) {
-        char c = map_peek(p);
+		char c = map_peek(p);
-        if (c == 0) break;
+		if (c == 0) break;
-        if (quoted) {
+		if (quoted) {
-            if (c == '"') {
+			if (c == '"') {
-                map_get(p);
+				map_get(p);
-                break;
+				break;
-            }
+			}
-        } else {
+		} else {
-            if (isspace(c) || c == '(' || c == ')' || c == '{' || c == '}') break;
+			if (isspace(c) || c == '(' || c == ')' || c == '{' || c == '}') break;
-        }
+		}
-        if (i < size - 1) buffer[i++] = map_get(p);
+		if (i < size - 1) buffer[i++] = map_get(p);
-        else map_get(p);
+		else map_get(p);
-    }
+	}
-    buffer[i] = 0;
+	buffer[i] = 0;
 }
 Vector3 map_parse_vector(MapParser *p) {
-    map_expect(p, '(');
+	map_expect(p, '(');
-    char buf[64];
+	char buf[64];
-    map_parse_token(p, buf, sizeof(buf));
+	map_parse_token(p, buf, sizeof(buf));
-    float x = (float)atof(buf);
+	float x = (float)atof(buf);
-    map_parse_token(p, buf, sizeof(buf));
+	map_parse_token(p, buf, sizeof(buf));
-    float y = (float)atof(buf);
+	float y = (float)atof(buf);
-    map_parse_token(p, buf, sizeof(buf));
+	map_parse_token(p, buf, sizeof(buf));
-    float z = (float)atof(buf);
+	float z = (float)atof(buf);
-    map_expect(p, ')');
+	map_expect(p, ')');
-    return (Vector3){ x, z, -y };
+	return (Vector3){ x, z, -y };
 }
 Map ParseMap(const char *filename) {
-    size_t size;
+	size_t size;
-    char *data = (char *)vfs_read(filename, &size);
+	char *data = (char *)vfs_read(filename, &size);
-    Map map = { 0 };
+	Map map = { 0 };
-    if (!data) return map;
+	if (!data) return map;
+	MapParser p = { data, size, 0 };
+	array(MapEntity) entities;
+	array_init(entities);
-    MapParser p = { data, size, 0 };
+	while (true) {
-    array(MapEntity) entities;
+		map_skip_whitespace(&p);
-    array_init(entities);
+		if (map_peek(&p) == 0) break;
+		if (map_expect(&p, '{')) {
+			MapEntity entity = { 0 };
+			array(MapProperty) props;
+			array(MapBrush) brushes;
+			array_init(props);
+			array_init(brushes);
-    while (true) {
+			while (true) {
-        map_skip_whitespace(&p);
+				map_skip_whitespace(&p);
-        if (map_peek(&p) == 0) break;
+				char c = map_peek(&p);
+				if (c == '}') {
+					map_get(&p);
+					break;
+				} else if (c == '"') {
+					MapProperty prop;
+					map_parse_token(&p, prop.key, sizeof(prop.key));
+					map_parse_token(&p, prop.value, sizeof(prop.value));
+					array_push(props, prop);
+				} else if (c == '{') {
+					map_get(&p);
+					MapBrush brush = { 0 };
+					array(MapPlane) planes;
+					array_init(planes);
+					while (true) {
+						map_skip_whitespace(&p);
+						if (map_peek(&p) == '}') {
+							map_get(&p);
+							break;
+						}
+						MapPlane plane;
+						plane.p[0] = map_parse_vector(&p);
+						plane.p[1] = map_parse_vector(&p);
+						plane.p[2] = map_parse_vector(&p);
+						map_parse_token(&p, plane.texture, sizeof(plane.texture));
-        if (map_expect(&p, '{')) {
+						char buf[64];
-            MapEntity entity = { 0 };
+						map_parse_token(&p, buf, sizeof(buf)); plane.shift[0] = (float)atof(buf);
-            array(MapProperty) props;
+						map_parse_token(&p, buf, sizeof(buf)); plane.shift[1] = (float)atof(buf);
-            array(MapBrush) brushes;
+						map_parse_token(&p, buf, sizeof(buf)); plane.rotate = (float)atof(buf);
-            array_init(props);
+						map_parse_token(&p, buf, sizeof(buf)); plane.scale[0] = (float)atof(buf);
-            array_init(brushes);
+						map_parse_token(&p, buf, sizeof(buf)); plane.scale[1] = (float)atof(buf);
-            while (true) {
+						array_push(planes, plane);
-                map_skip_whitespace(&p);
+					}
-                char c = map_peek(&p);
+					brush.planes = planes.data;
-                if (c == '}') {
+					brush.plane_count = (int)planes.length;
-                    map_get(&p);
+					array_push(brushes, brush);
-                    break;
+				} else {
-                } else if (c == '"') {
+					map_get(&p);
-                    MapProperty prop;
+				}
-                    map_parse_token(&p, prop.key, sizeof(prop.key));
+			}
-                    map_parse_token(&p, prop.value, sizeof(prop.value));
+			entity.properties = props.data;
-                    array_push(props, prop);
+			entity.property_count = (int)props.length;
-                } else if (c == '{') {
+			entity.brushes = brushes.data;
-                    map_get(&p);
+			entity.brush_count = (int)brushes.length;
-                    MapBrush brush = { 0 };
+			array_push(entities, entity);
-                    array(MapPlane) planes;
+		}
-                    array_init(planes);
+	}
-                    while (true) {
-                        map_skip_whitespace(&p);
-                        if (map_peek(&p) == '}') {
-                            map_get(&p);
-                            break;
-                        }
-                        MapPlane plane;
-                        plane.p[0] = map_parse_vector(&p);
-                        plane.p[1] = map_parse_vector(&p);
-                        plane.p[2] = map_parse_vector(&p);
-                        map_parse_token(&p, plane.texture, sizeof(plane.texture));
-                        char buf[64];
-                        map_parse_token(&p, buf, sizeof(buf)); plane.shift[0] = (float)atof(buf);
-                        map_parse_token(&p, buf, sizeof(buf)); plane.shift[1] = (float)atof(buf);
-                        map_parse_token(&p, buf, sizeof(buf)); plane.rotate = (float)atof(buf);
-                        map_parse_token(&p, buf, sizeof(buf)); plane.scale[0] = (float)atof(buf);
-                        map_parse_token(&p, buf, sizeof(buf)); plane.scale[1] = (float)atof(buf);
-                        array_push(planes, plane);
-                    }
-                    brush.planes = planes.data;
-                    brush.plane_count = (int)planes.length;
-                    array_push(brushes, brush);
-                } else {
-                    map_get(&p);
-                }
-            }
-            entity.properties = props.data;
-            entity.property_count = (int)props.length;
-            entity.brushes = brushes.data;
-            entity.brush_count = (int)brushes.length;
-            array_push(entities, entity);
-        }
-    }
-    map.entities = entities.data;
+	map.entities = entities.data;
-    map.entity_count = (int)entities.length;
+	map.entity_count = (int)entities.length;
-    vfs_free(data);
+	vfs_free(data);
-    return map;
+	return map;
 }
 void FreeMap(Map map) {
-    for (int i = 0; i < map.entity_count; i++) {
+	for (int i = 0; i < map.entity_count; i++) {
-        MapEntity *e = &map.entities[i];
+		MapEntity *e = &map.entities[i];
-        if (e->properties) free(e->properties);
+		if (e->properties) free(e->properties);
-        for (int j = 0; j < e->brush_count; j++) {
+		for (int j = 0; j < e->brush_count; j++) {
-            if (e->brushes[j].planes) free(e->brushes[j].planes);
+			if (e->brushes[j].planes) free(e->brushes[j].planes);
-        }
+		}
-        if (e->brushes) free(e->brushes);
+		if (e->brushes) free(e->brushes);
-    }
+	}
-    if (map.entities) free(map.entities);
+	if (map.entities) free(map.entities);
 }
 Plane PlaneFromPoints(Vector3 p1, Vector3 p2, Vector3 p3) {
-    Vector3 v1 = Vector3Subtract(p2, p1);
+	Vector3 v1 = Vector3Subtract(p2, p1);
-    Vector3 v2 = Vector3Subtract(p3, p1);
+	Vector3 v2 = Vector3Subtract(p3, p1);
-    Vector3 normal = Vector3Normalize(Vector3CrossProduct(v1, v2));
+	Vector3 normal = Vector3Normalize(Vector3CrossProduct(v1, v2));
-    return (Plane){ normal, Vector3DotProduct(normal, p1) };
+	return (Plane){ normal, Vector3DotProduct(normal, p1) };
 }
 void PolyFree(Polygon p) {
-    if (p.verts) free(p.verts);
+	if (p.verts) free(p.verts);
 }
 Polygon PolyClip(Polygon poly, Plane plane) {
-    if (poly.count == 0) return poly;
+	if (poly.count == 0) return poly;
-    array(Vector3) out_verts;
+	array(Vector3) out_verts;
-    array_init(out_verts);
+	array_init(out_verts);
-    for (int i = 0; i < poly.count; i++) {
+	for (int i = 0; i < poly.count; i++) {
-        Vector3 p1 = poly.verts[i];
+		Vector3 p1 = poly.verts[i];
-        Vector3 p2 = poly.verts[(i + 1) % poly.count];
+		Vector3 p2 = poly.verts[(i + 1) % poly.count];
-        float d1 = Vector3DotProduct(plane.normal, p1) - plane.dist;
+		float d1 = Vector3DotProduct(plane.normal, p1) - plane.dist;
-        float d2 = Vector3DotProduct(plane.normal, p2) - plane.dist;
+		float d2 = Vector3DotProduct(plane.normal, p2) - plane.dist;
-        // Using a smaller epsilon and more robust logic
+		const float eps = 0.001f;
-        const float eps = 0.001f;
-        if (d1 >= -eps) {
+		if (d1 >= -eps) {
-            if (d2 >= -eps) {
+			if (d2 >= -eps) {
-                array_push(out_verts, p2);
+				array_push(out_verts, p2);
-            } else {
+			} else {
-                float t = d1 / (d1 - d2);
+				float t = d1 / (d1 - d2);
-                Vector3 intersect = Vector3Add(p1, Vector3Scale(Vector3Subtract(p2, p1), t));
+				Vector3 intersect = Vector3Add(p1, Vector3Scale(Vector3Subtract(p2, p1), t));
-                array_push(out_verts, intersect);
+				array_push(out_verts, intersect);
-            }
+			}
-        } else {
+		} else {
-            if (d2 >= -eps) {
+			if (d2 >= -eps) {
-                float t = d1 / (d1 - d2);
+				float t = d1 / (d1 - d2);
-                Vector3 intersect = Vector3Add(p1, Vector3Scale(Vector3Subtract(p2, p1), t));
+				Vector3 intersect = Vector3Add(p1, Vector3Scale(Vector3Subtract(p2, p1), t));
-                array_push(out_verts, intersect);
+				array_push(out_verts, intersect);
-                array_push(out_verts, p2);
+				array_push(out_verts, p2);
-            }
+			}
-        }
+		}
-    }
+	}
-    Polygon res;
+	Polygon res;
-    res.verts = out_verts.data;
+	res.verts = out_verts.data;
-    res.count = (int)out_verts.length;
+	res.count = (int)out_verts.length;
-    return res;
+	return res;
 }
 Polygon CreateLargeQuad(Plane plane) {
-    Vector3 n = plane.normal;
+	Vector3 n = plane.normal;
-    Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
+	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
-    Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));
+	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));
-    up = Vector3CrossProduct(n, right);
+	up = Vector3CrossProduct(n, right);
-    Vector3 center = Vector3Scale(n, plane.dist);
+	Vector3 center = Vector3Scale(n, plane.dist);
-    float size = 10000.0f;
+	float size = 10000.0f;
-    Polygon poly;
+	Polygon poly;
-    poly.verts = ALLOC(Vector3, 4);
+	poly.verts = ALLOC(Vector3, 4);
-    poly.count = 4;
+	poly.count = 4;
-    poly.verts[0] = Vector3Add(center, Vector3Add(Vector3Scale(right, size), Vector3Scale(up, size)));
+	poly.verts[0] = Vector3Add(center, Vector3Add(Vector3Scale(right, size), Vector3Scale(up, size)));
-    poly.verts[1] = Vector3Add(center, Vector3Add(Vector3Scale(right, -size), Vector3Scale(up, size)));
+	poly.verts[1] = Vector3Add(center, Vector3Add(Vector3Scale(right, -size), Vector3Scale(up, size)));
-    poly.verts[2] = Vector3Add(center, Vector3Add(Vector3Scale(right, -size), Vector3Scale(up, -size)));
+	poly.verts[2] = Vector3Add(center, Vector3Add(Vector3Scale(right, -size), Vector3Scale(up, -size)));
-    poly.verts[3] = Vector3Add(center, Vector3Add(Vector3Scale(right, size), Vector3Scale(up, -size)));
+	poly.verts[3] = Vector3Add(center, Vector3Add(Vector3Scale(right, size), Vector3Scale(up, -size)));
-    return poly;
+	return poly;
 }
 Vector2 GetUV(Vector3 p, MapPlane *mp, Plane plane) {
-    Vector3 n = plane.normal;
+	Vector3 n = plane.normal;
-    Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
+	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
-    Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));
+	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));
-    up = Vector3CrossProduct(n, right);
+	up = Vector3CrossProduct(n, right);
-    float u = Vector3DotProduct(p, right) * (1.0f / (mp->scale[0] ? mp->scale[0] : 1.0f)) + mp->shift[0];
+	float u = Vector3DotProduct(p, right) * (1.0f / (mp->scale[0] ? mp->scale[0] : 1.0f)) + mp->shift[0];
-    float v = Vector3DotProduct(p, up) * (1.0f / (mp->scale[1] ? mp->scale[1] : 1.0f)) + mp->shift[1];
+	float v = Vector3DotProduct(p, up) * (1.0f / (mp->scale[1] ? mp->scale[1] : 1.0f)) + mp->shift[1];
-    return (Vector2){ u / 64.0f, v / 64.0f };
+	return (Vector2){ u / 64.0f, v / 64.0f };
+}
+void UnloadMap(void) {
+	if (game.map.models) {
+		for (int i = 0; i < game.map.count; i++) {
+			UnloadModel(game.map.models[i]);
+		}
+		free(game.map.models);
+		game.map.models = NULL;
+		game.map.count = 0;
+	}
+}
+bool LoadMap(const char *filename) {
+	TraceLog(LOG_INFO, "Loading map: %s", filename);
+	Map map = ParseMap(filename);
+	if (map.entity_count == 0) {
+		TraceLog(LOG_ERROR, "Failed to load map or map is empty: %s", filename);
+		return false;
+	}
+	UnloadMap();
+	array(TextureGroup) groups;
+	array_init(groups);
+	// Default player state if no start found
+	game.player.pos = (Vector3){ 0, 10, 0 };
+	game.player.yaw = 0;
+	game.player.pitch = 0;
+	int total_brushes = 0;
+	for (int i = 0; i < map.entity_count; i++) {
+		MapEntity *e = &map.entities[i];
+		bool is_world = false;
+		const char *classname = "";
+		for (int j = 0; j < e->property_count; j++) {
+			if (strcmp(e->properties[j].key, "classname") == 0) {
+				classname = e->properties[j].value;
+				if (strcmp(classname, "worldspawn") == 0) is_world = true;
+			}
+		}
+		// Handle entities (like player start)
+		for (int j = 0; j < e->property_count; j++) {
+			if (strcmp(e->properties[j].key, "origin") == 0) {
+				float x, y, z;
+				sscanf(e->properties[j].value, "%f %f %f", &x, &y, &z);
+				if (strcmp(classname, "info_player_start") == 0) {
+					game.player.pos = (Vector3){ x, z, -y };
+					float angle = 0;
+					for (int k = 0; k < e->property_count; k++) {
+						if (strcmp(e->properties[k].key, "angle") == 0) {
+							angle = (float)atof(e->properties[k].value);
+						}
+					}
+					game.player.yaw = (angle + 90.0f) * DEG2RAD;
+					game.player.pitch = 0;
+					TraceLog(LOG_INFO, "Player spawn set to: %f, %f, %f", game.player.pos.x, game.player.pos.y, game.player.pos.z);
+				}
+			}
+		}
+		if (is_world) {
+			total_brushes += e->brush_count;
+			for (int j = 0; j < e->brush_count; j++) {
+				MapBrush *brush = &e->brushes[j];
+				for (int p_idx = 0; p_idx < brush->plane_count; p_idx++) {
+					MapPlane *mp = &brush->planes[p_idx];
+					Plane plane = PlaneFromPoints(mp->p[0], mp->p[1], mp->p[2]);
+					if (Vector3Length(plane.normal) < 0.5f) continue;
+					Polygon poly = CreateLargeQuad(plane);
+					for (int k = 0; k < brush->plane_count; k++) {
+						if (p_idx == k) continue;
+						Plane clipPlane = PlaneFromPoints(brush->planes[k].p[0], brush->planes[k].p[1], brush->planes[k].p[2]);
+						if (Vector3Length(clipPlane.normal) < 0.5f) continue;
+						Polygon next = PolyClip(poly, clipPlane);
+						PolyFree(poly);
+						poly = next;
+					}
+					if (poly.count >= 3) {
+						TextureGroup *group = NULL;
+						for (int g = 0; g < groups.length; g++) {
+							if (strcmp(groups.data[g].texture, mp->texture) == 0) {
+								group = &groups.data[g];
+								break;
+							}
+						}
+						if (!group) {
+							TextureGroup new_group = { 0 };
+							strncpy(new_group.texture, mp->texture, sizeof(new_group.texture));
+							array_init(new_group.vertices);
+							array_init(new_group.texcoords);
+							array_init(new_group.normals);
+							array_push(groups, new_group);
+							group = &groups.data[groups.length - 1];
+						}
+						for (int v = 1; v < poly.count - 1; v++) {
+							Vector3 v0 = poly.verts[0];
+							Vector3 v1 = poly.verts[v+1];
+							Vector3 v2 = poly.verts[v];
+							array_push(group->vertices, v0.x); array_push(group->vertices, v0.y); array_push(group->vertices, v0.z);
+							array_push(group->vertices, v1.x); array_push(group->vertices, v1.y); array_push(group->vertices, v1.z);
+							array_push(group->vertices, v2.x); array_push(group->vertices, v2.y); array_push(group->vertices, v2.z);
+							Vector2 uv0 = GetUV(v0, mp, plane);
+							Vector2 uv1 = GetUV(v1, mp, plane);
+							Vector2 uv2 = GetUV(v2, mp, plane);
+							array_push(group->texcoords, uv0.x); array_push(group->texcoords, uv0.y);
+							array_push(group->texcoords, uv1.x); array_push(group->texcoords, uv1.y);
+							array_push(group->texcoords, uv2.x); array_push(group->texcoords, uv2.y);
+							Vector3 out_normal = Vector3Scale(plane.normal, -1.0f);
+							array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
+							array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
+							array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
+						}
+					}
+					PolyFree(poly);
+				}
+			}
+		}
+	}
+	array(Model) final_models;
+	array_init(final_models);
+	for (int i = 0; i < groups.length; i++) {
+		TextureGroup *g = &groups.data[i];
+		if (g->vertices.length == 0) continue;
+		Mesh mesh = { 0 };
+		mesh.vertexCount = (int)g->vertices.length / 3;
+		mesh.triangleCount = mesh.vertexCount / 3;
+		mesh.vertices = (float *)malloc(g->vertices.length * sizeof(float));
+		memcpy(mesh.vertices, g->vertices.data, g->vertices.length * sizeof(float));
+		mesh.texcoords = (float *)malloc(g->texcoords.length * sizeof(float));
+		memcpy(mesh.texcoords, g->texcoords.data, g->texcoords.length * sizeof(float));
+		mesh.normals = (float *)malloc(g->normals.length * sizeof(float));
+		memcpy(mesh.normals, g->normals.data, g->normals.length * sizeof(float));
+		UploadMesh(&mesh, false);
+		Model model = LoadModelFromMesh(mesh);
+		model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = GetTexture(g->texture);
+		array_push(final_models, model);
+		array_free(g->vertices);
+		array_free(g->texcoords);
+		array_free(g->normals);
+	}
+	game.map.models = final_models.data;
+	game.map.count = (int)final_models.length;
+	array_free(groups);
+	FreeMap(map);
+	TraceLog(LOG_INFO, "Processed %d brushes into %d models", total_brushes, game.map.count);
+	return true;
+}
+bool CheckMapCollision(Vector3 start, Vector3 end, RayCollision *outCollision) {
+	Vector3 diff = Vector3Subtract(end, start);
+	float maxDist = Vector3Length(diff);
+	if (maxDist < 0.001f) return false;
+	Ray ray = { 0 };
+	ray.position = start;
+	ray.direction = Vector3Scale(diff, 1.0f / maxDist);
+	RayCollision closest = { 0 };
+	closest.distance = FLT_MAX;
+	closest.hit = false;
+	for (int i = 0; i < game.map.count; i++) {
+		Model model = game.map.models[i];
+		for (int m = 0; m < model.meshCount; m++) {
+			RayCollision col = GetRayCollisionMesh(ray, model.meshes[m], model.transform);
+			if (col.hit && col.distance < closest.distance && col.distance <= maxDist) {
+				closest = col;
+			}
+		}
+	}
+	if (closest.hit) {
+		if (outCollision) *outCollision = closest;
+		return true;
+	}
+	return false;
 }

diff --git a/menu.c b/menu.c
	1	#include "all.h"
	2
	3	void UpdateMenu(void) {
	4	if (IsKeyPressed(KEY_ENTER)) {
	5	if (LoadMap(game.map_path)) {
	6	game.mode = STATE_PLAYING;
	7	game.cursor_captured = true;
	8	DisableCursor();
	9	}
	10	}
	11	}
	12
	13	void DrawMenu(void) {
	14	BeginDrawing();
	15	ClearBackground(BLACK);
	16
	17	int screenWidth = GetScreenWidth();
	18	int screenHeight = GetScreenHeight();
	19
	20	const char *title = "STALAG";
	21	const char *sub = "Press ENTER to Start";
	22
	23	int titleSize = 60;
	24	int subSize = 20;
	25
	26	Vector2 titlePos = {
	27	(float)(screenWidth - MeasureTextEx(game.font_ui, title, (float)titleSize, 4).x) / 2,
	28	(float)screenHeight / 2 - 40
	29	};
	30	Vector2 subPos = {
	31	(float)(screenWidth - MeasureTextEx(game.font_ui, sub, (float)subSize, 2).x) / 2,
	32	(float)screenHeight / 2 + 40
	33	};
	34
	35	DrawTextEx(game.font_ui, title, titlePos, (float)titleSize, 4, WHITE);
	36	DrawTextEx(game.font_ui, sub, subPos, (float)subSize, 2, GRAY);
	37
	38	EndDrawing();
	39	}


#include "all.h"
#include "raymath.h"
  
#include <float.h>
  
static void PlayerRotate(void) {
	if (!game.cursor_captured) return;
  
	Vector2 mouseDelta = GetMouseDelta();
	game.player.yaw += -mouseDelta.x * PLAYER_MOUSE_SENSITIVITY;
	game.player.pitch += mouseDelta.y * PLAYER_MOUSE_SENSITIVITY;
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
	if (game.player.pitch > 89.0f * DEG2RAD) game.player.pitch = 89.0f * DEG2RAD;
	if (game.player.pitch < -89.0f * DEG2RAD) game.player.pitch = -89.0f * DEG2RAD;
  
  
  
}
  
static void MoveNormal(float dt) {
	float eyeHeight = PLAYER_EYE_HEIGHT - (game.player.crouch_amount * PLAYER_CROUCH_OFFSET);
  
	Vector3 forward = { sinf(game.player.yaw), 0, cosf(game.player.yaw) };
	Vector3 right = { sinf(game.player.yaw - PI/2.0f), 0, cosf(game.player.yaw - PI/2.0f) };
  
  
	Vector3 moveDir = { 0 };
	if (IsKeyDown(KEY_W)) moveDir = Vector3Add(moveDir, forward);

  
	float speed = PLAYER_MOVE_SPEED;
	if (IsKeyDown(KEY_LEFT_SHIFT) || IsKeyDown(KEY_RIGHT_SHIFT)) speed *= PLAYER_SPRINT_MULTIPLIER;
	speed *= Lerp(1.0f, PLAYER_CROUCH_MOVE_MULTIPLIER, game.player.crouch_amount);
  
  
  
	if (Vector3Length(moveDir) > 0) {
		moveDir = Vector3Scale(Vector3Normalize(moveDir), speed * dt);
	}
  
	game.player.velocity.y -= PLAYER_GRAVITY * dt;
  
  
	if (game.player.is_grounded && IsKeyPressed(KEY_SPACE)) {
		game.player.velocity.y = PLAYER_JUMP_FORCE;
		game.player.is_grounded = false;
  
	}
  
  
	Vector3 remainingMove = moveDir;
	for (int iter = 0; iter < 4 && Vector3Length(remainingMove) > 0.001f; iter++) {
		RayCollision closestHit = { 0 };

		bool hitFound = false;
  
		float heights[] = { -eyeHeight + 10.0f, -eyeHeight / 2.0f, 0.0f };
		Vector3 currentPos = game.player.pos;
  
		for (int i = 0; i < 3; i++) {
			Vector3 start = Vector3Add(currentPos, (Vector3){0, heights[i], 0});

			Vector3 end = Vector3Add(start, Vector3Scale(dir, dist));
  
			RayCollision col;
			if (CheckMapCollision(start, end, &col)) {
  
				float adjustedDist = col.distance - PLAYER_RADIUS;
				if (adjustedDist < closestHit.distance) {
					closestHit = col;

		}
  
		if (hitFound) {
  
			float moveDist = fmaxf(0, closestHit.distance - 0.1f);
			Vector3 moveStep = Vector3Scale(Vector3Normalize(remainingMove), moveDist);
			game.player.pos.x += moveStep.x;
			game.player.pos.z += moveStep.z;
  
  
			Vector3 slideNormal = { closestHit.normal.x, 0, closestHit.normal.z };
			if (Vector3Length(slideNormal) > 0.001f) {
				slideNormal = Vector3Normalize(slideNormal);

				remainingMove = (Vector3){0, 0, 0};
			}
		} else {
			game.player.pos.x += remainingMove.x;
			game.player.pos.z += remainingMove.z;
  
			break;
		}
	}
  
	float verticalMove = game.player.velocity.y * dt;
	Vector3 vStart = game.player.pos;
  
  
	if (verticalMove < 0) {
		Vector3 start = vStart;
  
		Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove - eyeHeight, 0});
		RayCollision vCol;
		if (CheckMapCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {
			game.player.pos.y = vCol.point.y + eyeHeight;
			game.player.velocity.y = 0;
			game.player.is_grounded = true;
		} else {
			game.player.pos.y += verticalMove;
			game.player.is_grounded = false;
		}
	} else if (verticalMove > 0) {
		Vector3 start = vStart;
  
		float headHeight = PLAYER_HEIGHT - PLAYER_EYE_HEIGHT;
		Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove + headHeight, 0});
		RayCollision vCol;
		if (CheckMapCollision(start, end, &vCol)) {
			game.player.pos.y = vCol.point.y - headHeight - 1.0f;
			game.player.velocity.y = 0;
		} else {
			game.player.pos.y += verticalMove;
		}
		game.player.is_grounded = false;
	} else {
  
		Vector3 start = vStart;
		Vector3 end = Vector3Add(vStart, (Vector3){0, -eyeHeight - 2.0f, 0});
		RayCollision vCol;
		if (CheckMapCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {
			game.player.is_grounded = true;
  
			if (vCol.distance < eyeHeight + 1.0f) {
				game.player.pos.y = vCol.point.y + eyeHeight;
			}
		} else {
			game.player.is_grounded = false;
		}
	}
}
  
static void MoveFly(float dt) {
  
	Vector3 forward = { 
		cosf(game.player.pitch) * sinf(game.player.yaw), 
		-sinf(game.player.pitch), 
		cosf(game.player.pitch) * cosf(game.player.yaw) 
	};
	Vector3 right = { sinf(game.player.yaw - PI/2.0f), 0, cosf(game.player.yaw - PI/2.0f) };
  
	Vector3 move = { 0 };
	if (IsKeyDown(KEY_W)) move = Vector3Add(move, forward);

	if (IsKeyDown(KEY_D)) move = Vector3Add(move, right);
	if (IsKeyDown(KEY_A)) move = Vector3Subtract(move, right);
  
  
	if (IsKeyDown(KEY_SPACE)) move.y += 1.0f;
	if (IsKeyDown(KEY_LEFT_CONTROL)) move.y -= 1.0f;
  

  
	if (Vector3Length(move) > 0) {
		move = Vector3Scale(Vector3Normalize(move), speed * dt);
		game.player.pos = Vector3Add(game.player.pos, move);
	}
  
	game.player.velocity = (Vector3){0, 0, 0};
	game.player.is_grounded = false;
}
  
void UpdatePlayer(void) {
	float dt = GetFrameTime();
	Vector3 oldPos = game.player.pos;
  
	if (IsKeyPressed(KEY_F)) {
		game.player.move_mode = (game.player.move_mode == MOVE_NORMAL) ? MOVE_FLY : MOVE_NORMAL;
  
	}
  
	PlayerRotate();
  
  
	bool canStand = true;
	if (game.player.crouch_amount > 0.1f) {
		Vector3 headPos = game.player.pos;
		Vector3 headEnd = Vector3Add(headPos, (Vector3){0, PLAYER_HEIGHT - PLAYER_EYE_HEIGHT + PLAYER_CROUCH_OFFSET, 0});
		RayCollision col;
		if (CheckMapCollision(headPos, headEnd, &col)) {
			canStand = false;
		}
	}
  
	float targetCrouch = 0.0f;
	if (IsKeyDown(KEY_LEFT_CONTROL) || !canStand) targetCrouch = 1.0f;
	game.player.crouch_amount = Lerp(game.player.crouch_amount, targetCrouch, PLAYER_CROUCH_SPEED * dt);
  
  
	float targetLean = 0.0f;
	if (IsKeyDown(KEY_Q)) targetLean -= 1.0f;
	if (IsKeyDown(KEY_E)) targetLean += 1.0f;
	game.player.lean_amount = Lerp(game.player.lean_amount, targetLean, PLAYER_LEAN_SPEED * dt);
  
  
	if (game.player.move_mode == MOVE_FLY) {
		MoveFly(dt);
	} else {
		MoveNormal(dt);
	}
  
	float leanAngle = game.player.lean_amount * PLAYER_LEAN_ANGLE * DEG2RAD;
	Vector3 bodyForward = { sinf(game.player.yaw), 0, cosf(game.player.yaw) };
  
  
	float currentEyeHeight = PLAYER_EYE_HEIGHT - (game.player.crouch_amount * PLAYER_CROUCH_OFFSET);
	float pivotDist = fminf(PLAYER_LEAN_PIVOT_DISTANCE, currentEyeHeight * 0.8f);
  
	Vector3 neckToEye = { 0, pivotDist, 0 };
	Vector3 rotatedOffset = Vector3RotateByAxisAngle(neckToEye, bodyForward, leanAngle);
	Vector3 pivot = Vector3Subtract(game.player.pos, (Vector3){ 0, pivotDist, 0 });
  
  
	game.camera.position = Vector3Add(pivot, rotatedOffset);
  
  
	Vector3 forward = {
		cosf(game.player.pitch) * sinf(game.player.yaw),
		-sinf(game.player.pitch),
		cosf(game.player.pitch) * cosf(game.player.yaw)
	};
  
  
	Vector3 up = { 0, 1, 0 };
	up = Vector3RotateByAxisAngle(up, forward, leanAngle);
	game.camera.up = up;
  
  
	game.camera.target = Vector3Add(game.camera.position, Vector3Scale(forward, 20.0f));
  
  
	if (dt > 0) {
		Vector2 velH = { game.player.pos.x - oldPos.x, game.player.pos.z - oldPos.z };
		game.player.horizontal_speed = Vector2Length(velH) / dt;
	} else {
		game.player.horizontal_speed = 0;
	}
}

diff --git a/game.c b/game.c
1	#include "all.h"	1	#include "all.h"
2	#include <stdio.h>	2
3	#include <string.h>	3	#include <string.h>
4	#include <ctype.h>
5		4
6	GameState game;	5	GameState game;
7	static array(CachedTexture) texture_cache;
8
9	Texture2D GetTexture(const char *name) {
10	for (int i = 0; i < texture_cache.length; i++) {
11	if (strcmp(texture_cache.data[i].name, name) == 0) return texture_cache.data[i].tex;
12	}
13
14	char lname[256];
15	strncpy(lname, name, sizeof(lname));
16	for (int i = 0; lname[i]; i++) lname[i] = tolower(lname[i]);
17
18	char path[256];
19	void *data = NULL;
20	size_t size = 0;
21	const char *ext = ".jpg";
22
23	snprintf(path, sizeof(path), "textures/%s.png", lname);
24	data = vfs_read(path, &size);
25	if (data) {
26	ext = ".png";
27	} else {
28	snprintf(path, sizeof(path), "textures/%s.jpg", lname);
29	data = vfs_read(path, &size);
30	ext = ".jpg";
31	}
32
33	Texture2D tex = { 0 };
34	if (data) {
35	Image img = LoadImageFromMemory(ext, data, (int)size);
36	if (img.data) {
37	tex = LoadTextureFromImage(img);
38	UnloadImage(img);
39	}
40	vfs_free(data);
41	}
42
43	if (tex.id == 0) {
44	TraceLog(LOG_WARNING, "Failed to load texture: '%s' (tried path: '%s')", name, path);
45	Image img = GenImageChecked(64, 64, 8, 8, (Color){128, 128, 128, 255}, (Color){200, 200, 200, 255});
46	tex = LoadTextureFromImage(img);
47	UnloadImage(img);
48	}
49
50	if (tex.id != 0) {
51	GenTextureMipmaps(&tex);
52	SetTextureFilter(tex, TEXTURE_FILTER_BILINEAR);
53	SetTextureWrap(tex, TEXTURE_WRAP_REPEAT);
54
55	CachedTexture cached;
56	strncpy(cached.name, name, sizeof(cached.name));
57	cached.tex = tex;
58	array_push(texture_cache, cached);
59	}
60
61	return tex;
62	}
63
64	void UnloadMap(void) {
65	if (game.world_models) {
66	for (int i = 0; i < game.world_model_count; i++) {
67	UnloadModel(game.world_models[i]);
68	}
69	free(game.world_models);
70	game.world_models = NULL;
71	game.world_model_count = 0;
72	}
73
74	for (int i = 0; i < texture_cache.length; i++) {
75	UnloadTexture(texture_cache.data[i].tex);
76	}
77	array_clear(texture_cache);
78	}
79
80	bool LoadMap(const char *filename) {
81	TraceLog(LOG_INFO, "Loading map: %s", filename);
82
83	Map map = ParseMap(filename);
84	if (map.entity_count == 0) {
85	TraceLog(LOG_ERROR, "Failed to load map or map is empty: %s", filename);
86	return false;
87	}
88
89	UnloadMap();
90
91	array(TextureGroup) groups;
92	array_init(groups);
93
94	// Default camera if no start found
95	game.camera.position = (Vector3){ 0, 10, 0 };
96	game.camera.target = (Vector3){ 1, 10, 0 };
97	game.camera.up = (Vector3){ 0, 1, 0 };
98	game.camera.fovy = PLAYER_FOV;
99	game.camera.projection = CAMERA_PERSPECTIVE;
100
101	int total_brushes = 0;
102	for (int i = 0; i < map.entity_count; i++) {
103	MapEntity *e = &map.entities[i];
104	bool is_world = false;
105	const char *classname = "";
106	for (int j = 0; j < e->property_count; j++) {
107	if (strcmp(e->properties[j].key, "classname") == 0) {
108	classname = e->properties[j].value;
109	if (strcmp(classname, "worldspawn") == 0) is_world = true;
110	}
111	if (strcmp(e->properties[j].key, "origin") == 0) {
112	float x, y, z;
113	sscanf(e->properties[j].value, "%f %f %f", &x, &y, &z);
114	if (strcmp(classname, "info_player_start") == 0) {
115	game.pos = (Vector3){ x, z, -y };
116	game.camera.position = game.pos;
117	float angle = 0;
118	for (int k = 0; k < e->property_count; k++) {
119	if (strcmp(e->properties[k].key, "angle") == 0) {
120	angle = (float)atof(e->properties[k].value);
121	}
122	}
123	game.yaw = (angle + 90.0f) * DEG2RAD;
124	game.pitch = 0;
125	game.camera.target = Vector3Add(game.pos, (Vector3){sinf(game.yaw), 0, cosf(game.yaw)});
126	TraceLog(LOG_INFO, "Player spawn set to: %f, %f, %f (yaw: %f)", game.pos.x, game.pos.y, game.pos.z, game.yaw);
127	}
128	}
129	}
130
131	if (is_world) {
132	total_brushes += e->brush_count;
133	for (int j = 0; j < e->brush_count; j++) {
134	MapBrush *brush = &e->brushes[j];
135	for (int p_idx = 0; p_idx < brush->plane_count; p_idx++) {
136	MapPlane *mp = &brush->planes[p_idx];
137	Plane plane = PlaneFromPoints(mp->p[0], mp->p[1], mp->p[2]);
138
139	if (Vector3Length(plane.normal) < 0.5f) continue;
140
141	Polygon poly = CreateLargeQuad(plane);
142	for (int k = 0; k < brush->plane_count; k++) {
143	if (p_idx == k) continue;
144	Plane clipPlane = PlaneFromPoints(brush->planes[k].p[0], brush->planes[k].p[1], brush->planes[k].p[2]);
145	if (Vector3Length(clipPlane.normal) < 0.5f) continue;
146
147	Polygon next = PolyClip(poly, clipPlane);
148	PolyFree(poly);
149	poly = next;
150	}
151	if (poly.count >= 3) {
152	TextureGroup *group = NULL;
153	for (int g = 0; g < groups.length; g++) {
154	if (strcmp(groups.data[g].texture, mp->texture) == 0) {
155	group = &groups.data[g];
156	break;
157	}
158	}
159	if (!group) {
160	TextureGroup new_group = { 0 };
161	strncpy(new_group.texture, mp->texture, sizeof(new_group.texture));
162	array_init(new_group.vertices);
163	array_init(new_group.texcoords);
164	array_init(new_group.normals);
165	array_push(groups, new_group);
166	group = &groups.data[groups.length - 1];
167	}
168	for (int v = 1; v < poly.count - 1; v++) {
169	Vector3 v0 = poly.verts[0];
170	Vector3 v1 = poly.verts[v+1];
171	Vector3 v2 = poly.verts[v];
172	array_push(group->vertices, v0.x); array_push(group->vertices, v0.y); array_push(group->vertices, v0.z);
173	array_push(group->vertices, v1.x); array_push(group->vertices, v1.y); array_push(group->vertices, v1.z);
174	array_push(group->vertices, v2.x); array_push(group->vertices, v2.y); array_push(group->vertices, v2.z);
175	Vector2 uv0 = GetUV(v0, mp, plane);
176	Vector2 uv1 = GetUV(v1, mp, plane);
177	Vector2 uv2 = GetUV(v2, mp, plane);
178	array_push(group->texcoords, uv0.x); array_push(group->texcoords, uv0.y);
179	array_push(group->texcoords, uv1.x); array_push(group->texcoords, uv1.y);
180	array_push(group->texcoords, uv2.x); array_push(group->texcoords, uv2.y);
181	Vector3 out_normal = Vector3Scale(plane.normal, -1.0f);
182	array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
183	array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
184	array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
185	}
186	}
187	PolyFree(poly);
188	}
189	}
190	}
191	}
192
193	array(Model) final_models;
194	array_init(final_models);
195
196	for (int i = 0; i < groups.length; i++) {
197	TextureGroup *g = &groups.data[i];
198	if (g->vertices.length == 0) continue;
199	Mesh mesh = { 0 };
200	mesh.vertexCount = (int)g->vertices.length / 3;
201	mesh.triangleCount = mesh.vertexCount / 3;
202	mesh.vertices = (float )malloc(g->vertices.length sizeof(float));
203	memcpy(mesh.vertices, g->vertices.data, g->vertices.length * sizeof(float));
204	mesh.texcoords = (float )malloc(g->texcoords.length sizeof(float));
205	memcpy(mesh.texcoords, g->texcoords.data, g->texcoords.length * sizeof(float));
206	mesh.normals = (float )malloc(g->normals.length sizeof(float));
207	memcpy(mesh.normals, g->normals.data, g->normals.length * sizeof(float));
208	UploadMesh(&mesh, false);
209	Model model = LoadModelFromMesh(mesh);
210	model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = GetTexture(g->texture);
211	array_push(final_models, model);
212	array_free(g->vertices);
213	array_free(g->texcoords);
214	array_free(g->normals);
215	}
216
217	game.world_models = final_models.data;
218	game.world_model_count = (int)final_models.length;
219	array_free(groups);
220
221	FreeMap(map);
222	TraceLog(LOG_INFO, "Processed %d brushes into %d models", total_brushes, game.world_model_count);
223	return true;
224	}
225		6
226	void InitGame(void) {	7	void InitGame(void) {
227	array_init(texture_cache);	8	memset(&game, 0, sizeof(game));
228	game.world_models = NULL;
229	game.world_model_count = 0;
230
231	// Load UI Font
232	size_t font_size = 0;
233	void *font_data = vfs_read("fonts/LiberationSans-Bold.ttf", &font_size);
234	if (font_data) {
235	game.font_ui = LoadFontFromMemory(".ttf", font_data, (int)font_size, 20, NULL, 0);
236	vfs_free(font_data);
237	} else {
238	game.font_ui = GetFontDefault();
239	}
240		9
241	game.mode = STATE_TITLE;	10	game.font_ui = LoadFontVFS(UI_FONT_PATH, UI_FONT_SIZE);
		11	game.mode = STATE_MENU;
		12	game.cursor_captured = false;
		13	EnableCursor();
242		14
243	game.cursor_captured = false;	15	game.player.move_mode = MOVE_NORMAL;
244	EnableCursor();	16	game.player.pos = (Vector3){ 0, 0, 0 };
		17	game.player.velocity = (Vector3){ 0, 0, 0 };
		18	game.player.is_grounded = false;
245		19
246	game.move_mode = MOVE_NORMAL;	20	// Camera setup
247	game.velocity = (Vector3){ 0, 0, 0 };	21	game.camera.up = (Vector3){ 0, 1, 0 };
248	game.is_grounded = false;	22	game.camera.fovy = PLAYER_FOV;
		23	game.camera.projection = CAMERA_PERSPECTIVE;
249	}	24	}
250		25
251	void SetMap(const char *path) {	26	void SetMap(const char *path) {
252	strncpy(game.map_path, path, sizeof(game.map_path) - 1);	27	strncpy(game.map_path, path, sizeof(game.map_path) - 1);
253	game.map_path[sizeof(game.map_path) - 1] = '\0';	28	game.map_path[sizeof(game.map_path) - 1] = '\0';
254	}	29	}
255		30
256	void UpdateGame(void) {	31	void UpdateGame(void) {
257	if (game.mode == STATE_TITLE) {	32	if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {
258	if (IsKeyPressed(KEY_ENTER)) {	33	game.cursor_captured = !game.cursor_captured;
259	if (LoadMap(game.map_path)) {	34	if (game.cursor_captured) DisableCursor();
260	game.mode = STATE_PLAYING;	35	else EnableCursor();
261	}	36	}
262	}
263	return;
264	}
265
266	if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {
267	game.cursor_captured = !game.cursor_captured;
268	if (game.cursor_captured) DisableCursor();
269	else EnableCursor();
270	}
271
272	if (IsKeyPressed(KEY_ONE)) LoadMap("maps/demo1.map");
273	if (IsKeyPressed(KEY_TWO)) LoadMap("maps/demo2.map");
274	if (IsKeyPressed(KEY_THREE)) LoadMap("maps/demo3.map");
275		37
276	if (IsKeyPressed(KEY_V)) {	38	if (IsKeyPressed(KEY_V)) {
277	game.vsync = !game.vsync;	39	game.vsync = !game.vsync;
278	if (game.vsync) {	40	if (game.vsync) {
279	SetWindowState(FLAG_VSYNC_HINT);	41	SetWindowState(FLAG_VSYNC_HINT);
280	SetTargetFPS(GetMonitorRefreshRate(GetCurrentMonitor()));	42	SetTargetFPS(GetMonitorRefreshRate(GetCurrentMonitor()));
281	} else {	43	} else {
282	ClearWindowState(FLAG_VSYNC_HINT);	44	ClearWindowState(FLAG_VSYNC_HINT);
283	SetTargetFPS(0);	45	SetTargetFPS(0);
284	}	46	}
285	}	47	}
286		48
287	UpdatePlayer();	49	UpdatePlayer();
288	}	50	}
289		51
290	void DrawGame(void) {	52	void DrawGame(void) {
291	BeginDrawing();	53	BeginDrawing();
292	ClearBackground(BLACK);	54	ClearBackground(DARKGRAY);
293		55
294	if (game.mode == STATE_TITLE) {	56	BeginMode3D(game.camera);
295	int screenWidth = GetScreenWidth();
296	int screenHeight = GetScreenHeight();
297		57
298	const char *title = "STALAG";	58	rlEnableBackfaceCulling();
299	const char *sub = "Press ENTER to Start";	59	for (int i = 0; i < game.map.count; i++) {
300		60	DrawModel(game.map.models[i], (Vector3){ 0, 0, 0 }, 1.0f, WHITE);
301	int titleSize = 60;	61	}
302	int subSize = 20;
303		62
304	Vector2 titlePos = {	63	EndMode3D();
305	(float)(screenWidth - MeasureTextEx(game.font_ui, title, (float)titleSize, 4).x) / 2,
306	(float)screenHeight / 2 - 40
307	};
308	Vector2 subPos = {
309	(float)(screenWidth - MeasureTextEx(game.font_ui, sub, (float)subSize, 2).x) / 2,
310	(float)screenHeight / 2 + 40
311	};
312		64
313	DrawTextEx(game.font_ui, title, titlePos, (float)titleSize, 4, WHITE);	65	DrawCrosshair();
314	DrawTextEx(game.font_ui, sub, subPos, (float)subSize, 2, GRAY);	66	DrawDebugInfo();
315	} else {
316	ClearBackground(DARKGRAY);
317	BeginMode3D(game.camera);
318
319	// Enable backface culling to hide interior faces of brushes
320	rlEnableBackfaceCulling();
321	for (int i = 0; i < game.world_model_count; i++) {
322	DrawModel(game.world_models[i], (Vector3){ 0, 0, 0 }, 1.0f, WHITE);
323	}
324
325	EndMode3D();
326
327	DrawCrosshair();
328	DrawDebugInfo();
329	}
330		67
331	EndDrawing();	68	EndDrawing();
332	}	69	}

diff --git a/main.c b/main.c
1	#define _POSIX_C_SOURCE 200809L
2	#define NONSTD_IMPLEMENTATION	1	#define NONSTD_IMPLEMENTATION
3	#define VFS_IMPLEMENTATION	2	#define VFS_IMPLEMENTATION
4	#include "all.h"	3	#include "all.h"
		4
5	#include <getopt.h>	5	#include <getopt.h>
6	#include <string.h>
7		6
8	int main(int argc, char *argv[]) {	7	int main(int argc, char *argv[]) {
9	char map_path[256] = "maps/demo3.map";	8	stringb map_path;
10	bool skip_title = false;	9	sb_init(&map_path, 256);
		10	sb_append_cstr(&map_path, "maps/demo3.map");
11		11
12	static struct option long_options[] = {	12	bool skip_title = false;
13	{"map", required_argument, 0, 'm'},
14	{0, 0, 0, 0}
15	};
16		13
17	int opt;	14	static struct option long_options[] = {
18	int option_index = 0;	15	{"map", required_argument, 0, 'm'},
19	while ((opt = getopt_long_only(argc, argv, "m:", long_options, &option_index)) != -1) {	16	{0, 0, 0, 0}
20	switch (opt) {	17	};
21	case 'm':
22	strncpy(map_path, optarg, sizeof(map_path) - 1);
23	skip_title = true;
24	break;
25	}
26	}
27		18
28	SetConfigFlags(FLAG_VSYNC_HINT \| FLAG_WINDOW_RESIZABLE \| FLAG_WINDOW_HIGHDPI);	19	int opt;
29	InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE);	20	int option_index = 0;
		21	while ((opt = getopt_long_only(argc, argv, "m:", long_options, &option_index)) != -1) {
		22	switch (opt) {
		23	case 'm':
		24	sb_free(&map_path);
		25	sb_init(&map_path, 256);
		26	sb_append_cstr(&map_path, optarg);
		27	skip_title = true;
		28	break;
		29	}
		30	}
30		31
31	int monitor = GetCurrentMonitor();	32	SetConfigFlags(FLAG_VSYNC_HINT \| FLAG_WINDOW_RESIZABLE \| FLAG_WINDOW_HIGHDPI);
32	SetWindowPosition((GetMonitorWidth(monitor) - GetScreenWidth()) / 2,	33	InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE);
33	(GetMonitorHeight(monitor) - GetScreenHeight()) / 2);	34
34		35	int monitor = GetCurrentMonitor();
35	SetTargetFPS(GetMonitorRefreshRate(monitor));	36	SetWindowPosition((GetMonitorWidth(monitor) - GetScreenWidth()) / 2, (GetMonitorHeight(monitor) - GetScreenHeight()) / 2);
		37	SetTargetFPS(GetMonitorRefreshRate(monitor));
		38
		39	vfs_init(VFS_DATA_PAK);
		40	InitGame();
		41	SetMap(map_path.data);
36		42
37	vfs_init("data.pak");	43	if (skip_title) {
38	InitGame();	44	if (LoadMap(game.map_path)) {
39	SetMap(map_path);	45	game.mode = STATE_PLAYING;
		46	game.cursor_captured = true;
		47	DisableCursor();
		48	}
		49	}
40		50
41	if (skip_title) {	51	game.vsync = true;
42	if (LoadMap(game.map_path)) {
43	game.mode = STATE_PLAYING;
44	game.cursor_captured = true;
45	DisableCursor();
46	}
47	}
48		52
49	game.vsync = true;	53	while (!WindowShouldClose()) {
		54	// Global Map Switching (Debug/Demo)
		55	if (IsKeyPressed(KEY_ONE)) {
		56	if (LoadMap("maps/demo1.map")) {
		57	game.mode = STATE_PLAYING;
		58	game.cursor_captured = true;
		59	DisableCursor();
		60	}
		61	}
		62	if (IsKeyPressed(KEY_TWO)) {
		63	if (LoadMap("maps/demo2.map")) {
		64	game.mode = STATE_PLAYING;
		65	game.cursor_captured = true;
		66	DisableCursor();
		67	}
		68	}
		69	if (IsKeyPressed(KEY_THREE)) {
		70	if (LoadMap("maps/demo3.map")) {
		71	game.mode = STATE_PLAYING;
		72	game.cursor_captured = true;
		73	DisableCursor();
		74	}
		75	}
50		76
51	while (!WindowShouldClose()) {	77	// Game State Switcher
52	UpdateGame();	78	switch (game.mode) {
53	DrawGame();	79	case STATE_MENU:
54	}	80	UpdateMenu();
		81	DrawMenu();
		82	break;
		83	case STATE_PLAYING:
		84	UpdateGame();
		85	DrawGame();
		86	break;
		87	}
		88	}
55		89
56	vfs_shutdown();	90	UnloadMap();
57	CloseWindow();	91	UnloadAssets();
		92	vfs_shutdown();
		93	CloseWindow();
		94	sb_free(&map_path);
58		95
59	return 0;	96	return 0;
60	}	97	}

diff --git a/player.c b/player.c
1	#include "all.h"	1	#include "all.h"
2	#include "raymath.h"	2	#include "raymath.h"
		3
3	#include <float.h>	4	#include <float.h>
4		5
5	static void PlayerRotate(void) {	6	static void PlayerRotate(void) {
6	if (!game.cursor_captured) return;	7	if (!game.cursor_captured) return;
7		8
8	Vector2 mouseDelta = GetMouseDelta();	9	Vector2 mouseDelta = GetMouseDelta();
9	game.yaw += -mouseDelta.x * PLAYER_MOUSE_SENSITIVITY;	10	game.player.yaw += -mouseDelta.x * PLAYER_MOUSE_SENSITIVITY;
10	game.pitch += mouseDelta.y * PLAYER_MOUSE_SENSITIVITY;	11	game.player.pitch += mouseDelta.y * PLAYER_MOUSE_SENSITIVITY;
11
12	// Clamp pitch to avoid gimbal lock/flipping (approx 89 degrees)
13	if (game.pitch > 89.0f * DEG2RAD) game.pitch = 89.0f * DEG2RAD;
14	if (game.pitch < -89.0f * DEG2RAD) game.pitch = -89.0f * DEG2RAD;
15	}
16
17	static bool CheckWorldCollision(Vector3 start, Vector3 end, RayCollision *outCollision) {
18	Vector3 diff = Vector3Subtract(end, start);
19	float maxDist = Vector3Length(diff);
20	if (maxDist < 0.001f) return false;
21
22	Ray ray = { 0 };
23	ray.position = start;
24	ray.direction = Vector3Scale(diff, 1.0f / maxDist);
25
26	RayCollision closest = { 0 };
27	closest.distance = FLT_MAX;
28	closest.hit = false;
29
30	for (int i = 0; i < game.world_model_count; i++) {
31	Model model = game.world_models[i];
32	for (int m = 0; m < model.meshCount; m++) {
33	RayCollision col = GetRayCollisionMesh(ray, model.meshes[m], model.transform);
34	if (col.hit && col.distance < closest.distance && col.distance <= maxDist) {
35	closest = col;
36	}
37	}
38	}
39		12
40	if (closest.hit) {	13	if (game.player.pitch > 89.0f * DEG2RAD) game.player.pitch = 89.0f * DEG2RAD;
41	if (outCollision) *outCollision = closest;	14	if (game.player.pitch < -89.0f * DEG2RAD) game.player.pitch = -89.0f * DEG2RAD;
42	return true;
43	}
44	return false;
45	}	15	}
46		16
47	static void MoveNormal(float dt) {	17	static void MoveNormal(float dt) {
48	float eyeHeight = PLAYER_EYE_HEIGHT - (game.crouch_amount * PLAYER_CROUCH_OFFSET);	18	float eyeHeight = PLAYER_EYE_HEIGHT - (game.player.crouch_amount * PLAYER_CROUCH_OFFSET);
49		19
50	// Movement vectors based on yaw	20	Vector3 forward = { sinf(game.player.yaw), 0, cosf(game.player.yaw) };
51	Vector3 forward = { sinf(game.yaw), 0, cosf(game.yaw) };	21	Vector3 right = { sinf(game.player.yaw - PI/2.0f), 0, cosf(game.player.yaw - PI/2.0f) };
52	Vector3 right = { sinf(game.yaw - PI/2.0f), 0, cosf(game.yaw - PI/2.0f) };
53		22
54	Vector3 moveDir = { 0 };	23	Vector3 moveDir = { 0 };
55	if (IsKeyDown(KEY_W)) moveDir = Vector3Add(moveDir, forward);	24	if (IsKeyDown(KEY_W)) moveDir = Vector3Add(moveDir, forward);
...
59		28
60	float speed = PLAYER_MOVE_SPEED;	29	float speed = PLAYER_MOVE_SPEED;
61	if (IsKeyDown(KEY_LEFT_SHIFT) \|\| IsKeyDown(KEY_RIGHT_SHIFT)) speed *= PLAYER_SPRINT_MULTIPLIER;	30	if (IsKeyDown(KEY_LEFT_SHIFT) \|\| IsKeyDown(KEY_RIGHT_SHIFT)) speed *= PLAYER_SPRINT_MULTIPLIER;
62		31	speed *= Lerp(1.0f, PLAYER_CROUCH_MOVE_MULTIPLIER, game.player.crouch_amount);
63	// Apply crouch speed penalty
64	speed *= Lerp(1.0f, PLAYER_CROUCH_MOVE_MULTIPLIER, game.crouch_amount);
65		32
66	if (Vector3Length(moveDir) > 0) {	33	if (Vector3Length(moveDir) > 0) {
67	moveDir = Vector3Scale(Vector3Normalize(moveDir), speed * dt);	34	moveDir = Vector3Scale(Vector3Normalize(moveDir), speed * dt);
68	}	35	}
69		36
70	// Apply gravity	37	game.player.velocity.y -= PLAYER_GRAVITY * dt;
71	game.velocity.y -= PLAYER_GRAVITY * dt;
72		38
73	// Jump	39	if (game.player.is_grounded && IsKeyPressed(KEY_SPACE)) {
74	if (game.is_grounded && IsKeyPressed(KEY_SPACE)) {	40	game.player.velocity.y = PLAYER_JUMP_FORCE;
75	game.velocity.y = PLAYER_JUMP_FORCE;	41	game.player.is_grounded = false;
76	game.is_grounded = false;
77	}	42	}
78		43
79	// Horizontal movement with sliding collision
80	Vector3 remainingMove = moveDir;	44	Vector3 remainingMove = moveDir;
81	for (int iter = 0; iter < 4 && Vector3Length(remainingMove) > 0.001f; iter++) {	45	for (int iter = 0; iter < 4 && Vector3Length(remainingMove) > 0.001f; iter++) {
82	RayCollision closestHit = { 0 };	46	RayCollision closestHit = { 0 };
...
84	bool hitFound = false;	48	bool hitFound = false;
85		49
86	float heights[] = { -eyeHeight + 10.0f, -eyeHeight / 2.0f, 0.0f };	50	float heights[] = { -eyeHeight + 10.0f, -eyeHeight / 2.0f, 0.0f };
87	Vector3 currentPos = game.pos;	51	Vector3 currentPos = game.player.pos;
88		52
89	for (int i = 0; i < 3; i++) {	53	for (int i = 0; i < 3; i++) {
90	Vector3 start = Vector3Add(currentPos, (Vector3){0, heights[i], 0});	54	Vector3 start = Vector3Add(currentPos, (Vector3){0, heights[i], 0});
...
93	Vector3 end = Vector3Add(start, Vector3Scale(dir, dist));	57	Vector3 end = Vector3Add(start, Vector3Scale(dir, dist));
94		58
95	RayCollision col;	59	RayCollision col;
96	if (CheckWorldCollision(start, end, &col)) {	60	if (CheckMapCollision(start, end, &col)) {
97	// Adjust distance to be relative to the player boundary
98	float adjustedDist = col.distance - PLAYER_RADIUS;	61	float adjustedDist = col.distance - PLAYER_RADIUS;
99	if (adjustedDist < closestHit.distance) {	62	if (adjustedDist < closestHit.distance) {
100	closestHit = col;	63	closestHit = col;
...
105	}	68	}
106		69
107	if (hitFound) {	70	if (hitFound) {
108	// Move as far as possible
109	float moveDist = fmaxf(0, closestHit.distance - 0.1f);	71	float moveDist = fmaxf(0, closestHit.distance - 0.1f);
110	Vector3 moveStep = Vector3Scale(Vector3Normalize(remainingMove), moveDist);	72	Vector3 moveStep = Vector3Scale(Vector3Normalize(remainingMove), moveDist);
111	game.pos.x += moveStep.x;	73	game.player.pos.x += moveStep.x;
112	game.pos.z += moveStep.z;	74	game.player.pos.z += moveStep.z;
113		75
114	// Project remaining movement onto the plane of the wall
115	Vector3 slideNormal = { closestHit.normal.x, 0, closestHit.normal.z };	76	Vector3 slideNormal = { closestHit.normal.x, 0, closestHit.normal.z };
116	if (Vector3Length(slideNormal) > 0.001f) {	77	if (Vector3Length(slideNormal) > 0.001f) {
117	slideNormal = Vector3Normalize(slideNormal);	78	slideNormal = Vector3Normalize(slideNormal);
...
122	remainingMove = (Vector3){0, 0, 0};	83	remainingMove = (Vector3){0, 0, 0};
123	}	84	}
124	} else {	85	} else {
125	// No collision found, move the rest of the way	86	game.player.pos.x += remainingMove.x;
126	game.pos.x += remainingMove.x;	87	game.player.pos.z += remainingMove.z;
127	game.pos.z += remainingMove.z;
128	break;	88	break;
129	}	89	}
130	}	90	}
131		91
132	// Vertical movement with collision	92	float verticalMove = game.player.velocity.y * dt;
133	float verticalMove = game.velocity.y * dt;	93	Vector3 vStart = game.player.pos;
134	Vector3 vStart = game.pos;
135		94
136	if (verticalMove < 0) { // Falling/Down	95	if (verticalMove < 0) {
137	Vector3 start = vStart;	96	Vector3 start = vStart;
138	// Check slightly below feet
139	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove - eyeHeight, 0});	97	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove - eyeHeight, 0});
140	RayCollision vCol;	98	RayCollision vCol;
141	if (CheckWorldCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {	99	if (CheckMapCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {
142	game.pos.y = vCol.point.y + eyeHeight;	100	game.player.pos.y = vCol.point.y + eyeHeight;
143	game.velocity.y = 0;	101	game.player.velocity.y = 0;
144	game.is_grounded = true;	102	game.player.is_grounded = true;
145	} else {	103	} else {
146	game.pos.y += verticalMove;	104	game.player.pos.y += verticalMove;
147	game.is_grounded = false;	105	game.player.is_grounded = false;
148	}	106	}
149	} else if (verticalMove > 0) { // Jumping/Up	107	} else if (verticalMove > 0) {
150	Vector3 start = vStart;	108	Vector3 start = vStart;
151	// Check above head
152	float headHeight = PLAYER_HEIGHT - PLAYER_EYE_HEIGHT;	109	float headHeight = PLAYER_HEIGHT - PLAYER_EYE_HEIGHT;
153	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove + headHeight, 0});	110	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove + headHeight, 0});
154	RayCollision vCol;	111	RayCollision vCol;
155	if (CheckWorldCollision(start, end, &vCol)) {	112	if (CheckMapCollision(start, end, &vCol)) {
156	game.pos.y = vCol.point.y - headHeight - 1.0f;	113	game.player.pos.y = vCol.point.y - headHeight - 1.0f;
157	game.velocity.y = 0;	114	game.player.velocity.y = 0;
158	} else {	115	} else {
159	game.pos.y += verticalMove;	116	game.player.pos.y += verticalMove;
160	}	117	}
161	game.is_grounded = false;	118	game.player.is_grounded = false;
162	} else {	119	} else {
163	// Not moving vertically, but check if we are still on ground
164	Vector3 start = vStart;	120	Vector3 start = vStart;
165	Vector3 end = Vector3Add(vStart, (Vector3){0, -eyeHeight - 2.0f, 0});	121	Vector3 end = Vector3Add(vStart, (Vector3){0, -eyeHeight - 2.0f, 0});
166	RayCollision vCol;	122	RayCollision vCol;
167	if (CheckWorldCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {	123	if (CheckMapCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {
168	game.is_grounded = true;	124	game.player.is_grounded = true;
169	// Snap to floor if very close
170	if (vCol.distance < eyeHeight + 1.0f) {	125	if (vCol.distance < eyeHeight + 1.0f) {
171	game.pos.y = vCol.point.y + eyeHeight;	126	game.player.pos.y = vCol.point.y + eyeHeight;
172	}	127	}
173	} else {	128	} else {
174	game.is_grounded = false;	129	game.player.is_grounded = false;
175	}	130	}
176	}	131	}
177	}	132	}
178		133
179	static void MoveFly(float dt) {	134	static void MoveFly(float dt) {
180	// Full 3D movement based on yaw/pitch
181	Vector3 forward = {	135	Vector3 forward = {
182	cosf(game.pitch) * sinf(game.yaw),	136	cosf(game.player.pitch) * sinf(game.player.yaw),
183	-sinf(game.pitch),	137	-sinf(game.player.pitch),
184	cosf(game.pitch) * cosf(game.yaw)	138	cosf(game.player.pitch) * cosf(game.player.yaw)
185	};	139	};
186	Vector3 right = { sinf(game.yaw - PI/2.0f), 0, cosf(game.yaw - PI/2.0f) };	140	Vector3 right = { sinf(game.player.yaw - PI/2.0f), 0, cosf(game.player.yaw - PI/2.0f) };
187		141
188	Vector3 move = { 0 };	142	Vector3 move = { 0 };
189	if (IsKeyDown(KEY_W)) move = Vector3Add(move, forward);	143	if (IsKeyDown(KEY_W)) move = Vector3Add(move, forward);
...
191	if (IsKeyDown(KEY_D)) move = Vector3Add(move, right);	145	if (IsKeyDown(KEY_D)) move = Vector3Add(move, right);
192	if (IsKeyDown(KEY_A)) move = Vector3Subtract(move, right);	146	if (IsKeyDown(KEY_A)) move = Vector3Subtract(move, right);
193		147
194	// Fly up/down
195	if (IsKeyDown(KEY_SPACE)) move.y += 1.0f;	148	if (IsKeyDown(KEY_SPACE)) move.y += 1.0f;
196	if (IsKeyDown(KEY_LEFT_CONTROL)) move.y -= 1.0f;	149	if (IsKeyDown(KEY_LEFT_CONTROL)) move.y -= 1.0f;
197		150
...
200		153
201	if (Vector3Length(move) > 0) {	154	if (Vector3Length(move) > 0) {
202	move = Vector3Scale(Vector3Normalize(move), speed * dt);	155	move = Vector3Scale(Vector3Normalize(move), speed * dt);
203	game.pos = Vector3Add(game.pos, move);	156	game.player.pos = Vector3Add(game.player.pos, move);
204	}	157	}
205		158
206	game.velocity = (Vector3){0, 0, 0};	159	game.player.velocity = (Vector3){0, 0, 0};
207	game.is_grounded = false;	160	game.player.is_grounded = false;
208	}	161	}
209		162
210	void UpdatePlayer(void) {	163	void UpdatePlayer(void) {
211	float dt = GetFrameTime();	164	float dt = GetFrameTime();
212	Vector3 oldPos = game.pos;	165	Vector3 oldPos = game.player.pos;
213		166
214	if (IsKeyPressed(KEY_F)) {	167	if (IsKeyPressed(KEY_F)) {
215	game.move_mode = (game.move_mode == MOVE_NORMAL) ? MOVE_FLY : MOVE_NORMAL;	168	game.player.move_mode = (game.player.move_mode == MOVE_NORMAL) ? MOVE_FLY : MOVE_NORMAL;
216	TraceLog(LOG_INFO, "Movement mode: %s", (game.move_mode == MOVE_NORMAL) ? "NORMAL" : "FLY");
217	}	169	}
218		170
219	PlayerRotate();	171	PlayerRotate();
220		172
221	// Crouching logic
222	bool canStand = true;	173	bool canStand = true;
223	if (game.crouch_amount > 0.1f) {	174	if (game.player.crouch_amount > 0.1f) {
224	Vector3 headPos = game.pos;	175	Vector3 headPos = game.player.pos;
225	Vector3 headEnd = Vector3Add(headPos, (Vector3){0, PLAYER_HEIGHT - PLAYER_EYE_HEIGHT + PLAYER_CROUCH_OFFSET, 0});	176	Vector3 headEnd = Vector3Add(headPos, (Vector3){0, PLAYER_HEIGHT - PLAYER_EYE_HEIGHT + PLAYER_CROUCH_OFFSET, 0});
226	RayCollision col;	177	RayCollision col;
227	if (CheckWorldCollision(headPos, headEnd, &col)) {	178	if (CheckMapCollision(headPos, headEnd, &col)) {
228	canStand = false;	179	canStand = false;
229	}	180	}
230	}	181	}
231		182
232	float targetCrouch = 0.0f;	183	float targetCrouch = 0.0f;
233	if (IsKeyDown(KEY_LEFT_CONTROL) \|\| !canStand) targetCrouch = 1.0f;	184	if (IsKeyDown(KEY_LEFT_CONTROL) \|\| !canStand) targetCrouch = 1.0f;
234	game.crouch_amount = Lerp(game.crouch_amount, targetCrouch, PLAYER_CROUCH_SPEED * dt);	185	game.player.crouch_amount = Lerp(game.player.crouch_amount, targetCrouch, PLAYER_CROUCH_SPEED * dt);
235		186
236	// Leaning logic
237	float targetLean = 0.0f;	187	float targetLean = 0.0f;
238	if (IsKeyDown(KEY_Q)) targetLean -= 1.0f;	188	if (IsKeyDown(KEY_Q)) targetLean -= 1.0f;
239	if (IsKeyDown(KEY_E)) targetLean += 1.0f;	189	if (IsKeyDown(KEY_E)) targetLean += 1.0f;
240		190	game.player.lean_amount = Lerp(game.player.lean_amount, targetLean, PLAYER_LEAN_SPEED * dt);
241	game.lean_amount = Lerp(game.lean_amount, targetLean, PLAYER_LEAN_SPEED * dt);
242		191
243	if (game.move_mode == MOVE_FLY) {	192	if (game.player.move_mode == MOVE_FLY) {
244	MoveFly(dt);	193	MoveFly(dt);
245	} else {	194	} else {
246	MoveNormal(dt);	195	MoveNormal(dt);
247	}	196	}
248		197
249	// Apply lean as a pivot from the neck/waist	198	float leanAngle = game.player.lean_amount * PLAYER_LEAN_ANGLE * DEG2RAD;
250	float leanAngle = game.lean_amount * PLAYER_LEAN_ANGLE * DEG2RAD;	199	Vector3 bodyForward = { sinf(game.player.yaw), 0, cosf(game.player.yaw) };
251	Vector3 bodyForward = { sinf(game.yaw), 0, cosf(game.yaw) };
252		200
253	float currentEyeHeight = PLAYER_EYE_HEIGHT - (game.crouch_amount * PLAYER_CROUCH_OFFSET);	201	float currentEyeHeight = PLAYER_EYE_HEIGHT - (game.player.crouch_amount * PLAYER_CROUCH_OFFSET);
254	float pivotDist = fminf(PLAYER_LEAN_PIVOT_DISTANCE, currentEyeHeight * 0.8f);	202	float pivotDist = fminf(PLAYER_LEAN_PIVOT_DISTANCE, currentEyeHeight * 0.8f);
255		203
256	Vector3 neckToEye = { 0, pivotDist, 0 };	204	Vector3 neckToEye = { 0, pivotDist, 0 };
257	Vector3 rotatedOffset = Vector3RotateByAxisAngle(neckToEye, bodyForward, leanAngle);	205	Vector3 rotatedOffset = Vector3RotateByAxisAngle(neckToEye, bodyForward, leanAngle);
258	Vector3 pivot = Vector3Subtract(game.pos, (Vector3){ 0, pivotDist, 0 });	206	Vector3 pivot = Vector3Subtract(game.player.pos, (Vector3){ 0, pivotDist, 0 });
259		207
260	// Update camera based on physical pos + visual lean pivot
261	game.camera.position = Vector3Add(pivot, rotatedOffset);	208	game.camera.position = Vector3Add(pivot, rotatedOffset);
262		209
263	// Apply roll to up vector
264	Vector3 forward = {	210	Vector3 forward = {
265	cosf(game.pitch) * sinf(game.yaw),	211	cosf(game.player.pitch) * sinf(game.player.yaw),
266	-sinf(game.pitch),	212	-sinf(game.player.pitch),
267	cosf(game.pitch) * cosf(game.yaw)	213	cosf(game.player.pitch) * cosf(game.player.yaw)
268	};	214	};
269		215
270	// Use a stable world-up vector and apply lean roll
271	Vector3 up = { 0, 1, 0 };	216	Vector3 up = { 0, 1, 0 };
272	up = Vector3RotateByAxisAngle(up, forward, leanAngle);	217	up = Vector3RotateByAxisAngle(up, forward, leanAngle);
273	game.camera.up = up;	218	game.camera.up = up;
274
275	// Use a longer target distance for better precision in the projection matrix
276	game.camera.target = Vector3Add(game.camera.position, Vector3Scale(forward, 20.0f));	219	game.camera.target = Vector3Add(game.camera.position, Vector3Scale(forward, 20.0f));
277		220
278	// Calculate horizontal speed for UI
279	if (dt > 0) {	221	if (dt > 0) {
280	Vector2 velH = { game.pos.x - oldPos.x, game.pos.z - oldPos.z };	222	Vector2 velH = { game.player.pos.x - oldPos.x, game.player.pos.z - oldPos.z };
281	game.horizontal_speed = Vector2Length(velH) / dt;	223	game.player.horizontal_speed = Vector2Length(velH) / dt;
282	} else {	224	} else {
283	game.horizontal_speed = 0;	225	game.player.horizontal_speed = 0;
284	}	226	}
285	}	227	}