Commit b1106c7

Convert local functions to lower case

Author	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-05-05 01:59:45 +0200
Committer	Mitja Felicijan <mitja.felicijan@gmail.com>	2026-05-05 01:59:45 +0200
Commit	`b1106c79dfdabc5379f9588a088e415aea29d7b8` (patch)

`-rw-r--r--`	all.h	44
`-rw-r--r--`	assets.c	6
`-rw-r--r--`	game.c	16
`-rw-r--r--`	interface.c	4
`-rw-r--r--`	main.c	24
`-rw-r--r--`	map.c	46
`-rw-r--r--`	maps/demo4.map	65
`-rw-r--r--`	menu.c	6
`-rw-r--r--`	player.c	12
`-rw-r--r--`	textures/interior/interior_wall.xcf	bin 0 B -> 58.9 KB
`-rw-r--r--`	textures/interior/interior_wall_001.png	bin 0 B -> 6.5 KB
`-rw-r--r--`	textures/interior/interior_wall_002.png	bin 0 B -> 8.0 KB
`-rw-r--r--`	textures/interior/interior_wall_003.png	bin 0 B -> 10.4 KB
`-rw-r--r--`	textures/palette.xcf	bin 0 B -> 4.7 KB

14 files changed, 144 insertions, 79 deletions



} CachedTexture;
  
// Asset Module
Texture2D get_texture(const char *name);
void unload_assets(void);
Font load_font_vfs(const char *path, int fontSize);
  
// Map Module
typedef struct {

	int count;
} MapState;
  
bool load_map(const char *filename);
void unload_map(void);
bool check_map_collision(Vector3 start, Vector3 end, RayCollision *outCollision);
Map parse_map(const char *filename);
void free_map(Map map);
  
// Menu Module
void update_menu(void);
void draw_menu(void);
  
// Player Module
typedef enum {

	float camera_offset_y; // Vertical offset for stair smoothing
} PlayerState;
  
void update_player(void);
  
