main.c

#include "raylib.h"
#include "raymath.h"

#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(_WIN32)
    #include <direct.h>
    #define MKDIR(path) _mkdir(path)
#else
    #include <sys/stat.h>
    #define MKDIR(path) mkdir(path, 0777)
#endif

#define SCREEN_W 1280
#define SCREEN_H 720

#define CHUNK_SIZE 16
#define WORLD_HEIGHT 64
#define MAX_CHUNKS 1024
#define RENDER_DISTANCE 6
#define MAX_MONSTERS 64
#define SAVE_DIR "worldsave"

#define PLAYER_WIDTH 0.60f
#define PLAYER_HEIGHT 1.80f
#define PLAYER_EYE 1.62f
#define GRAVITY 24.0f
#define JUMP_VEL 8.5f
#define MOVE_SPEED 6.0f
#define RUN_SPEED 9.5f

#define NETWORK_ENABLED 0  /* Keep one-file demo self-contained. */

typedef enum BlockType {
    BLOCK_AIR = 0,
    BLOCK_GRASS,
    BLOCK_DIRT,
    BLOCK_STONE,
    BLOCK_WOOD,
    BLOCK_LEAF,
    BLOCK_WATER,
    BLOCK_TORCH,
    BLOCK_COBBLE,
    BLOCK_SAND,
    BLOCK_COUNT
} BlockType;

static Color BlockColor(BlockType b)
{
    switch (b)
    {
        case BLOCK_GRASS: return (Color){ 95, 159, 53, 255 };
        case BLOCK_DIRT: return (Color){ 134, 96, 67, 255 };
        case BLOCK_STONE: return (Color){ 125, 125, 125, 255 };
        case BLOCK_WOOD: return (Color){ 102, 73, 43, 255 };
        case BLOCK_LEAF: return (Color){ 54, 140, 54, 255 };
        case BLOCK_WATER: return (Color){ 50, 90, 180, 170 };
        case BLOCK_TORCH: return (Color){ 255, 220, 120, 255 };
        case BLOCK_COBBLE: return (Color){ 105, 105, 105, 255 };
        case BLOCK_SAND: return (Color){ 214, 198, 132, 255 };
        default: return BLANK;
    }
}

static int IsSolid(BlockType b)
{
    return (b != BLOCK_AIR && b != BLOCK_WATER && b != BLOCK_TORCH);
}

static float ClampF(float v, float a, float b)
{
    return (v < a) ? a : (v > b ? b : v);
}

static int ClampI(int v, int a, int b)
{
    return (v < a) ? a : (v > b ? b : v);
}

static float Fract(float x) { return x - floorf(x); }

static float Hash2i(int x, int z)
{
    uint32_t n = (uint32_t)(x * 374761393u + z * 668265263u);
    n = (n ^ (n >> 13u)) * 1274126177u;
    n ^= (n >> 16u);
    return (float)(n & 0x7fffffff) / 2147483647.0f;
}

static float Hash3i(int x, int y, int z)
{
    uint32_t n = (uint32_t)(x * 374761393u ^ y * 668265263u ^ z * 2147483647u);
    n = (n ^ (n >> 13u)) * 1274126177u;
    n ^= (n >> 16u);
    return (float)(n & 0x7fffffff) / 2147483647.0f;
}

static float Smooth(float t) { return t * t * (3.0f - 2.0f * t); }

static float Noise2D(float x, float z)
{
    int xi = (int)floorf(x);
    int zi = (int)floorf(z);
    float xf = Fract(x);
    float zf = Fract(z);

    float v00 = Hash2i(xi, zi);
    float v10 = Hash2i(xi + 1, zi);
    float v01 = Hash2i(xi, zi + 1);
    float v11 = Hash2i(xi + 1, zi + 1);

    float u = Smooth(xf);
    float v = Smooth(zf);

    float a = Lerp(v00, v10, u);
    float b = Lerp(v01, v11, u);
    return Lerp(a, b, v) * 2.0f - 1.0f;
}

static float FBM2D(float x, float z)
{
    float sum = 0.0f;
    float amp = 1.0f;
    float freq = 0.03f;
    for (int i = 0; i < 5; i++)
    {
        sum += Noise2D(x * freq, z * freq) * amp;
        freq *= 2.0f;
        amp *= 0.5f;
    }
    return sum;
}

typedef struct Chunk {
    int cx, cz;
    int generated;
    unsigned char blocks[CHUNK_SIZE][WORLD_HEIGHT][CHUNK_SIZE];
    unsigned char light[CHUNK_SIZE][WORLD_HEIGHT][CHUNK_SIZE];
} Chunk;

typedef struct Inventory {
    BlockType hotbar[9];
    int counts[BLOCK_COUNT];
    int selected;
} Inventory;

typedef struct Monster {
    Vector3 pos;
    Vector3 vel;
    int alive;
    int hp;
    float thinkT;
    float wanderYaw;
    float attackCd;
} Monster;

typedef struct World {
    Chunk *chunks[MAX_CHUNKS];
    Monster monsters[MAX_MONSTERS];
    int monsterCount;
} World;

static void EnsureSaveDir(void)
{
    MKDIR(SAVE_DIR);
}

static int ChunkHash(int cx, int cz)
{
    uint32_t n = (uint32_t)(cx * 73856093u ^ cz * 19349663u);
    return (int)(n % MAX_CHUNKS);
}

static Chunk *WorldGetChunk(World *w, int cx, int cz, int create)
{
    int h = ChunkHash(cx, cz);
    for (int i = 0; i < MAX_CHUNKS; i++)
    {
        int idx = (h + i) % MAX_CHUNKS;
        Chunk *c = w->chunks[idx];
        if (c && c->cx == cx && c->cz == cz) return c;
        if (!c && create)
        {
            c = (Chunk *)calloc(1, sizeof(Chunk));
            c->cx = cx;
            c->cz = cz;
            w->chunks[idx] = c;
            return c;
        }
        if (!c && !create) return NULL;
    }
    return NULL;
}