// Game State Module
typedef enum {

  
extern GameState game;
  
void init_game(void);
void set_map(const char *path);
void update_game(void);
void draw_game(void);
  
// Geometry Helpers
Plane plane_from_points(Vector3 p1, Vector3 p2, Vector3 p3);
void poly_free(Polygon p);
Polygon poly_clip(Polygon poly, Plane plane);
Polygon create_large_quad(Plane plane);
Vector2 get_uv(Vector3 p, MapPlane *mp, Plane plane);
  
// Interface
void draw_crosshair(void);
void draw_debug_info(void);
  
#endif



  
static array(CachedTexture) texture_cache;
  
Texture2D get_texture(const char *name) {
	if (texture_cache.data == NULL) {
		array_init(texture_cache);
	}

	return tex;
}
  
void unload_assets(void) {
	for (int i = 0; i < texture_cache.length; i++) {
		UnloadTexture(texture_cache.data[i].tex);
	}
	array_clear(texture_cache);
}
  
Font load_font_vfs(const char *path, int fontSize) {
	size_t size = 0;
	void *data = vfs_read(path, &size);
	if (data) {




  
GameState game;
  
void init_game(void) {
	memset(&game, 0, sizeof(game));
  
	game.font_ui = load_font_vfs(UI_FONT_PATH, UI_FONT_SIZE);
	game.mode = STATE_MENU;
	game.cursor_captured = false;
	EnableCursor();

	game.camera.projection = CAMERA_PERSPECTIVE;
}
  
void set_map(const char *path) {
	strncpy(game.map_path, path, sizeof(game.map_path) - 1);
	game.map_path[sizeof(game.map_path) - 1] = '\0';
}
  
void update_game(void) {
	if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {
		game.cursor_captured = !game.cursor_captured;
		if (game.cursor_captured) DisableCursor();

		}
	}
  
	update_player();
}
  
void draw_game(void) {
	BeginDrawing();
	ClearBackground(DARKGRAY);
  

  
	EndMode3D();
  
	draw_crosshair();
	draw_debug_info();
  
	EndDrawing();
}


#include "all.h"
  
void draw_crosshair(void) {
	int screenWidth = GetScreenWidth();
	int screenHeight = GetScreenHeight();
	DrawLine(screenWidth / 2 - 10, screenHeight / 2, screenWidth / 2 + 10, screenHeight / 2, GREEN);
	DrawLine(screenWidth / 2, screenHeight / 2 - 10, screenWidth / 2, screenHeight / 2 + 10, GREEN);
}
  
void draw_debug_info(void) {
	DrawTextEx(game.font_ui, TextFormat("%i FPS", GetFPS()), (Vector2){ 10, 10 }, 20, 2, GREEN);
	DrawTextEx(game.font_ui, TextFormat("VSync: %s", game.vsync ? "ON" : "OFF"), (Vector2){ 10, 35 }, 20, 2, GREEN);
	DrawTextEx(game.font_ui, TextFormat("Speed: %.0f", game.player.horizontal_speed), (Vector2){ 10, 60 }, 20, 2, GREEN);




	SetWindowPosition((GetMonitorWidth(monitor) - GetScreenWidth()) / 2, (GetMonitorHeight(monitor) - GetScreenHeight()) / 2);
  
	vfs_init(VFS_DATA_PAK);
	init_game();
	game.screen_width = width;
	game.screen_height = height;
	set_map(map_path.data);
  
	if (target_fps >= 0) {
		game.target_fps = target_fps;

	}
  
	if (skip_title) {
		if (load_map(game.map_path)) {
			game.mode = STATE_PLAYING;
			game.cursor_captured = true;
			DisableCursor();

	while (!WindowShouldClose()) {
		// Global Map Switching (Debug/Demo)
		if (IsKeyPressed(KEY_ONE)) {
			if (load_map("maps/demo1.map")) {
				game.mode = STATE_PLAYING;
				game.cursor_captured = true;
				DisableCursor();
			}
		}
		if (IsKeyPressed(KEY_TWO)) {
			if (load_map("maps/demo2.map")) {
				game.mode = STATE_PLAYING;
				game.cursor_captured = true;
				DisableCursor();
			}
		}
		if (IsKeyPressed(KEY_THREE)) {
			if (load_map("maps/demo3.map")) {
				game.mode = STATE_PLAYING;
				game.cursor_captured = true;
				DisableCursor();

		// Game State Switcher
		switch (game.mode) {
			case STATE_MENU:
				update_menu();
				draw_menu();
				break;
			case STATE_PLAYING:
				update_game();
				draw_game();
				break;
		}
	}
  
	unload_map();
	unload_assets();
	vfs_shutdown();
	CloseWindow();
	sb_free(&map_path);




	return (Vector3){ x, z, -y };
}
  
Map parse_map(const char *filename) {
	size_t size;
	char *data = (char *)vfs_read(filename, &size);
	Map map = { 0 };

	return map;
}
  
void free_map(Map map) {
	for (int i = 0; i < map.entity_count; i++) {
		MapEntity *e = &map.entities[i];
		if (e->properties) free(e->properties);

	if (map.entities) free(map.entities);
}
  
Plane plane_from_points(Vector3 p1, Vector3 p2, Vector3 p3) {
	Vector3 v1 = Vector3Subtract(p2, p1);
	Vector3 v2 = Vector3Subtract(p3, p1);
	Vector3 normal = Vector3Normalize(Vector3CrossProduct(v1, v2));
	return (Plane){ normal, Vector3DotProduct(normal, p1) };
}
  
void poly_free(Polygon p) {
	if (p.verts) free(p.verts);
}
  
Polygon poly_clip(Polygon poly, Plane plane) {
	if (poly.count == 0) return poly;
  
	array(Vector3) out_verts;

	return res;
}
  
Polygon create_large_quad(Plane plane) {
	Vector3 n = plane.normal;
	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));

	return poly;
}
  
Vector2 get_uv(Vector3 p, MapPlane *mp, Plane plane) {
	Vector3 n = plane.normal;
	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));

	return (Vector2){ u / 64.0f, v / 64.0f };
}
  
void unload_map(void) {
	if (game.map.models) {
		for (int i = 0; i < game.map.count; i++) {
			UnloadModel(game.map.models[i]);

	}
}
  
bool load_map(const char *filename) {
	TraceLog(LOG_INFO, "Loading map: %s", filename);
  
	Map map = parse_map(filename);
	if (map.entity_count == 0) {
		TraceLog(LOG_ERROR, "Failed to load map or map is empty: %s", filename);
		return false;
	}
  
	unload_map();
  
	array(TextureGroup) groups;
	array_init(groups);

				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 = plane_from_points(mp->p[0], mp->p[1], mp->p[2]);
  
					if (Vector3Length(plane.normal) < 0.5f) continue;
  
					Polygon poly = create_large_quad(plane);
					for (int k = 0; k < brush->plane_count; k++) {
						if (p_idx == k) continue;
						Plane clipPlane = plane_from_points(brush->planes[k].p[0], brush->planes[k].p[1], brush->planes[k].p[2]);
						if (Vector3Length(clipPlane.normal) < 0.5f) continue;
  
						Polygon next = poly_clip(poly, clipPlane);
						poly_free(poly);
						poly = next;
					}
  

							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 = get_uv(v0, mp, plane);
							Vector2 uv1 = get_uv(v1, mp, plane);
							Vector2 uv2 = get_uv(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);

							array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
						}
					}
					poly_free(poly);
				}
			}
		}

		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 = get_texture(g->texture);
		array_push(final_models, model);
		array_free(g->vertices);
		array_free(g->texcoords);

	game.map.count = (int)final_models.length;
	array_free(groups);
  
	free_map(map);
	TraceLog(LOG_INFO, "Processed %d brushes into %d models", total_brushes, game.map.count);
	return true;
}
  