static BlockType WorldGetBlock(World *w, int x, int y, int z)
{
    if (y < 0 || y >= WORLD_HEIGHT) return BLOCK_AIR;
    int cx = (x >= 0) ? x / CHUNK_SIZE : ((x + 1) / CHUNK_SIZE) - 1;
    int cz = (z >= 0) ? z / CHUNK_SIZE : ((z + 1) / CHUNK_SIZE) - 1;
    int lx = ((x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
    int lz = ((z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
    Chunk *c = WorldGetChunk(w, cx, cz, 0);
    if (!c) return BLOCK_AIR;
    return (BlockType)c->blocks[lx][y][lz];
}

static void WorldSetBlock(World *w, int x, int y, int z, BlockType t)
{
    if (y < 0 || y >= WORLD_HEIGHT) return;
    int cx = (x >= 0) ? x / CHUNK_SIZE : ((x + 1) / CHUNK_SIZE) - 1;
    int cz = (z >= 0) ? z / CHUNK_SIZE : ((z + 1) / CHUNK_SIZE) - 1;
    int lx = ((x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
    int lz = ((z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
    Chunk *c = WorldGetChunk(w, cx, cz, 1);
    c->blocks[lx][y][lz] = (unsigned char)t;
    c->generated = 1;
}

static float TerrainHeight(int wx, int wz)
{
    float h = 22.0f + FBM2D((float)wx, (float)wz) * 10.0f;
    h += Noise2D((float)wx * 0.2f, (float)wz * 0.2f) * 3.0f;
    return ClampF(h, 6.0f, (float)(WORLD_HEIGHT - 4));
}

static void CarveCaves(Chunk *c)
{
    for (int x = 0; x < CHUNK_SIZE; x++)
    for (int z = 0; z < CHUNK_SIZE; z++)
    for (int y = 6; y < WORLD_HEIGHT - 6; y++)
    {
        int wx = c->cx * CHUNK_SIZE + x;
        int wz = c->cz * CHUNK_SIZE + z;
        float n = Hash3i(wx, y, wz);
        float cave = Hash3i(wx * 2, y * 3, wz * 2);
        if (y < 14) continue;
        if (n > 0.83f && cave > 0.72f) c->blocks[x][y][z] = BLOCK_AIR;
    }
}

static void PlaceTree(Chunk *c, int x, int y, int z)
{
    if (y < 4 || y > WORLD_HEIGHT - 8) return;
    int trunk = 4 + (int)(Hash2i(c->cx * 31 + x, c->cz * 31 + z) * 2.0f);
    for (int i = 0; i < trunk; i++)
    {
        if (y + i < WORLD_HEIGHT) c->blocks[x][y + i][z] = BLOCK_WOOD;
    }
    int top = y + trunk;
    for (int dx = -2; dx <= 2; dx++)
    for (int dz = -2; dz <= 2; dz++)
    for (int dy = -2; dy <= 2; dy++)
    {
        int ax = x + dx, ay = top + dy, az = z + dz;
        if (ax < 0 || ax >= CHUNK_SIZE || az < 0 || az >= CHUNK_SIZE) continue;
        if (ay < 0 || ay >= WORLD_HEIGHT) continue;
        float d = (float)(dx * dx + dy * dy + dz * dz);
        if (d <= 6.8f && c->blocks[ax][ay][az] == BLOCK_AIR) c->blocks[ax][ay][az] = BLOCK_LEAF;
    }
}

static void GenerateChunk(World *w, Chunk *c)
{
    if (c->generated) return;

    for (int x = 0; x < CHUNK_SIZE; x++)
    for (int z = 0; z < CHUNK_SIZE; z++)
    {
        int wx = c->cx * CHUNK_SIZE + x;
        int wz = c->cz * CHUNK_SIZE + z;
        int h = (int)TerrainHeight(wx, wz);

        for (int y = 0; y < WORLD_HEIGHT; y++)
        {
            BlockType t = BLOCK_AIR;
            if (y == 0) t = BLOCK_STONE;
            else if (y < h - 4) t = BLOCK_STONE;
            else if (y < h - 1) t = BLOCK_DIRT;
            else if (y == h - 1)
            {
                if (h < 12) t = BLOCK_SAND;
                else t = BLOCK_GRASS;
            }
            else if (y < 10 && h < 10) t = BLOCK_WATER;
            c->blocks[x][y][z] = (unsigned char)t;
            c->light[x][y][z] = 0;
        }

        if (h < 10)
        {
            for (int y = h; y < 10; y++) c->blocks[x][y][z] = BLOCK_WATER;
        }

        if ((Hash2i(wx, wz) > 0.985f) && h >= 8 && h < WORLD_HEIGHT - 8)
        {
            PlaceTree(c, x, h, z);
        }
    }

    CarveCaves(c);
    c->generated = 1;
}

static void RecalcChunkLight(Chunk *c)
{
    for (int x = 0; x < CHUNK_SIZE; x++)
    for (int z = 0; z < CHUNK_SIZE; z++)
    {
        int sky = 15;
        for (int y = WORLD_HEIGHT - 1; y >= 0; y--)
        {
            BlockType b = (BlockType)c->blocks[x][y][z];
            if (b == BLOCK_AIR || b == BLOCK_WATER || b == BLOCK_TORCH)
            {
                c->light[x][y][z] = (unsigned char)sky;
            }
            else
            {
                sky = (sky > 1) ? sky - 2 : 0;
                c->light[x][y][z] = (unsigned char)sky;
            }
        }
    }
}

static void EnsureWorldAround(World *w, Vector3 pos)
{
    int pcx = (int)floorf(pos.x / (float)CHUNK_SIZE);
    int pcz = (int)floorf(pos.z / (float)CHUNK_SIZE);

    for (int dz = -RENDER_DISTANCE; dz <= RENDER_DISTANCE; dz++)
    for (int dx = -RENDER_DISTANCE; dx <= RENDER_DISTANCE; dx++)
    {
        Chunk *c = WorldGetChunk(w, pcx + dx, pcz + dz, 1);
        if (!c->generated)
        {
            GenerateChunk(w, c);
            RecalcChunkLight(c);
        }
    }
}

static void SaveChunk(const Chunk *c)
{
    char path[256];
    snprintf(path, sizeof(path), "%s/%d_%d.bin", SAVE_DIR, c->cx, c->cz);
    FILE *f = fopen(path, "wb");
    if (!f) return;
    fwrite(&c->cx, sizeof(int), 1, f);
    fwrite(&c->cz, sizeof(int), 1, f);
    fwrite(c->blocks, 1, sizeof(c->blocks), f);
    fclose(f);
}

static int LoadChunkTo(World *w, int cx, int cz)
{
    char path[256];
    snprintf(path, sizeof(path), "%s/%d_%d.bin", SAVE_DIR, cx, cz);
    FILE *f = fopen(path, "rb");
    if (!f) return 0;
    Chunk *c = WorldGetChunk(w, cx, cz, 1);
    fread(&c->cx, sizeof(int), 1, f);
    fread(&c->cz, sizeof(int), 1, f);
    fread(c->blocks, 1, sizeof(c->blocks), f);
    fclose(f);
    c->generated = 1;
    RecalcChunkLight(c);
    return 1;
}

static void SaveWorld(World *w)
{
    EnsureSaveDir();
    for (int i = 0; i < MAX_CHUNKS; i++)
    {
        if (w->chunks[i]) SaveChunk(w->chunks[i]);
    }
}

static void LoadVisibleWorld(World *w, Vector3 pos)
{
    EnsureSaveDir();
    int pcx = (int)floorf(pos.x / (float)CHUNK_SIZE);
    int pcz = (int)floorf(pos.z / (float)CHUNK_SIZE);
    for (int dz = -RENDER_DISTANCE; dz <= RENDER_DISTANCE; dz++)
    for (int dx = -RENDER_DISTANCE; dx <= RENDER_DISTANCE; dx++)
    {
        int cx = pcx + dx;
        int cz = pcz + dz;
        if (!LoadChunkTo(w, cx, cz))
        {
            Chunk *c = WorldGetChunk(w, cx, cz, 1);
            if (!c->generated)
            {
                GenerateChunk(w, c);
                RecalcChunkLight(c);
            }
        }
    }
}

static void UnloadFarChunks(World *w, Vector3 pos)
{
    int pcx = (int)floorf(pos.x / (float)CHUNK_SIZE);
    int pcz = (int)floorf(pos.z / (float)CHUNK_SIZE);

    for (int i = 0; i < MAX_CHUNKS; i++)
    {
        Chunk *c = w->chunks[i];
        if (!c) continue;
        int dx = c->cx - pcx;
        int dz = c->cz - pcz;
        if (abs(dx) > RENDER_DISTANCE + 2 || abs(dz) > RENDER_DISTANCE + 2)
        {
            SaveChunk(c);
            free(c);
            w->chunks[i] = NULL;
        }
    }
}

static float BlockEmission(BlockType b)
{
    if (b == BLOCK_TORCH) return 1.0f;
    return 0.0f;
}

static unsigned char GetLocalLight(World *w, int x, int y, int z)
{
    unsigned char base = 0;
    BlockType b = WorldGetBlock(w, x, y, z);
    if (b == BLOCK_TORCH) return 15;

    int cx = (x >= 0) ? x / CHUNK_SIZE : ((x + 1) / CHUNK_SIZE) - 1;
    int cz = (z >= 0) ? z / CHUNK_SIZE : ((z + 1) / CHUNK_SIZE) - 1;
    Chunk *c = WorldGetChunk(w, cx, cz, 0);
    if (c)
    {
        int lx = ((x % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
        int lz = ((z % CHUNK_SIZE) + CHUNK_SIZE) % CHUNK_SIZE;
        base = c->light[lx][y][lz];
    }

    int best = base;
    for (int dz = -4; dz <= 4; dz++)
    for (int dy = -4; dy <= 4; dy++)
    for (int dx = -4; dx <= 4; dx++)
    {
        BlockType t = WorldGetBlock(w, x + dx, y + dy, z + dz);
        if (t == BLOCK_TORCH)
        {
            int d = abs(dx) + abs(dy) + abs(dz);
            int l = 15 - d * 2;
            if (l > best) best = l;
        }
    }

    return (unsigned char)ClampI(best, 0, 15);
}

static int AABBIntersectsBlock(World *w, Vector3 p, float w2, float h, float d)
{
    int minX = (int)floorf(p.x - w2 * 0.5f);
    int maxX = (int)floorf(p.x + w2 * 0.5f);
    int minY = (int)floorf(p.y);
    int maxY = (int)floorf(p.y + h);
    int minZ = (int)floorf(p.z - d * 0.5f);
    int maxZ = (int)floorf(p.z + d * 0.5f);

    for (int y = minY; y <= maxY; y++)
    for (int x = minX; x <= maxX; x++)
    for (int z = minZ; z <= maxZ; z++)
    {
        if (IsSolid(WorldGetBlock(w, x, y, z))) return 1;
    }
    return 0;
}

static void MoveWithCollision(World *w, Vector3 *pos, Vector3 *vel, float dt, int *onGround)
{
    Vector3 p = *pos;
    Vector3 v = *vel;
    *onGround = 0;

    p.x += v.x * dt;
    if (AABBIntersectsBlock(w, p, PLAYER_WIDTH, PLAYER_HEIGHT, PLAYER_WIDTH))
    {
        p.x -= v.x * dt;
        v.x = 0.0f;
    }

    p.y += v.y * dt;
    if (AABBIntersectsBlock(w, p, PLAYER_WIDTH, PLAYER_HEIGHT, PLAYER_WIDTH))
    {
        if (v.y < 0.0f) *onGround = 1;
        p.y -= v.y * dt;
        v.y = 0.0f;
    }

    p.z += v.z * dt;
    if (AABBIntersectsBlock(w, p, PLAYER_WIDTH, PLAYER_HEIGHT, PLAYER_WIDTH))
    {
        p.z -= v.z * dt;
        v.z = 0.0f;
    }

    *pos = p;
    *vel = v;
}

typedef struct HitResult {
    int hit;
    int x, y, z;
    int px, py, pz;
} HitResult;

static HitResult RaycastBlocks(World *w, Vector3 origin, Vector3 dir, float maxDist)
{
    HitResult r = { 0 };
    Vector3 prev = origin;
    float step = 0.08f;
    for (float t = 0.0f; t <= maxDist; t += step)
    {
        Vector3 p = Vector3Add(origin, Vector3Scale(dir, t));
        int x = (int)floorf(p.x);
        int y = (int)floorf(p.y);
        int z = (int)floorf(p.z);
        if (IsSolid(WorldGetBlock(w, x, y, z)))
        {
            r.hit = 1;
            r.x = x; r.y = y; r.z = z;
            r.px = (int)floorf(prev.x);
            r.py = (int)floorf(prev.y);
            r.pz = (int)floorf(prev.z);
            return r;
        }
        prev = p;
    }
    return r;
}

static void AddInventory(Inventory *inv, BlockType t, int amount)
{
    if (t <= BLOCK_AIR || t >= BLOCK_COUNT) return;
    inv->counts[t] += amount;
}

static BlockType SelectedBlock(const Inventory *inv)
{
    return inv->hotbar[ClampI(inv->selected, 0, 8)];
}

static int ConsumeSelected(Inventory *inv)
{
    BlockType t = SelectedBlock(inv);
    if (t <= BLOCK_AIR || t >= BLOCK_COUNT) return 0;
    if (inv->counts[t] <= 0) return 0;
    inv->counts[t]--;
    return 1;
}

static void SpawnMonster(World *w, Vector3 pos)
{
    if (w->monsterCount >= MAX_MONSTERS) return;
    Monster *m = &w->monsters[w->monsterCount++];
    memset(m, 0, sizeof(*m));
    m->pos = pos;
    m->alive = 1;
    m->hp = 20;
    m->wanderYaw = Hash2i((int)pos.x, (int)pos.z) * 2.0f * PI;
}

static void EnsureMonsters(World *w, Vector3 playerPos)
{
    if (w->monsterCount == 0)
    {
        for (int i = 0; i < 10; i++)
        {
            float a = Hash2i(i, i * 31) * 2.0f * PI;
            float r = 18.0f + Hash2i(i * 7, i * 13) * 22.0f;
            Vector3 p = (Vector3){ playerPos.x + cosf(a) * r, playerPos.y + 2.0f, playerPos.z + sinf(a) * r };
            SpawnMonster(w, p);
        }
    }
}

static void MonsterTick(World *w, Monster *m, Vector3 playerPos, float dt)
{
    if (!m->alive) return;

    m->thinkT -= dt;
    m->attackCd = fmaxf(0.0f, m->attackCd - dt);
    Vector3 toPlayer = Vector3Subtract(playerPos, m->pos);
    float dist = Vector3Length(toPlayer);

    if (dist < 14.0f)
    {
        Vector3 dir = Vector3Normalize((Vector3){ toPlayer.x, 0.0f, toPlayer.z });
        m->vel.x = dir.x * 3.8f;
        m->vel.z = dir.z * 3.8f;
    }
    else if (m->thinkT <= 0.0f)
    {
        m->thinkT = 1.2f + Hash2i((int)m->pos.x, (int)m->pos.z) * 1.8f;
        m->wanderYaw += (Hash2i((int)m->pos.x + 3, (int)m->pos.z + 7) - 0.5f) * 2.0f;
        m->vel.x = cosf(m->wanderYaw) * 2.0f;
        m->vel.z = sinf(m->wanderYaw) * 2.0f;
    }

    m->vel.y -= GRAVITY * dt;
    int onGround = 0;
    MoveWithCollision(w, &m->pos, &m->vel, dt, &onGround);
    if (onGround) m->vel.y = 0.0f;

    if (dist < 1.4f && m->attackCd <= 0.0f)
    {
        m->attackCd = 0.8f;
        // simple touch damage would be wired here
    }
}

static void DrawBlock(World *w, int x, int y, int z, BlockType b)
{
    if (b == BLOCK_AIR) return;

    Color c = BlockColor(b);
    unsigned char l = GetLocalLight(w, x, y, z);
    float brightness = 0.25f + 0.05f * l;
    c.r = (unsigned char)ClampI((int)(c.r * brightness), 0, 255);
    c.g = (unsigned char)ClampI((int)(c.g * brightness), 0, 255);
    c.b = (unsigned char)ClampI((int)(c.b * brightness), 0, 255);

    if (b == BLOCK_WATER)
    {
        c.a = 170;
    }

    Vector3 p = { (float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f };
    DrawCube(p, 1.0f, 1.0f, 1.0f, c);

    if (b != BLOCK_WATER && b != BLOCK_LEAF)
    {
        DrawCubeWires(p, 1.0f, 1.0f, 1.0f, (Color){ 15, 15, 15, 70 });
    }
}

static void DrawInventoryUI(Inventory *inv)
{
    int x0 = 20;
    int y0 = SCREEN_H - 64;
    for (int i = 0; i < 9; i++)
    {
        Rectangle r = { (float)(x0 + i * 56), (float)y0, 48.0f, 48.0f };
        DrawRectangleLinesEx(r, 2.0f, (i == inv->selected) ? YELLOW : DARKGRAY);
        BlockType t = inv->hotbar[i];
        Color c = BlockColor(t);
        DrawRectangle((int)r.x + 8, (int)r.y + 8, 16, 16, c);
        DrawText(TextFormat("%d", inv->counts[t]), (int)r.x + 26, (int)r.y + 16, 16, WHITE);
    }
    DrawText("1-9 Select | LMB Break | RMB Place | F Save | N Load | ESC Release Cursor", 20, SCREEN_H - 92, 18, RAYWHITE);
}

static void InitInventory(Inventory *inv)
{
    memset(inv, 0, sizeof(*inv));
    inv->hotbar[0] = BLOCK_GRASS;
    inv->hotbar[1] = BLOCK_DIRT;
    inv->hotbar[2] = BLOCK_STONE;
    inv->hotbar[3] = BLOCK_WOOD;
    inv->hotbar[4] = BLOCK_LEAF;
    inv->hotbar[5] = BLOCK_TORCH;
    inv->hotbar[6] = BLOCK_COBBLE;
    inv->hotbar[7] = BLOCK_SAND;
    inv->hotbar[8] = BLOCK_WATER;
    inv->selected = 0;
    inv->counts[BLOCK_GRASS] = 256;
    inv->counts[BLOCK_DIRT] = 256;
    inv->counts[BLOCK_STONE] = 256;
    inv->counts[BLOCK_WOOD] = 64;
    inv->counts[BLOCK_LEAF] = 128;
    inv->counts[BLOCK_TORCH] = 64;
    inv->counts[BLOCK_COBBLE] = 64;
    inv->counts[BLOCK_SAND] = 64;
    inv->counts[BLOCK_WATER] = 64;
}

static Vector3 ForwardFromYawPitch(float yaw, float pitch)
{
    Vector3 f = {
        cosf(pitch) * sinf(yaw),
        sinf(pitch),
        cosf(pitch) * cosf(yaw)
    };
    return Vector3Normalize(f);
}

static Vector3 RightFromYaw(float yaw)
{
    return (Vector3){ sinf(yaw - PI/2.0f), 0.0f, cosf(yaw - PI/2.0f) };
}

int main(void)
{
    SetConfigFlags(FLAG_MSAA_4X_HINT);
    InitWindow(SCREEN_W, SCREEN_H, "Single-File Voxel Sandbox");
    DisableCursor();
    SetTargetFPS(144);

    EnsureSaveDir();

    World world = { 0 };
    Inventory inv;
    InitInventory(&inv);

    Vector3 playerPos = { 8.0f, 28.0f, 8.0f };
    Vector3 playerVel = { 0 };
    int onGround = 0;
    int health = 20;

    float yaw = 0.0f;
    float pitch = 0.0f;

    Camera3D cam = { 0 };
    cam.position = Vector3Add(playerPos, (Vector3){ 0.0f, PLAYER_EYE, 0.0f });
    cam.target = Vector3Add(cam.position, (Vector3){ 0.0f, 0.0f, 1.0f });
    cam.up = (Vector3){ 0.0f, 1.0f, 0.0f };
    cam.fovy = 70.0f;
    cam.projection = CAMERA_PERSPECTIVE;

    int debugFly = 0;

    LoadVisibleWorld(&world, playerPos);

    while (!WindowShouldClose())
    {
        float dt = GetFrameTime();
        if (dt > 0.05f) dt = 0.05f;

        if (IsKeyPressed(KEY_ESCAPE))
        {
            if (IsCursorHidden())
                EnableCursor();
            else
                DisableCursor();
        }

        if (IsKeyPressed(KEY_F5))
        {
            SaveWorld(&world);
        }
        if (IsKeyPressed(KEY_F9))
        {
            SaveWorld(&world);
        }
        if (IsKeyPressed(KEY_F3))
        {
            debugFly = !debugFly;
        }

        const int hotKeys[9] = { KEY_ONE, KEY_TWO, KEY_THREE, KEY_FOUR, KEY_FIVE, KEY_SIX, KEY_SEVEN, KEY_EIGHT, KEY_NINE };
        for (int i = 0; i < 9; i++)
        {
            if (IsKeyPressed(hotKeys[i])) inv.selected = i;
        }

        Vector2 md = GetMouseDelta();
        if (IsCursorHidden())
        {
            yaw   += md.x * 0.0032f;
            pitch -= md.y * 0.0032f;
            pitch = ClampF(pitch, -1.50f, 1.50f);
        }

        Vector3 forward = ForwardFromYawPitch(yaw, pitch);
        Vector3 right = RightFromYaw(yaw);

        float speed = IsKeyDown(KEY_LEFT_SHIFT) ? RUN_SPEED : MOVE_SPEED;
        Vector3 wish = { 0 };

        if (IsKeyDown(KEY_W)) wish = Vector3Add(wish, forward);
        if (IsKeyDown(KEY_S)) wish = Vector3Subtract(wish, forward);
        if (IsKeyDown(KEY_D)) wish = Vector3Add(wish, right);
        if (IsKeyDown(KEY_A)) wish = Vector3Subtract(wish, right);

        wish.y = 0.0f;
        if (Vector3Length(wish) > 0.0f) wish = Vector3Normalize(wish);

        playerVel.x = wish.x * speed;
        playerVel.z = wish.z * speed;

        if (debugFly)
        {
            playerVel.y = 0.0f;
            if (IsKeyDown(KEY_SPACE)) playerVel.y = speed;
            if (IsKeyDown(KEY_LEFT_CONTROL)) playerVel.y = -speed;
        }
        else
        {
            if (IsKeyPressed(KEY_SPACE) && onGround) playerVel.y = JUMP_VEL;
            playerVel.y -= GRAVITY * dt;
        }

        EnsureWorldAround(&world, playerPos);
        EnsureMonsters(&world, playerPos);
        UnloadFarChunks(&world, playerPos);

        MoveWithCollision(&world, &playerPos, &playerVel, dt, &onGround);

        Vector3 eye = Vector3Add(playerPos, (Vector3){ 0.0f, PLAYER_EYE, 0.0f });
        cam.position = eye;
        cam.target = Vector3Add(eye, forward);

        if (IsKeyPressed(KEY_N))
        {
            SaveWorld(&world);
            LoadVisibleWorld(&world, playerPos);
        }

        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsMouseButtonPressed(MOUSE_RIGHT_BUTTON))
        {
            HitResult hit = RaycastBlocks(&world, cam.position, forward, 6.0f);
            if (hit.hit)
            {
                if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
                {
                    BlockType broken = WorldGetBlock(&world, hit.x, hit.y, hit.z);
                    if (broken != BLOCK_AIR)
                    {
                        WorldSetBlock(&world, hit.x, hit.y, hit.z, BLOCK_AIR);
                        AddInventory(&inv, broken, 1);
                        Chunk *cc = WorldGetChunk(&world,
                                                  (hit.x >= 0) ? hit.x / CHUNK_SIZE : ((hit.x + 1) / CHUNK_SIZE) - 1,
                                                  (hit.z >= 0) ? hit.z / CHUNK_SIZE : ((hit.z + 1) / CHUNK_SIZE) - 1,
                                                  0);
                        if (cc) RecalcChunkLight(cc);
                    }
                }
                else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON))
                {
                    int px = hit.px;
                    int py = hit.py;
                    int pz = hit.pz;
                    if (WorldGetBlock(&world, px, py, pz) == BLOCK_AIR)
                    {
                        if (inv.selected > 0 && inv.selected < BLOCK_COUNT)
                        {
                            if (ConsumeSelected(&inv))
                            {
                                WorldSetBlock(&world, px, py, pz, SelectedBlock(&inv));
                                Chunk *cc = WorldGetChunk(&world,
                                                          (px >= 0) ? px / CHUNK_SIZE : ((px + 1) / CHUNK_SIZE) - 1,
                                                          (pz >= 0) ? pz / CHUNK_SIZE : ((pz + 1) / CHUNK_SIZE) - 1,
                                                          0);
                                if (cc) RecalcChunkLight(cc);
                            }
                        }
                    }
                }
            }
        }

        for (int i = 0; i < world.monsterCount; i++)
        {
            MonsterTick(&world, &world.monsters[i], playerPos, dt);
        }

        BeginDrawing();
        ClearBackground((Color){ 120, 180, 255, 255 });

        BeginMode3D(cam);

        DrawGrid(64, 1.0f);

        int pcx = (int)floorf(playerPos.x / CHUNK_SIZE);
        int pcz = (int)floorf(playerPos.z / CHUNK_SIZE);

        for (int cz = pcz - RENDER_DISTANCE; cz <= pcz + RENDER_DISTANCE; cz++)
        for (int cx = pcx - RENDER_DISTANCE; cx <= pcx + RENDER_DISTANCE; cx++)
        {
            Chunk *c = WorldGetChunk(&world, cx, cz, 0);
            if (!c || !c->generated) continue;
            for (int x = 0; x < CHUNK_SIZE; x++)
            for (int z = 0; z < CHUNK_SIZE; z++)
            for (int y = 0; y < WORLD_HEIGHT; y++)
            {
                BlockType b = (BlockType)c->blocks[x][y][z];
                if (b == BLOCK_AIR) continue;
                int wx = cx * CHUNK_SIZE + x;
                int wz = cz * CHUNK_SIZE + z;
                if (Vector3DistanceSqr(cam.position, (Vector3){ wx + 0.5f, y + 0.5f, wz + 0.5f }) > 90.0f * 90.0f) continue;
                DrawBlock(&world, wx, y, wz, b);
            }
        }

        for (int i = 0; i < world.monsterCount; i++)
        {
            Monster *m = &world.monsters[i];
            if (!m->alive) continue;
            DrawCube(m->pos, 0.8f, 1.7f, 0.8f, RED);
            DrawCubeWires(m->pos, 0.8f, 1.7f, 0.8f, MAROON);
        }

        // player marker
        DrawCube(Vector3Add(playerPos, (Vector3){ 0.0f, 0.9f, 0.0f }), 0.6f, 1.8f, 0.6f, (Color){ 70, 220, 255, 120 });

        EndMode3D();

        DrawText(TextFormat("FPS: %d  Health:%d  Chunks:%d  Monsters:%d", GetFPS(), health, world.monsterCount, world.monsterCount), 20, 20, 20, BLACK);
        DrawText(TextFormat("Pos: %.1f %.1f %.1f", playerPos.x, playerPos.y, playerPos.z), 20, 46, 18, BLACK);
        DrawInventoryUI(&inv);

        if (debugFly)
            DrawText("DEBUG FLY ON", 20, 72, 20, RED);

        EndDrawing();
    }

    SaveWorld(&world);
    for (int i = 0; i < MAX_CHUNKS; i++) free(world.chunks[i]);
    CloseWindow();
    return 0;
}