bool check_map_collision(Vector3 start, Vector3 end, RayCollision *outCollision) {
	Vector3 diff = Vector3Subtract(end, start);
	float maxDist = Vector3Length(diff);
	if (maxDist < 0.001f) return false;


diff --git a/maps/demo4.map b/maps/demo4.map
	1	// Game: Stalag
	2	// Format: Standard
	3	// entity 0
	4	{
	5	"classname" "worldspawn"
	6	// brush 0
	7	{
	8	( -128 -80 -16 ) ( -128 -79 -16 ) ( -128 -80 -15 ) __TB_empty -16 0 0 1 1
	9	( -64 -80 -16 ) ( -64 -80 -15 ) ( -63 -80 -16 ) __TB_empty 0 0 0 1 1
	10	( -64 -80 -16 ) ( -63 -80 -16 ) ( -64 -79 -16 ) __TB_empty 0 16 0 1 1
	11	( 64 48 0 ) ( 64 49 0 ) ( 65 48 0 ) __TB_empty 0 16 0 1 1
	12	( 64 656 16 ) ( 65 656 16 ) ( 64 656 17 ) __TB_empty 0 0 0 1 1
	13	( 64 48 16 ) ( 64 48 17 ) ( 64 49 16 ) __TB_empty -16 0 0 1 1
	14	}
	15	// brush 1
	16	{
	17	( -128 -80 0 ) ( -128 -79 0 ) ( -128 -80 1 ) interior/interior_wall_003 0 0 0 1 1
	18	( -128 -80 0 ) ( -128 -80 1 ) ( -127 -80 0 ) interior/interior_wall_003 0 0 0 1 1
	19	( -128 -80 0 ) ( -127 -80 0 ) ( -128 -79 0 ) interior/interior_wall_003 0 0 0 1 1
	20	( -112 48 112 ) ( -112 49 112 ) ( -111 48 112 ) interior/interior_wall_003 0 0 0 1 1
	21	( -112 656 16 ) ( -111 656 16 ) ( -112 656 17 ) interior/interior_wall_003 0 0 0 1 1
	22	( -112 48 16 ) ( -112 48 17 ) ( -112 49 16 ) interior/interior_wall_003 0 0 0 1 1
	23	}
	24	// brush 2
	25	{
	26	( 48 -80 0 ) ( 48 -79 0 ) ( 48 -80 1 ) interior/interior_wall_003 0 0 0 1 1
	27	( 48 -80 0 ) ( 48 -80 1 ) ( 49 -80 0 ) interior/interior_wall_003 0 0 0 1 1
	28	( 48 -80 0 ) ( 49 -80 0 ) ( 48 -79 0 ) interior/interior_wall_003 0 0 0 1 1
	29	( 64 48 112 ) ( 64 49 112 ) ( 65 48 112 ) interior/interior_wall_003 0 0 0 1 1
	30	( 64 656 16 ) ( 65 656 16 ) ( 64 656 17 ) interior/interior_wall_003 0 0 0 1 1
	31	( 64 48 16 ) ( 64 48 17 ) ( 64 49 16 ) interior/interior_wall_003 0 0 0 1 1
	32	}
	33	// brush 3
	34	{
	35	( 48 480 112 ) ( 48 481 112 ) ( 47 480 113 ) interior/interior_wall_001 0 0 90 1 1
	36	( 48 480 112 ) ( 47 480 113 ) ( 49 480 112 ) interior/interior_wall_001 16 6.4000015 0 1 1.25
	37	( 48 480 112 ) ( 49 480 112 ) ( 48 481 112 ) interior/interior_wall_001 0 0 0 1 1
	38	( 32 656 144 ) ( 32 657 144 ) ( 33 656 144 ) interior/interior_wall_001 0 0 0 1 1
	39	( 48 656 128 ) ( 49 656 128 ) ( 47 656 129 ) interior/interior_wall_001 16 6.4000015 0 1 1.25
	40	( 48 656 128 ) ( 47 656 129 ) ( 48 657 128 ) interior/interior_wall_001 0 -16 90 1 1
	41	}
	42	// brush 4
	43	{
	44	( -112 480 128 ) ( -111 480 129 ) ( -112 479 128 ) interior/interior_wall_001 -16 -16 270 1 1
	45	( -112 480 128 ) ( -113 480 128 ) ( -111 480 129 ) interior/interior_wall_001 -16 6.4000015 180 1 -1.25
	46	( -112 656 112 ) ( -113 656 112 ) ( -112 655 112 ) interior/interior_wall_001 0 16 180 1 1
	47	( -96 480 144 ) ( -96 479 144 ) ( -97 480 144 ) interior/interior_wall_001 0 16 180 1 1
	48	( -112 656 112 ) ( -111 656 113 ) ( -113 656 112 ) interior/interior_wall_001 -16 6.4000015 180 1 -1.25
	49	( -112 656 112 ) ( -112 655 112 ) ( -111 656 113 ) interior/interior_wall_001 -16 0 270 1 1
	50	}
	51	// brush 5
	52	{
	53	( -96 480 144 ) ( -96 481 144 ) ( -96 480 145 ) interior/interior_wall_001 0 0 0 1 1
	54	( -96 480 144 ) ( -96 480 145 ) ( -95 480 144 ) interior/interior_wall_001 0 0 0 1 1
	55	( -96 480 144 ) ( -95 480 144 ) ( -96 481 144 ) interior/interior_wall_001 0 0 0 1 1
	56	( 32 656 160 ) ( 32 657 160 ) ( 33 656 160 ) interior/interior_wall_001 0 0 0 1 1
	57	( 32 656 160 ) ( 33 656 160 ) ( 32 656 161 ) interior/interior_wall_001 0 0 0 1 1
	58	( 32 656 160 ) ( 32 656 161 ) ( 32 657 160 ) interior/interior_wall_001 0 0 0 1 1
	59	}
	60	}
	61	// entity 1
	62	{
	63	"classname" "info_player_start"
	64	"origin" "-32 624 16"
	65	}


#include "all.h"
  
void update_menu(void) {
	if (IsKeyPressed(KEY_ENTER)) {
		if (load_map(game.map_path)) {
			game.mode = STATE_PLAYING;
			game.cursor_captured = true;
			DisableCursor();

	}
}
  
void draw_menu(void) {
	BeginDrawing();
	ClearBackground(BLACK);
  




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

		Vector3 start = vStart;
		Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove - eyeHeight, 0});
		RayCollision vCol;
		if (check_map_collision(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;

		float headHeight = PLAYER_HEIGHT - PLAYER_EYE_HEIGHT;
		Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove + headHeight, 0});
		RayCollision vCol;
		if (check_map_collision(start, end, &vCol)) {
			game.player.pos.y = vCol.point.y - headHeight - 1.0f;
			game.player.velocity.y = 0;
		} else {

		Vector3 start = vStart;
		Vector3 end = Vector3Add(vStart, (Vector3){0, -eyeHeight - 2.0f, 0});
		RayCollision vCol;
		if (check_map_collision(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;

	game.player.is_grounded = false;
}
  
void update_player(void) {
	float dt = GetFrameTime();
	Vector3 oldPos = game.player.pos;
  

		Vector3 headPos = game.player.pos;
		Vector3 headEnd = Vector3Add(headPos, (Vector3){0, PLAYER_HEIGHT - PLAYER_EYE_HEIGHT + PLAYER_CROUCH_OFFSET, 0});
		RayCollision col;
		if (check_map_collision(headPos, headEnd, &col)) {
			canStand = false;
		}
	}


diff --git a/textures/interior/interior_wall.xcf b/textures/interior/interior_wall.xcf

diff --git a/textures/interior/interior_wall_001.png b/textures/interior/interior_wall_001.png

diff --git a/textures/interior/interior_wall_002.png b/textures/interior/interior_wall_002.png

diff --git a/textures/interior/interior_wall_003.png b/textures/interior/interior_wall_003.png

diff --git a/textures/palette.xcf b/textures/palette.xcf

diff --git a/all.h b/all.h
...
78	} CachedTexture;	78	} CachedTexture;
79		79
80	// Asset Module	80	// Asset Module
81	Texture2D GetTexture(const char *name);	81	Texture2D get_texture(const char *name);
82	void UnloadAssets(void);	82	void unload_assets(void);
83	Font LoadFontVFS(const char *path, int fontSize);	83	Font load_font_vfs(const char *path, int fontSize);
84		84
85	// Map Module	85	// Map Module
86	typedef struct {	86	typedef struct {
...
88	int count;	88	int count;
89	} MapState;	89	} MapState;
90		90
91	bool LoadMap(const char *filename);	91	bool load_map(const char *filename);
92	void UnloadMap(void);	92	void unload_map(void);
93	bool CheckMapCollision(Vector3 start, Vector3 end, RayCollision *outCollision);	93	bool check_map_collision(Vector3 start, Vector3 end, RayCollision *outCollision);
94	Map ParseMap(const char *filename);	94	Map parse_map(const char *filename);
95	void FreeMap(Map map);	95	void free_map(Map map);
96		96
97	// Menu Module	97	// Menu Module
98	void UpdateMenu(void);	98	void update_menu(void);
99	void DrawMenu(void);	99	void draw_menu(void);
100		100
101	// Player Module	101	// Player Module
102	typedef enum {	102	typedef enum {
...
117	float camera_offset_y; // Vertical offset for stair smoothing	117	float camera_offset_y; // Vertical offset for stair smoothing
118	} PlayerState;	118	} PlayerState;
119		119
120	void UpdatePlayer(void);	120	void update_player(void);
121		121
122	// Game State Module	122	// Game State Module
123	typedef enum {	123	typedef enum {
...
142		142
143	extern GameState game;	143	extern GameState game;
144		144
145	void InitGame(void);	145	void init_game(void);
146	void SetMap(const char *path);	146	void set_map(const char *path);
147	void UpdateGame(void);	147	void update_game(void);
148	void DrawGame(void);	148	void draw_game(void);
149		149
150	// Geometry Helpers	150	// Geometry Helpers
151	Plane PlaneFromPoints(Vector3 p1, Vector3 p2, Vector3 p3);	151	Plane plane_from_points(Vector3 p1, Vector3 p2, Vector3 p3);
152	void PolyFree(Polygon p);	152	void poly_free(Polygon p);
153	Polygon PolyClip(Polygon poly, Plane plane);	153	Polygon poly_clip(Polygon poly, Plane plane);
154	Polygon CreateLargeQuad(Plane plane);	154	Polygon create_large_quad(Plane plane);
155	Vector2 GetUV(Vector3 p, MapPlane *mp, Plane plane);	155	Vector2 get_uv(Vector3 p, MapPlane *mp, Plane plane);
156		156
157	// Interface	157	// Interface
158	void DrawCrosshair(void);	158	void draw_crosshair(void);
159	void DrawDebugInfo(void);	159	void draw_debug_info(void);
160		160
161	#endif	161	#endif

diff --git a/map.c b/map.c
...
74	return (Vector3){ x, z, -y };	74	return (Vector3){ x, z, -y };
75	}	75	}
76		76
77	Map ParseMap(const char *filename) {	77	Map parse_map(const char *filename) {
78	size_t size;	78	size_t size;
79	char data = (char )vfs_read(filename, &size);	79	char data = (char )vfs_read(filename, &size);
80	Map map = { 0 };	80	Map map = { 0 };
...
153	return map;	153	return map;
154	}	154	}
155		155
156	void FreeMap(Map map) {	156	void free_map(Map map) {
157	for (int i = 0; i < map.entity_count; i++) {	157	for (int i = 0; i < map.entity_count; i++) {
158	MapEntity *e = &map.entities[i];	158	MapEntity *e = &map.entities[i];
159	if (e->properties) free(e->properties);	159	if (e->properties) free(e->properties);
...
165	if (map.entities) free(map.entities);	165	if (map.entities) free(map.entities);
166	}	166	}
167		167
168	Plane PlaneFromPoints(Vector3 p1, Vector3 p2, Vector3 p3) {	168	Plane plane_from_points(Vector3 p1, Vector3 p2, Vector3 p3) {
169	Vector3 v1 = Vector3Subtract(p2, p1);	169	Vector3 v1 = Vector3Subtract(p2, p1);
170	Vector3 v2 = Vector3Subtract(p3, p1);	170	Vector3 v2 = Vector3Subtract(p3, p1);
171	Vector3 normal = Vector3Normalize(Vector3CrossProduct(v1, v2));	171	Vector3 normal = Vector3Normalize(Vector3CrossProduct(v1, v2));
172	return (Plane){ normal, Vector3DotProduct(normal, p1) };	172	return (Plane){ normal, Vector3DotProduct(normal, p1) };
173	}	173	}
174		174
175	void PolyFree(Polygon p) {	175	void poly_free(Polygon p) {
176	if (p.verts) free(p.verts);	176	if (p.verts) free(p.verts);
177	}	177	}
178		178
179	Polygon PolyClip(Polygon poly, Plane plane) {	179	Polygon poly_clip(Polygon poly, Plane plane) {
180	if (poly.count == 0) return poly;	180	if (poly.count == 0) return poly;
181		181
182	array(Vector3) out_verts;	182	array(Vector3) out_verts;
...
215	return res;	215	return res;
216	}	216	}
217		217
218	Polygon CreateLargeQuad(Plane plane) {	218	Polygon create_large_quad(Plane plane) {
219	Vector3 n = plane.normal;	219	Vector3 n = plane.normal;
220	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };	220	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
221	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));	221	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));
...
235	return poly;	235	return poly;
236	}	236	}
237		237
238	Vector2 GetUV(Vector3 p, MapPlane *mp, Plane plane) {	238	Vector2 get_uv(Vector3 p, MapPlane *mp, Plane plane) {
239	Vector3 n = plane.normal;	239	Vector3 n = plane.normal;
240	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };	240	Vector3 up = (fabsf(n.y) < 0.999f) ? (Vector3){ 0, 1, 0 } : (Vector3){ 1, 0, 0 };
241	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));	241	Vector3 right = Vector3Normalize(Vector3CrossProduct(up, n));
...
247	return (Vector2){ u / 64.0f, v / 64.0f };	247	return (Vector2){ u / 64.0f, v / 64.0f };
248	}	248	}
249		249
250	void UnloadMap(void) {	250	void unload_map(void) {
251	if (game.map.models) {	251	if (game.map.models) {
252	for (int i = 0; i < game.map.count; i++) {	252	for (int i = 0; i < game.map.count; i++) {
253	UnloadModel(game.map.models[i]);	253	UnloadModel(game.map.models[i]);
...
258	}	258	}
259	}	259	}
260		260
261	bool LoadMap(const char *filename) {	261	bool load_map(const char *filename) {
262	TraceLog(LOG_INFO, "Loading map: %s", filename);	262	TraceLog(LOG_INFO, "Loading map: %s", filename);
263		263
264	Map map = ParseMap(filename);	264	Map map = parse_map(filename);
265	if (map.entity_count == 0) {	265	if (map.entity_count == 0) {
266	TraceLog(LOG_ERROR, "Failed to load map or map is empty: %s", filename);	266	TraceLog(LOG_ERROR, "Failed to load map or map is empty: %s", filename);
267	return false;	267	return false;
268	}	268	}
269		269
270	UnloadMap();	270	unload_map();
271		271
272	array(TextureGroup) groups;	272	array(TextureGroup) groups;
273	array_init(groups);	273	array_init(groups);
...
316	MapBrush *brush = &e->brushes[j];	316	MapBrush *brush = &e->brushes[j];
317	for (int p_idx = 0; p_idx < brush->plane_count; p_idx++) {	317	for (int p_idx = 0; p_idx < brush->plane_count; p_idx++) {
318	MapPlane *mp = &brush->planes[p_idx];	318	MapPlane *mp = &brush->planes[p_idx];
319	Plane plane = PlaneFromPoints(mp->p[0], mp->p[1], mp->p[2]);	319	Plane plane = plane_from_points(mp->p[0], mp->p[1], mp->p[2]);
320		320
321	if (Vector3Length(plane.normal) < 0.5f) continue;	321	if (Vector3Length(plane.normal) < 0.5f) continue;
322		322
323	Polygon poly = CreateLargeQuad(plane);	323	Polygon poly = create_large_quad(plane);
324	for (int k = 0; k < brush->plane_count; k++) {	324	for (int k = 0; k < brush->plane_count; k++) {
325	if (p_idx == k) continue;	325	if (p_idx == k) continue;
326	Plane clipPlane = PlaneFromPoints(brush->planes[k].p[0], brush->planes[k].p[1], brush->planes[k].p[2]);	326	Plane clipPlane = plane_from_points(brush->planes[k].p[0], brush->planes[k].p[1], brush->planes[k].p[2]);
327	if (Vector3Length(clipPlane.normal) < 0.5f) continue;	327	if (Vector3Length(clipPlane.normal) < 0.5f) continue;
328		328
329	Polygon next = PolyClip(poly, clipPlane);	329	Polygon next = poly_clip(poly, clipPlane);
330	PolyFree(poly);	330	poly_free(poly);
331	poly = next;	331	poly = next;
332	}	332	}
333		333
...
355	array_push(group->vertices, v0.x); array_push(group->vertices, v0.y); array_push(group->vertices, v0.z);	355	array_push(group->vertices, v0.x); array_push(group->vertices, v0.y); array_push(group->vertices, v0.z);
356	array_push(group->vertices, v1.x); array_push(group->vertices, v1.y); array_push(group->vertices, v1.z);	356	array_push(group->vertices, v1.x); array_push(group->vertices, v1.y); array_push(group->vertices, v1.z);
357	array_push(group->vertices, v2.x); array_push(group->vertices, v2.y); array_push(group->vertices, v2.z);	357	array_push(group->vertices, v2.x); array_push(group->vertices, v2.y); array_push(group->vertices, v2.z);
358	Vector2 uv0 = GetUV(v0, mp, plane);	358	Vector2 uv0 = get_uv(v0, mp, plane);
359	Vector2 uv1 = GetUV(v1, mp, plane);	359	Vector2 uv1 = get_uv(v1, mp, plane);
360	Vector2 uv2 = GetUV(v2, mp, plane);	360	Vector2 uv2 = get_uv(v2, mp, plane);
361	array_push(group->texcoords, uv0.x); array_push(group->texcoords, uv0.y);	361	array_push(group->texcoords, uv0.x); array_push(group->texcoords, uv0.y);
362	array_push(group->texcoords, uv1.x); array_push(group->texcoords, uv1.y);	362	array_push(group->texcoords, uv1.x); array_push(group->texcoords, uv1.y);
363	array_push(group->texcoords, uv2.x); array_push(group->texcoords, uv2.y);	363	array_push(group->texcoords, uv2.x); array_push(group->texcoords, uv2.y);
...
367	array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);	367	array_push(group->normals, out_normal.x); array_push(group->normals, out_normal.y); array_push(group->normals, out_normal.z);
368	}	368	}
369	}	369	}
370	PolyFree(poly);	370	poly_free(poly);
371	}	371	}
372	}	372	}
373	}	373	}
...
390	memcpy(mesh.normals, g->normals.data, g->normals.length * sizeof(float));	390	memcpy(mesh.normals, g->normals.data, g->normals.length * sizeof(float));
391	UploadMesh(&mesh, false);	391	UploadMesh(&mesh, false);
392	Model model = LoadModelFromMesh(mesh);	392	Model model = LoadModelFromMesh(mesh);
393	model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = GetTexture(g->texture);	393	model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = get_texture(g->texture);
394	array_push(final_models, model);	394	array_push(final_models, model);
395	array_free(g->vertices);	395	array_free(g->vertices);
396	array_free(g->texcoords);	396	array_free(g->texcoords);
...
401	game.map.count = (int)final_models.length;	401	game.map.count = (int)final_models.length;
402	array_free(groups);	402	array_free(groups);
403		403
404	FreeMap(map);	404	free_map(map);
405	TraceLog(LOG_INFO, "Processed %d brushes into %d models", total_brushes, game.map.count);	405	TraceLog(LOG_INFO, "Processed %d brushes into %d models", total_brushes, game.map.count);
406	return true;	406	return true;
407	}	407	}
408		408
409	bool CheckMapCollision(Vector3 start, Vector3 end, RayCollision *outCollision) {	409	bool check_map_collision(Vector3 start, Vector3 end, RayCollision *outCollision) {
410	Vector3 diff = Vector3Subtract(end, start);	410	Vector3 diff = Vector3Subtract(end, start);
411	float maxDist = Vector3Length(diff);	411	float maxDist = Vector3Length(diff);
412	if (maxDist < 0.001f) return false;	412	if (maxDist < 0.001f) return false;
...

diff --git a/assets.c b/assets.c
...
6		6
7	static array(CachedTexture) texture_cache;	7	static array(CachedTexture) texture_cache;
8		8
9	Texture2D GetTexture(const char *name) {	9	Texture2D get_texture(const char *name) {
10	if (texture_cache.data == NULL) {	10	if (texture_cache.data == NULL) {
11	array_init(texture_cache);	11	array_init(texture_cache);
12	}	12	}
...
62	return tex;	62	return tex;
63	}	63	}
64		64
65	void UnloadAssets(void) {	65	void unload_assets(void) {
66	for (int i = 0; i < texture_cache.length; i++) {	66	for (int i = 0; i < texture_cache.length; i++) {
67	UnloadTexture(texture_cache.data[i].tex);	67	UnloadTexture(texture_cache.data[i].tex);
68	}	68	}
69	array_clear(texture_cache);	69	array_clear(texture_cache);
70	}	70	}
71		71
72	Font LoadFontVFS(const char *path, int fontSize) {	72	Font load_font_vfs(const char *path, int fontSize) {
73	size_t size = 0;	73	size_t size = 0;
74	void *data = vfs_read(path, &size);	74	void *data = vfs_read(path, &size);
75	if (data) {	75	if (data) {
...

diff --git a/game.c b/game.c
...
4		4
5	GameState game;	5	GameState game;
6		6
7	void InitGame(void) {	7	void init_game(void) {
8	memset(&game, 0, sizeof(game));	8	memset(&game, 0, sizeof(game));
9		9
10	game.font_ui = LoadFontVFS(UI_FONT_PATH, UI_FONT_SIZE);	10	game.font_ui = load_font_vfs(UI_FONT_PATH, UI_FONT_SIZE);
11	game.mode = STATE_MENU;	11	game.mode = STATE_MENU;
12	game.cursor_captured = false;	12	game.cursor_captured = false;
13	EnableCursor();	13	EnableCursor();
...
23	game.camera.projection = CAMERA_PERSPECTIVE;	23	game.camera.projection = CAMERA_PERSPECTIVE;
24	}	24	}
25		25
26	void SetMap(const char *path) {	26	void set_map(const char *path) {
27	strncpy(game.map_path, path, sizeof(game.map_path) - 1);	27	strncpy(game.map_path, path, sizeof(game.map_path) - 1);
28	game.map_path[sizeof(game.map_path) - 1] = '\0';	28	game.map_path[sizeof(game.map_path) - 1] = '\0';
29	}	29	}
30		30
31	void UpdateGame(void) {	31	void update_game(void) {
32	if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {	32	if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {
33	game.cursor_captured = !game.cursor_captured;	33	game.cursor_captured = !game.cursor_captured;
34	if (game.cursor_captured) DisableCursor();	34	if (game.cursor_captured) DisableCursor();
...
46	}	46	}
47	}	47	}
48		48
49	UpdatePlayer();	49	update_player();
50	}	50	}
51		51
52	void DrawGame(void) {	52	void draw_game(void) {
53	BeginDrawing();	53	BeginDrawing();
54	ClearBackground(DARKGRAY);	54	ClearBackground(DARKGRAY);
55		55
...
62		62
63	EndMode3D();	63	EndMode3D();
64		64
65	DrawCrosshair();	65	draw_crosshair();
66	DrawDebugInfo();	66	draw_debug_info();
67		67
68	EndDrawing();	68	EndDrawing();
69	}	69	}

diff --git a/interface.c b/interface.c
1	#include "all.h"	1	#include "all.h"
2		2
3	void DrawCrosshair(void) {	3	void draw_crosshair(void) {
4	int screenWidth = GetScreenWidth();	4	int screenWidth = GetScreenWidth();
5	int screenHeight = GetScreenHeight();	5	int screenHeight = GetScreenHeight();
6	DrawLine(screenWidth / 2 - 10, screenHeight / 2, screenWidth / 2 + 10, screenHeight / 2, GREEN);	6	DrawLine(screenWidth / 2 - 10, screenHeight / 2, screenWidth / 2 + 10, screenHeight / 2, GREEN);
7	DrawLine(screenWidth / 2, screenHeight / 2 - 10, screenWidth / 2, screenHeight / 2 + 10, GREEN);	7	DrawLine(screenWidth / 2, screenHeight / 2 - 10, screenWidth / 2, screenHeight / 2 + 10, GREEN);
8	}	8	}
9		9
10	void DrawDebugInfo(void) {	10	void draw_debug_info(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.player.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);
...

diff --git a/main.c b/main.c
...
54	SetWindowPosition((GetMonitorWidth(monitor) - GetScreenWidth()) / 2, (GetMonitorHeight(monitor) - GetScreenHeight()) / 2);	54	SetWindowPosition((GetMonitorWidth(monitor) - GetScreenWidth()) / 2, (GetMonitorHeight(monitor) - GetScreenHeight()) / 2);
55		55
56	vfs_init(VFS_DATA_PAK);	56	vfs_init(VFS_DATA_PAK);
57	InitGame();	57	init_game();
58	game.screen_width = width;	58	game.screen_width = width;
59	game.screen_height = height;	59	game.screen_height = height;
60	SetMap(map_path.data);	60	set_map(map_path.data);
61		61
62	if (target_fps >= 0) {	62	if (target_fps >= 0) {
63	game.target_fps = target_fps;	63	game.target_fps = target_fps;
...
69	}	69	}
70		70
71	if (skip_title) {	71	if (skip_title) {
72	if (LoadMap(game.map_path)) {	72	if (load_map(game.map_path)) {
73	game.mode = STATE_PLAYING;	73	game.mode = STATE_PLAYING;
74	game.cursor_captured = true;	74	game.cursor_captured = true;
75	DisableCursor();	75	DisableCursor();
...
81	while (!WindowShouldClose()) {	81	while (!WindowShouldClose()) {
82	// Global Map Switching (Debug/Demo)	82	// Global Map Switching (Debug/Demo)
83	if (IsKeyPressed(KEY_ONE)) {	83	if (IsKeyPressed(KEY_ONE)) {
84	if (LoadMap("maps/demo1.map")) {	84	if (load_map("maps/demo1.map")) {
85	game.mode = STATE_PLAYING;	85	game.mode = STATE_PLAYING;
86	game.cursor_captured = true;	86	game.cursor_captured = true;
87	DisableCursor();	87	DisableCursor();
88	}	88	}
89	}	89	}
90	if (IsKeyPressed(KEY_TWO)) {	90	if (IsKeyPressed(KEY_TWO)) {
91	if (LoadMap("maps/demo2.map")) {	91	if (load_map("maps/demo2.map")) {
92	game.mode = STATE_PLAYING;	92	game.mode = STATE_PLAYING;
93	game.cursor_captured = true;	93	game.cursor_captured = true;
94	DisableCursor();	94	DisableCursor();
95	}	95	}
96	}	96	}
97	if (IsKeyPressed(KEY_THREE)) {	97	if (IsKeyPressed(KEY_THREE)) {
98	if (LoadMap("maps/demo3.map")) {	98	if (load_map("maps/demo3.map")) {
99	game.mode = STATE_PLAYING;	99	game.mode = STATE_PLAYING;
100	game.cursor_captured = true;	100	game.cursor_captured = true;
101	DisableCursor();	101	DisableCursor();
...
105	// Game State Switcher	105	// Game State Switcher
106	switch (game.mode) {	106	switch (game.mode) {
107	case STATE_MENU:	107	case STATE_MENU:
108	UpdateMenu();	108	update_menu();
109	DrawMenu();	109	draw_menu();
110	break;	110	break;
111	case STATE_PLAYING:	111	case STATE_PLAYING:
112	UpdateGame();	112	update_game();
113	DrawGame();	113	draw_game();
114	break;	114	break;
115	}	115	}
116	}	116	}
117		117
118	UnloadMap();	118	unload_map();
119	UnloadAssets();	119	unload_assets();
120	vfs_shutdown();	120	vfs_shutdown();
121	CloseWindow();	121	CloseWindow();
122	sb_free(&map_path);	122	sb_free(&map_path);
...

diff --git a/menu.c b/menu.c
1	#include "all.h"	1	#include "all.h"
2		2
3	void UpdateMenu(void) {	3	void update_menu(void) {
4	if (IsKeyPressed(KEY_ENTER)) {	4	if (IsKeyPressed(KEY_ENTER)) {
5	if (LoadMap(game.map_path)) {	5	if (load_map(game.map_path)) {
6	game.mode = STATE_PLAYING;	6	game.mode = STATE_PLAYING;
7	game.cursor_captured = true;	7	game.cursor_captured = true;
8	DisableCursor();	8	DisableCursor();
...
10	}	10	}
11	}	11	}
12		12
13	void DrawMenu(void) {	13	void draw_menu(void) {
14	BeginDrawing();	14	BeginDrawing();
15	ClearBackground(BLACK);	15	ClearBackground(BLACK);
16		16
...

diff --git a/player.c b/player.c
...
59	Vector3 end = Vector3Add(start, Vector3Scale(dir, dist));	59	Vector3 end = Vector3Add(start, Vector3Scale(dir, dist));
60		60
61	RayCollision col;	61	RayCollision col;
62	if (CheckMapCollision(start, end, &col)) {	62	if (check_map_collision(start, end, &col)) {
63	float adjustedDist = col.distance - PLAYER_RADIUS;	63	float adjustedDist = col.distance - PLAYER_RADIUS;
64	if (adjustedDist < closestHit.distance) {	64	if (adjustedDist < closestHit.distance) {
65	closestHit = col;	65	closestHit = col;
...
99	Vector3 start = vStart;	99	Vector3 start = vStart;
100	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove - eyeHeight, 0});	100	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove - eyeHeight, 0});
101	RayCollision vCol;	101	RayCollision vCol;
102	if (CheckMapCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {	102	if (check_map_collision(start, end, &vCol) && vCol.normal.y > 0.5f) {
103	game.player.pos.y = vCol.point.y + eyeHeight;	103	game.player.pos.y = vCol.point.y + eyeHeight;
104	game.player.velocity.y = 0;	104	game.player.velocity.y = 0;
105	game.player.is_grounded = true;	105	game.player.is_grounded = true;
...
112	float headHeight = PLAYER_HEIGHT - PLAYER_EYE_HEIGHT;	112	float headHeight = PLAYER_HEIGHT - PLAYER_EYE_HEIGHT;
113	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove + headHeight, 0});	113	Vector3 end = Vector3Add(vStart, (Vector3){0, verticalMove + headHeight, 0});
114	RayCollision vCol;	114	RayCollision vCol;
115	if (CheckMapCollision(start, end, &vCol)) {	115	if (check_map_collision(start, end, &vCol)) {
116	game.player.pos.y = vCol.point.y - headHeight - 1.0f;	116	game.player.pos.y = vCol.point.y - headHeight - 1.0f;
117	game.player.velocity.y = 0;	117	game.player.velocity.y = 0;
118	} else {	118	} else {
...
123	Vector3 start = vStart;	123	Vector3 start = vStart;
124	Vector3 end = Vector3Add(vStart, (Vector3){0, -eyeHeight - 2.0f, 0});	124	Vector3 end = Vector3Add(vStart, (Vector3){0, -eyeHeight - 2.0f, 0});
125	RayCollision vCol;	125	RayCollision vCol;
126	if (CheckMapCollision(start, end, &vCol) && vCol.normal.y > 0.5f) {	126	if (check_map_collision(start, end, &vCol) && vCol.normal.y > 0.5f) {
127	game.player.is_grounded = true;	127	game.player.is_grounded = true;
128	if (vCol.distance < eyeHeight + 1.0f) {	128	if (vCol.distance < eyeHeight + 1.0f) {
129	game.player.pos.y = vCol.point.y + eyeHeight;	129	game.player.pos.y = vCol.point.y + eyeHeight;
...
170	game.player.is_grounded = false;	170	game.player.is_grounded = false;
171	}	171	}
172		172
173	void UpdatePlayer(void) {	173	void update_player(void) {
174	float dt = GetFrameTime();	174	float dt = GetFrameTime();
175	Vector3 oldPos = game.player.pos;	175	Vector3 oldPos = game.player.pos;
176		176
...
189	Vector3 headPos = game.player.pos;	189	Vector3 headPos = game.player.pos;
190	Vector3 headEnd = Vector3Add(headPos, (Vector3){0, PLAYER_HEIGHT - PLAYER_EYE_HEIGHT + PLAYER_CROUCH_OFFSET, 0});	190	Vector3 headEnd = Vector3Add(headPos, (Vector3){0, PLAYER_HEIGHT - PLAYER_EYE_HEIGHT + PLAYER_CROUCH_OFFSET, 0});
191	RayCollision col;	191	RayCollision col;
192	if (CheckMapCollision(headPos, headEnd, &col)) {	192	if (check_map_collision(headPos, headEnd, &col)) {
193	canStand = false;	193	canStand = false;
194	}	194	}
195	}	195	}
...