#include "network.h"
#include "raylib.h"
#include "raymath.h"
#include "rcamera.h"
#include <vector>
#include <unordered_map>
#include <string>
#include <cmath>
#include <iostream>
#include <cstring>
#include <time.h>
#include <filesystem>
#include <fstream>
#include "rlgl.h"

#define CHUNK_SIZE 32
#ifndef PI
#define PI 3.1415926535f
#endif
#define CHUNK_HEIGHT 128
#define RENDER_DISTANCE 1 // 3x3 chunks visible for performance

enum BlockType {
    AIR = 0, GRASS = 1, DIRT = 2, COBBLESTONE = 3, LOG = 4, LEAVES = 5, PLANK = 6,
    STONE = 7, BEDROCK = 8, DIAMOND_ORE = 9, IRON_ORE = 10, GRAVEL = 11, CRAFTING_TABLE = 12, SAND = 13,
    STICK = 14, WOOD_AXE = 15
};

// Simple 2D Perlin Noise implementation
float dotGridGradient(int ix, int iy, float x, float y, unsigned int seed) {
    unsigned int hash = ix * 3284157443 ^ iy * 1911520717;
    hash ^= seed;
    float random = hash * (3.14159265f / ~(~0u >> 1));
    float gradientX = cosf(random);
    float gradientY = sinf(random);
    float dx = x - (float)ix;
    float dy = y - (float)iy;
    return (dx*gradientX + dy*gradientY);
}

float interpolate(float a0, float a1, float w) {
    return (a1 - a0) * (3.0f - w * 2.0f) * w * w;
}

float perlin(float x, float y, unsigned int seed) {
    int x0 = (int)floorf(x);
    int x1 = x0 + 1;
    int y0 = (int)floorf(y);
    int y1 = y0 + 1;
    float sx = x - (float)x0;
    float sy = y - (float)y0;
    float n0 = dotGridGradient(x0, y0, x, y, seed);
    float n1 = dotGridGradient(x1, y0, x, y, seed);
    float ix0 = interpolate(n0, n1, sx);
    n0 = dotGridGradient(x0, y1, x, y, seed);
    n1 = dotGridGradient(x1, y1, x, y, seed);
    float ix1 = interpolate(n0, n1, sx);
    return interpolate(ix0, ix1, sy); // returns approximately -1.0 to 1.0
}

struct ChunkPos {
    int x, z;
    bool operator==(const ChunkPos& other) const { return x == other.x && z == other.z; }
};

struct ChunkPosHash {
    std::size_t operator()(const ChunkPos& k) const {
        return ((std::hash<int>()(k.x) ^ (std::hash<int>()(k.z) << 1)) >> 1);
    }
};

struct Chunk {
    int blocks[CHUNK_SIZE][CHUNK_HEIGHT][CHUNK_SIZE];
    int maxY = 0;
    bool generated = false;
    bool modified = false;
    bool dirty = true;
    std::vector<Vector3> renderLists[16];
    Chunk() : generated(false), modified(false), maxY(0), dirty(true) {}
};

// Global variables for persistence
std::unordered_map<ChunkPos, Chunk*, ChunkPosHash> worldChunks;
static unsigned int globalSeedHash = 0;
static std::string currentWorldName = "";
static std::string playerName = "Player";
static bool serverMode = false;

enum MenuState { MAIN_MENU, OPTIONS_MENU, CREATE_WORLD_MENU, LOAD_WORLD_MENU, GAMEPLAY, PAUSE_MENU, CRAFTING_GUI, CHECKING_UPDATES, UPDATE_NOTES, UPDATE_FOUND, DOWNLOADING_UPDATE, CONNECT_MENU };

// Forward Declarations
bool IsExposedOptimized(int lx, int ly, int lz, Chunk* chunk, Chunk* nxM, Chunk* nxP, Chunk* nzM, Chunk* nzP);
void RebuildChunkRenderList(Chunk* chunk, int cx, int cz);
void GenerateChunk(int cx, int cz);
void SetBlock(int x, int y, int z, int type);
void SaveConfig();
void LoadConfig();
std::string GetRemoteVersion();

struct RemotePlayer {
    Socket sock;
    std::string name;
    Vector3 position;
    float yaw;
};
static std::vector<RemotePlayer> remotePlayers;

// Global Networking State
static Socket clientSocket = INVALID_SOCKET_VAL;
static Socket serverSocket = INVALID_SOCKET_VAL;
static std::vector<Socket> clientSockets;
static bool isConnecting = false;

// ---- Inventory System ----
struct InventorySlot {
    int blockType = AIR;
    int count = 0;
    InventorySlot() : blockType(AIR), count(0) {}
    InventorySlot(int bt, int c) : blockType(bt), count(c) {}
};

static InventorySlot hotbar[9];    // 9 hotbar slots
static InventorySlot inventory[27]; // 3x9 main inventory
static int activeHotbarSlot = 0;
static bool inventoryOpen = false;

// Adds one block to inventory: first fills existing stacks, then empty slots.
void AddToInventory(int blockType) {
    // Search hotbar first
    for (int i = 0; i < 9; i++) {
        if (hotbar[i].blockType == blockType && hotbar[i].count < 64) {
            hotbar[i].count++; return;
        }
    }
    // Then main inventory
    for (int i = 0; i < 27; i++) {
        if (inventory[i].blockType == blockType && inventory[i].count < 64) {
            inventory[i].count++; return;
        }
    }
    // Empty hotbar slot
    for (int i = 0; i < 9; i++) {
        if (hotbar[i].count == 0) {
            hotbar[i].blockType = blockType; hotbar[i].count = 1; return;
        }
    }
    // Empty main inventory slot
    for (int i = 0; i < 27; i++) {
        if (inventory[i].count == 0) {
            inventory[i].blockType = blockType; inventory[i].count = 1; return;
        }
    }
    // Inventory full — item is lost for now
}

// Camera look angles — global so world load/create can reset them cleanly
static float camYaw   = 0.0f;
static float camPitch = 0.0f;

bool LoadChunk(Chunk* chunk, int cx, int cz) {
    if (currentWorldName.empty()) return false;
    std::string path = "saves/" + currentWorldName + "/chunk_" + std::to_string(cx) + "_" + std::to_string(cz) + ".dat";
    std::ifstream file(path, std::ios::binary);
    if (file.is_open()) {
        file.read((char*)chunk->blocks, sizeof(chunk->blocks));
        chunk->generated = true;
        chunk->modified = false;
        // Calculate maxY for the loaded chunk
        chunk->maxY = 0;
        for (int x=0; x<CHUNK_SIZE; x++)
            for (int z=0; z<CHUNK_SIZE; z++)
                for (int y=CHUNK_HEIGHT-1; y>=0; y--)
                    if (chunk->blocks[x][y][z] != AIR) {
                        if (y > chunk->maxY) chunk->maxY = y;
                        break;
                    }
        return true;
    }
    return false;
}

void SaveChunk(Chunk* chunk, int cx, int cz) {
    if (currentWorldName.empty() || !chunk->modified) return;
    std::filesystem::create_directories("saves/" + currentWorldName);
    std::string path = "saves/" + currentWorldName + "/chunk_" + std::to_string(cx) + "_" + std::to_string(cz) + ".dat";
    std::ofstream file(path, std::ios::binary);
    if (file.is_open()) {
        file.write((char*)chunk->blocks, sizeof(chunk->blocks));
        chunk->modified = false;
    }
}

int GetBlock(int x, int y, int z) {
    if (y < 0 || y >= CHUNK_HEIGHT) return 0;
    int cx = (int)floorf((float)x / CHUNK_SIZE);
    int cz = (int)floorf((float)z / CHUNK_SIZE);
    ChunkPos key = { cx, cz };
    if (worldChunks.find(key) != worldChunks.end()) {
        int lx = x - (cx * CHUNK_SIZE);
        int lz = z - (cz * CHUNK_SIZE);
        return worldChunks[key]->blocks[lx][y][lz];
    }
    return 0; // Air if chunk not loaded
}

void RebuildChunkRenderList(Chunk* chunk, int cx, int cz) {
    for (int i = 0; i < 16; i++) chunk->renderLists[i].clear();
    
    // Neighbors for exposure check
    auto itNM = worldChunks.find({cx-1, cz});
    Chunk* nxM = (itNM != worldChunks.end()) ? itNM->second : nullptr;
    auto itNP = worldChunks.find({cx+1, cz});
    Chunk* nxP = (itNP != worldChunks.end()) ? itNP->second : nullptr;
    auto itZM = worldChunks.find({cx, cz-1});
    Chunk* nzM = (itZM != worldChunks.end()) ? itZM->second : nullptr;
    auto itZP = worldChunks.find({cx, cz+1});
    Chunk* nzP = (itZP != worldChunks.end()) ? itZP->second : nullptr;

    int worldX = cx * CHUNK_SIZE;
    int worldZ = cz * CHUNK_SIZE;

    for (int lx = 0; lx < CHUNK_SIZE; lx++) {
        for (int ly = 0; ly <= chunk->maxY; ly++) {
            for (int lz = 0; lz < CHUNK_SIZE; lz++) {
                int bt = chunk->blocks[lx][ly][lz];
                if (bt == AIR) continue;
                
                if (IsExposedOptimized(lx, ly, lz, chunk, nxM, nxP, nzM, nzP)) {
                    chunk->renderLists[bt].push_back((Vector3){(float)(worldX+lx), (float)ly, (float)(worldZ+lz)});
                }
            }
        }
    }
    chunk->dirty = false;
}

void NetSetBlock(int x, int y, int z, int type) {
    SetBlock(x, y, z, type);
    PacketHeader head = { (uint8_t)PACKET_BLOCK_CHANGE, (uint32_t)sizeof(PacketBlockChange) };
    PacketBlockChange bc = { x, y, z, type };
    
    if (clientSocket != INVALID_SOCKET_VAL) {
        send(clientSocket, (char*)&head, sizeof(head), 0);
        send(clientSocket, (char*)&bc, sizeof(bc), 0);
    }
    if (serverSocket != INVALID_SOCKET_VAL) {
        for (auto& s : clientSockets) {
            send(s, (char*)&head, sizeof(head), 0);
            send(s, (char*)&bc, sizeof(bc), 0);
        }
    }
}

void SetBlock(int x, int y, int z, int type) {
    if (y < 0 || y >= CHUNK_HEIGHT) return;
    int cx = (int)floorf((float)x / CHUNK_SIZE);
    int cz = (int)floorf((float)z / CHUNK_SIZE);
    ChunkPos key = { cx, cz };
    if (worldChunks.find(key) != worldChunks.end()) {
        int lx = x - (cx * CHUNK_SIZE);
        int lz = z - (cz * CHUNK_SIZE);
        worldChunks[key]->blocks[lx][y][lz] = type;
        worldChunks[key]->modified = true;
        worldChunks[key]->dirty = true;
        
        // Keep maxY up to date
        if (type != AIR && y > worldChunks[key]->maxY) worldChunks[key]->maxY = y;
        
        // Mark neighbors dirty as well since exposure changes
        if (lx == 0) { auto n = worldChunks.find({cx-1, cz}); if (n != worldChunks.end()) n->second->dirty = true; }
        if (lx == CHUNK_SIZE-1) { auto n = worldChunks.find({cx+1, cz}); if (n != worldChunks.end()) n->second->dirty = true; }
        if (lz == 0) { auto n = worldChunks.find({cx, cz-1}); if (n != worldChunks.end()) n->second->dirty = true; }
        if (lz == CHUNK_SIZE-1) { auto n = worldChunks.find({cx, cz+1}); if (n != worldChunks.end()) n->second->dirty = true; }
    }
}

std::string GetRemoteVersion() {
    std::string url = "https://git.linology.tech/michael/MorriCraft/raw/branch/master/version.txt";
    char buffer[128];
    std::string result = "";
    std::string cmd = "curl -s -m 5 " + url; // 5 second timeout
    FILE* pipe = popen(cmd.c_str(), "r");
    if (!pipe) return "error";
    while (fgets(buffer, sizeof(buffer), pipe) != NULL) {
        result += buffer;
    }
    pclose(pipe);
    // Trim result
    size_t last = result.find_last_not_of(" \n\r\t");
    if (last != std::string::npos) result = result.substr(0, last + 1);
    return result;
}

void SaveConfig() {
    std::ofstream file("config.cfg");
    if (file.is_open()) {
        file << "playerName=" << playerName << "\n";
        file << "serverMode=" << (serverMode ? "true" : "false") << "\n";
        file.close();
    }
}

void LoadConfig() {
    std::ifstream file("config.cfg");
    if (file.is_open()) {
        std::string line;
        while (std::getline(file, line)) {
            size_t sep = line.find('=');
            if (sep != std::string::npos) {
                std::string key = line.substr(0, sep);
                std::string val = line.substr(sep + 1);
                if (key == "playerName") playerName = val;
                else if (key == "serverMode") serverMode = (val == "true");
            }
        }
        file.close();
    } else {
        playerName = ""; // Trigger popup
    }
}

void GenerateTrees(Chunk* chunk, int cx, int cz) {
    for (int x = 0; x < CHUNK_SIZE; x++) {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            // Find the highest block
            int topY = -1;
            for (int y = CHUNK_HEIGHT - 1; y >= 0; y--) {
                if (chunk->blocks[x][y][z] != AIR) {
                    topY = y;
                    break;
                }
            }
            
            // Trees only spawn on grass
            if (topY != -1 && chunk->blocks[x][topY][z] == GRASS) {
                // Pseudo-random chance to spawn a tree
                unsigned int treeHash = (cx * CHUNK_SIZE + x) * 73856093 ^ (cz * CHUNK_SIZE + z) * 19349663;
                treeHash ^= globalSeedHash;
                
                // ~0.5% chance to spawn a tree, and ensure there's enough height
                if (treeHash % 1000 < 5 && topY < CHUNK_HEIGHT - 6) {
                    int treeHeight = 4 + (treeHash % 2); // 4 or 5 blocks tall
                    
                    // Wood logs
                    for (int i = 1; i <= treeHeight; i++) {
                        chunk->blocks[x][topY + i][z] = LOG;
                    }
                    
                    // 3x3x3 Leaf cluster at the top
                    for (int lx = x - 1; lx <= x + 1; lx++) {
                        for (int lz = z - 1; lz <= z + 1; lz++) {
                            for (int ly = topY + treeHeight - 1; ly <= topY + treeHeight + 1; ly++) {
                                if (lx >= 0 && lx < CHUNK_SIZE && lz >= 0 && lz < CHUNK_SIZE && ly >= 0 && ly < CHUNK_HEIGHT) {
                                    // Don't overwrite the wood logs
                                    if (chunk->blocks[lx][ly][lz] == AIR) {
                                        chunk->blocks[lx][ly][lz] = LEAVES;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

// Fractal Brownian Motion: stacks multiple octaves of Perlin noise for smooth terrain
float fbm(float x, float y, unsigned int seed) {
    float value = 0.0f;
    float amplitude = 1.0f;
    float frequency = 1.0f;
    float maxValue = 0.0f;
    // 4 octaves: coarse shape + medium bumps + fine details + micro-texture
    for (int i = 0; i < 4; i++) {
        value += perlin(x * frequency, y * frequency, seed + i * 7919) * amplitude;
        maxValue += amplitude;
        amplitude *= 0.5f;   // each octave is half the strength
        frequency *= 2.0f;   // each octave is double the detail
    }
    return value / maxValue; // normalize back to -1..1
}

// Forward-declare so FindSpawnY can call GenerateChunk
void GenerateChunk(int cx, int cz);

// Generate the spawn chunk and scan downward to find the first solid surface.
// Returns the player eye-level Y (surface block top + 1.6 camera height).
float FindSpawnY(int spawnX, int spawnZ) {
    int cx = (int)floorf((float)spawnX / CHUNK_SIZE);
    int cz = (int)floorf((float)spawnZ / CHUNK_SIZE);
    GenerateChunk(cx, cz);
    for (int y = CHUNK_HEIGHT - 1; y >= 1; y--) {
        if (GetBlock(spawnX, y, spawnZ) != AIR) {
            // Feet land at top of block (y + 0.5), eye is 1.6 above feet
            return (float)y + 0.5f + 1.6f;
        }
    }
    return 40.0f; // Fallback
}

void GenerateChunk(int cx, int cz) {
    ChunkPos key = { cx, cz };
    if (worldChunks.find(key) != worldChunks.end()) return;
    
    Chunk* newChunk = new Chunk();
    
    if (LoadChunk(newChunk, cx, cz)) {
        worldChunks[key] = newChunk;
        return;
    }
    
    // Initialize with AIR
    for (int x=0; x<CHUNK_SIZE; x++)
        for (int y=0; y<CHUNK_HEIGHT; y++)
            for (int z=0; z<CHUNK_SIZE; z++)
                newChunk->blocks[x][y][z] = AIR;
                
    for (int x = 0; x < CHUNK_SIZE; x++) {
        for (int z = 0; z < CHUNK_SIZE; z++) {
            float worldX = cx * CHUNK_SIZE + x;
            float worldZ = cz * CHUNK_SIZE + z;
            
            // Multi-octave fbm noise at a much lower frequency for broad, smooth hills.
            // Base freq 0.006 means features span ~160 blocks, preventing steep cliffs.
            float noiseVal = fbm(worldX * 0.006f, worldZ * 0.006f, globalSeedHash);
            // Terrain sits around Y=32 with only ±6 blocks of variation,
            // so the minimum ground level is 26 -- no sudden deep holes.
            int height = 32 + (int)(noiseVal * 6.0f);
            if (height < 10) height = 10;
            if (height >= CHUNK_HEIGHT - 2) height = CHUNK_HEIGHT - 2;
            
            for (int y = 0; y <= height; y++) {
                if (y == 0) {
                    newChunk->blocks[x][y][z] = BEDROCK;
                } else if (y == height) {
                    newChunk->blocks[x][y][z] = GRASS;
                } else if (y > height - 4) {
                    // 4 blocks of dirt under the surface — thick enough that ores
                    // can never be exposed by normal terrain features.
                    newChunk->blocks[x][y][z] = DIRT;
                } else {
                    newChunk->blocks[x][y][z] = STONE;
                    
                    // Ore generation gated by depth so ores are never at surface.
                    unsigned int oreHash = (cx * CHUNK_SIZE + x) * 73856093 ^ (cz * CHUNK_SIZE + z) * 19349663 ^ y * 83492791;
                    oreHash ^= globalSeedHash;
                    
                    // Diamond only very deep (below Y=16, well below new surface at Y=32)
                    if (y <= 16 && oreHash % 120 < 1) {
                        newChunk->blocks[x][y][z] = DIAMOND_ORE;
                    // Iron ore below Y=24
                    } else if (y <= 24 && oreHash % 80 < 3) {
                        newChunk->blocks[x][y][z] = IRON_ORE;
                    // Gravel pockets below Y=20
                    } else if (y <= 20 && oreHash % 60 < 4) {
                        newChunk->blocks[x][y][z] = GRAVEL;
                    }
                }
            }
        }
    }
    
    // Add trees
    GenerateTrees(newChunk, cx, cz);
    
    // Record the highest non-air block so the render loop skips empty space
    newChunk->maxY = 0;
    for (int x = 0; x < CHUNK_SIZE; x++)
        for (int z = 0; z < CHUNK_SIZE; z++)
            for (int y = CHUNK_HEIGHT - 1; y >= 0; y--)
                if (newChunk->blocks[x][y][z] != AIR) {
                    if (y > newChunk->maxY) newChunk->maxY = y;
                    break;
                }
    
    newChunk->generated = true;
    newChunk->modified = true; // Newly generated, so we should save it
    worldChunks[key] = newChunk;
}

bool CheckPlayerCollision(Vector3 pos) {
    BoundingBox playerBox = {
        (Vector3){ pos.x - 0.3f, pos.y - 1.5f, pos.z - 0.3f },
        (Vector3){ pos.x + 0.3f, pos.y + 0.1f, pos.z + 0.3f }
    };
    
    int minX = (int)floorf(playerBox.min.x + 0.5f);
    int maxX = (int)floorf(playerBox.max.x + 0.5f);
    int minY = (int)floorf(playerBox.min.y + 0.5f);
    int maxY = (int)floorf(playerBox.max.y + 0.5f);
    int minZ = (int)floorf(playerBox.min.z + 0.5f);
    int maxZ = (int)floorf(playerBox.max.z + 0.5f);
    
    for (int x = minX; x <= maxX; x++) {
        for (int y = minY; y <= maxY; y++) {
            for (int z = minZ; z <= maxZ; z++) {
                if (GetBlock(x, y, z) != AIR) {
                    BoundingBox blockBox = {
                        (Vector3){ x - 0.5f, y - 0.5f, z - 0.5f },
                        (Vector3){ x + 0.5f, y + 0.5f, z + 0.5f }
                    };
                    if (CheckCollisionBoxes(playerBox, blockBox)) {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

void DrawTexturedCube(Vector3 position, float width, float height, float length, Color color) {
    float x = position.x;
    float y = position.y;
    float z = position.z;
    
    rlBegin(RL_QUADS);
    rlColor4ub(color.r, color.g, color.b, color.a);
    // Front
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - width/2, y - height/2, z + length/2);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + width/2, y - height/2, z + length/2);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + width/2, y + height/2, z + length/2);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - width/2, y + height/2, z + length/2);
    // Back
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - width/2, y - height/2, z - length/2);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - width/2, y + height/2, z - length/2);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + width/2, y + height/2, z - length/2);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + width/2, y - height/2, z - length/2);
    // Top
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - width/2, y + height/2, z - length/2);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - width/2, y + height/2, z + length/2);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + width/2, y + height/2, z + length/2);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + width/2, y + height/2, z - length/2);
    // Bottom
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - width/2, y - height/2, z - length/2);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + width/2, y - height/2, z - length/2);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + width/2, y - height/2, z + length/2);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - width/2, y - height/2, z + length/2);
    // Right
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + width/2, y - height/2, z - length/2);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + width/2, y + height/2, z - length/2);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + width/2, y + height/2, z + length/2);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + width/2, y - height/2, z + length/2);
    // Left
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - width/2, y - height/2, z - length/2);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - width/2, y - height/2, z + length/2);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - width/2, y + height/2, z + length/2);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - width/2, y + height/2, z - length/2);
    rlEnd();
}

// Draws a grass block with correct per-face textures:
// top=green grass, sides=dirt+grass stripe, bottom=pure dirt.
// Caller must NOT have an active rlSetTexture — this function manages its own binds.
void DrawGrassBlock(Vector3 position, unsigned int sideTexId, unsigned int topTexId, unsigned int botTexId, Color tint) {
    float x = position.x;
    float y = position.y;
    float z = position.z;
    
    // ---- SIDES (4 faces) ----
    rlSetTexture(sideTexId);
    rlBegin(RL_QUADS);
    rlColor4ub(tint.r, tint.g, tint.b, 255);
    // Front
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z + 0.5f);
    // Back
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z - 0.5f);
    // Right
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z + 0.5f);
    // Left
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z - 0.5f);
    rlEnd();
    
    // ---- TOP (pure green) ----
    rlSetTexture(topTexId);
    rlBegin(RL_QUADS);
    // Combine grass green with ambient light
    rlColor4ub((unsigned char)(124 * (tint.r/255.0f)), 
               (unsigned char)(189 * (tint.g/255.0f)), 
               (unsigned char)(107 * (tint.b/255.0f)), 255);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - 0.5f, y + 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + 0.5f, y + 0.5f, z - 0.5f);
    // ---- BOTTOM (pure dirt) ----
    rlSetTexture(botTexId);
    rlBegin(RL_QUADS);
    rlColor4ub(tint.r, tint.g, tint.b, 255);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + 0.5f, y - 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - 0.5f, y - 0.5f, z + 0.5f);
    rlEnd();
}

// Draws a crafting table with custom top and sides
void DrawCraftingTable(Vector3 position, unsigned int sideTexId, unsigned int topTexId, unsigned int botTexId, Color tint) {
    float x = position.x; float y = position.y; float z = position.z;
    
    // SIDES
    rlSetTexture(sideTexId);
    rlBegin(RL_QUADS);
    rlColor4ub(tint.r, tint.g, tint.b, 255);
    // Front, Back, Right, Left
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z + 0.5f); rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z + 0.5f); rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z + 0.5f); rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z - 0.5f); rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z - 0.5f); rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z - 0.5f); rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z - 0.5f); rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z - 0.5f); rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z + 0.5f); rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z + 0.5f);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z - 0.5f); rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z + 0.5f); rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z + 0.5f); rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z - 0.5f);
    rlEnd();
    
    // TOP
    rlSetTexture(topTexId);
    rlBegin(RL_QUADS);
    rlColor4ub(tint.r, tint.g, tint.b, 255);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - 0.5f, y + 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + 0.5f, y + 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + 0.5f, y + 0.5f, z - 0.5f);
    rlEnd();
    
    // BOTTOM (dirt)
    rlSetTexture(botTexId);
    rlBegin(RL_QUADS);
    rlColor4ub(tint.r, tint.g, tint.b, 255);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + 0.5f, y - 0.5f, z - 0.5f);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + 0.5f, y - 0.5f, z + 0.5f);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - 0.5f, y - 0.5f, z + 0.5f);
    rlEnd();
}

// Optimized check to see if a block has any exposed faces.
bool IsExposedOptimized(int lx, int ly, int lz, Chunk* chunk, Chunk* nxM, Chunk* nxP, Chunk* nzM, Chunk* nzP) {
    if (ly > 0) { if (chunk->blocks[lx][ly-1][lz] == AIR) return true; } else return true;
    if (ly < CHUNK_HEIGHT - 1) { if (chunk->blocks[lx][ly+1][lz] == AIR) return true; } else return true;
    if (lx > 0) { if (chunk->blocks[lx-1][ly][lz] == AIR) return true; }
    else if (nxM) { if (nxM->blocks[CHUNK_SIZE-1][ly][lz] == AIR) return true; } else return true;
    if (lx < CHUNK_SIZE - 1) { if (chunk->blocks[lx+1][ly][lz] == AIR) return true; }
    else if (nxP) { if (nxP->blocks[0][ly][lz] == AIR) return true; } else return true;
    if (lz > 0) { if (chunk->blocks[lx][ly][lz-1] == AIR) return true; }
    else if (nzM) { if (nzM->blocks[lx][ly][CHUNK_SIZE-1] == AIR) return true; } else return true;
    if (lz < CHUNK_SIZE - 1) { if (chunk->blocks[lx][ly][lz+1] == AIR) return true; }
    else if (nzP) { if (nzP->blocks[lx][ly][0] == AIR) return true; } else return true;
    return false;
}

// Optimized helper for batched rendering: Draws only the vertices (no texture bind or rlBegin/End)
void DrawCubeVertices(float x, float y, float z, float w, float h, float l) {
    float hw = w/2.0f; float hh = h/2.0f; float hl = l/2.0f;
    // Front
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - hw, y - hh, z + hl);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + hw, y - hh, z + hl);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + hw, y + hh, z + hl);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - hw, y + hh, z + hl);
    // Back
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - hw, y - hh, z - hl);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - hw, y + hh, z - hl);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + hw, y + hh, z - hl);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + hw, y - hh, z - hl);
    // Top
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - hw, y + hh, z - hl);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - hw, y + hh, z + hl);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + hw, y + hh, z + hl);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + hw, y + hh, z - hl);
    // Bottom
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - hw, y - hh, z - hl);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + hw, y - hh, z - hl);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + hw, y - hh, z + hl);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - hw, y - hh, z + hl);
    // Right
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x + hw, y - hh, z - hl);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x + hw, y + hh, z - hl);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x + hw, y + hh, z + hl);
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x + hw, y - hh, z + hl);
    // Left
    rlTexCoord2f(0.0f, 1.0f); rlVertex3f(x - hw, y - hh, z - hl);
    rlTexCoord2f(1.0f, 1.0f); rlVertex3f(x - hw, y - hh, z + hl);
    rlTexCoord2f(1.0f, 0.0f); rlVertex3f(x - hw, y + hh, z + hl);
    rlTexCoord2f(0.0f, 0.0f); rlVertex3f(x - hw, y + hh, z - hl);
}

// Optimized check to see if a block has any exposed faces
bool IsExposed(int x, int ly, int z, Chunk* chunk, int lx, int lz) {
    // Local check (inside same chunk)
    if (lx > 0 && lx < CHUNK_SIZE - 1 && ly > 0 && ly < CHUNK_HEIGHT - 1 && lz > 0 && lz < CHUNK_SIZE - 1) {
        if (chunk->blocks[lx-1][ly][lz] == AIR) return true;
        if (chunk->blocks[lx+1][ly][lz] == AIR) return true;
        if (chunk->blocks[lx][ly-1][lz] == AIR) return true;
        if (chunk->blocks[lx][ly+1][lz] == AIR) return true;
        if (chunk->blocks[lx][ly][lz-1] == AIR) return true;
        if (chunk->blocks[lx][ly][lz+1] == AIR) return true;
        return false;
    }
    // Global check (at chunk boundary)
    if (GetBlock(x-1, ly, z) == AIR) return true;
    if (GetBlock(x+1, ly, z) == AIR) return true;
    if (GetBlock(x, ly-1, z) == AIR) return true;
    if (GetBlock(x, ly+1, z) == AIR) return true;
    if (GetBlock(x, ly, z-1) == AIR) return true;
    if (GetBlock(x, ly, z+1) == AIR) return true;
    return false;
}

int main(void)
{
    SetRandomSeed((unsigned int)time(NULL));
    // Initialization
    //--------------------------------------------------------------------------------------
    const int screenWidth = 1280;
    const int screenHeight = 720;

    // Set config flags to allow window resizing.
    // By default, windows have minimize, maximize, and close buttons on the top bar.
    SetConfigFlags(FLAG_WINDOW_RESIZABLE | FLAG_VSYNC_HINT);

    InitWindow(screenWidth, screenHeight, "MorriCraft v2.0.1");
    LoadConfig();
    SetExitKey(KEY_NULL); // Prevent ESC from closing the window

    // Initialize audio device
    InitAudioDevice();

    // Load the title image, music, and font
    // NOTE: Textures and Fonts MUST be loaded after Window initialization
    Texture2D titleTexture = LoadTexture("assets/TitleImage.png");
    Font customFont = LoadFontEx("assets/PixelFont.ttf", 32, 0, 250);
    Music titleMusic = LoadMusicStream("assets/Morricraft-title.mp3");
    titleMusic.looping = true;
    PlayMusicStream(titleMusic);
    
    Music gameplayMusic = LoadMusicStream("assets/Morricraft-day1.mp3");
    gameplayMusic.looping = true;
    PlayMusicStream(gameplayMusic);
    SetMusicVolume(gameplayMusic, 0.0f);

    Music nightMusic = LoadMusicStream("assets/Morricraft-night.mp3");
    nightMusic.looping = true;
    PlayMusicStream(nightMusic);
    SetMusicVolume(nightMusic, 0.0f);

    // Digging Sound Effects
    Sound digGrass = LoadSound("assets/grass1.ogg");
    Sound digWood = LoadSound("assets/wood1.ogg");
    Sound digStone = LoadSound("assets/stone1.ogg");
    Sound digSand = LoadSound("assets/sand1.ogg");
    
    SetSoundVolume(digGrass, 0.6f);
    SetSoundVolume(digWood, 0.6f);
    SetSoundVolume(digStone, 0.6f);
    SetSoundVolume(digSand, 0.6f);

    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
    //--------------------------------------------------------------------------------------
    
    float playerVelocityY = 0.0f;
    bool isGrounded = false;
    
    MenuState currentState = CHECKING_UPDATES;
    MenuState optionsReturnState = MAIN_MENU;
    
    bool updateReady = false;
    float updateTimer = 0.0f;
    float downloadProgress = 0.0f;
    std::string latestVersion = "";
    std::string localVersion = "v1.9.0"; // Default fallback
    
    // Read local version
    std::ifstream vfile("assets/version.txt");
    if (vfile.is_open()) {
        std::getline(vfile, localVersion);
        vfile.close();
    }
    
    // Networking State (Target IP/Port remain local for UI)
    char targetIP[128] = "127.0.0.1";
    char targetPort[16] = "12345";
    int activeNetField = 0; // 0=none, 1=IP, 2=Port
    
    InitNetworking();
    InventorySlot mouseHeldItem(AIR, 0);
    float gameTime = 75.0f; // Start at 6:00 AM
    float breakProgress = 0.0f;
    int lastHitX = -1, lastHitY = -1, lastHitZ = -1;
    float swingTime = 0.0f;
    bool isSwinging = false;
    float digSoundTimer = 0.0f;

    float targetZoom = 1.1f;
    float currentZoom = 1.1f;

    float masterMusicVolume = 1.0f;
    float masterSoundVolume = 1.0f;
    
    char worldName[64] = "New World";
    int worldNameLen = 9;
    char worldSeed[64] = "";
    int worldSeedLen = 0;
    int activeTextBox = 0; // 0 = none, 1 = name, 2 = seed
    
    bool showDeleteConfirm = false;
    std::string deletingWorldName = "";

    Camera2D camera = { 0 };
    camera.offset = (Vector2){ screenWidth/2.0f, screenHeight/2.0f };
    camera.target = (Vector2){ screenWidth/2.0f, screenHeight/2.0f };
    camera.rotation = 0.0f;
    camera.zoom = 1.1f;
    
    // 3D Camera Setup
    Camera3D camera3D = { 0 };
    camera3D.position = (Vector3){ 0.0f, 60.0f, 0.0f }; // Spawn high, gravity drops player to surface
    camera3D.target = (Vector3){ 0.0f, 60.0f, 1.0f };
    camera3D.up = (Vector3){ 0.0f, 1.0f, 0.0f };
    camera3D.fovy = 70.0f;
    camera3D.projection = CAMERA_PERSPECTIVE;
    
    // 3D Block Textures Setup
    Texture2D blockTextures[32] = {0};
    blockTextures[DIRT] = LoadTexture("assets/dirt.png");
    blockTextures[GRASS] = LoadTexture("assets/grass.png");
    blockTextures[COBBLESTONE] = LoadTexture("assets/cobblestone.png");
    blockTextures[LOG] = LoadTexture("assets/plank.png"); // Fallback for missing log.png
    blockTextures[LEAVES] = blockTextures[GRASS]; // Leaves share grass texture (tinted in render loop)
    blockTextures[PLANK] = LoadTexture("assets/plank.png");
    blockTextures[SAND] = LoadTexture("assets/sand.png");
    blockTextures[STONE] = LoadTexture("assets/stone.png");
    blockTextures[BEDROCK] = LoadTexture("assets/bedrock.png");
    blockTextures[DIAMOND_ORE] = LoadTexture("assets/diamond_ore.png");
    blockTextures[IRON_ORE] = LoadTexture("assets/iron_ore.png");
    blockTextures[GRAVEL] = LoadTexture("assets/gravel.png");
    
    // Grass needs separate top/side/bottom textures for correct look
    Texture2D grassTopTexture = LoadTexture("assets/grass_top.png");
    Texture2D craftingSideTexture = LoadTexture("assets/crafting_table_side.png");
    Texture2D craftingTopTexture = LoadTexture("assets/crafting_table_top.png");
    
    // Safety Fallback: Use Planks if custom textures failed to load (prevents crash)
    if (craftingSideTexture.id == 0) craftingSideTexture = blockTextures[PLANK];
    if (craftingTopTexture.id == 0) craftingTopTexture = blockTextures[PLANK];
    blockTextures[CRAFTING_TABLE] = craftingSideTexture; // Preview for inventory
    
    blockTextures[STICK] = LoadTexture("assets/stick.png");
    blockTextures[WOOD_AXE] = LoadTexture("assets/wooden_axe.png");
    
    // Explicitly check for successful load and print warning if fail
    if (blockTextures[STICK].id == 0) TraceLog(LOG_WARNING, "FAILED TO LOAD STICK TEXTURE");
    if (blockTextures[WOOD_AXE].id == 0) TraceLog(LOG_WARNING, "FAILED TO LOAD AXE TEXTURE");
    
    // Inventory Crafting State
    InventorySlot craftingSlots[4]; // Default to AIR/0
    InventorySlot craftingResult(AIR, 0);
    
    // Crafting Table State (3x3)
    InventorySlot tableSlots[9]; 
    InventorySlot tableResult(AIR, 0);

    auto UpdateCrafting = [&]() {
        // Recipe: 4 Planks -> 1 Crafting Table
        if (craftingSlots[0].blockType == PLANK && craftingSlots[1].blockType == PLANK &&
            craftingSlots[2].blockType == PLANK && craftingSlots[3].blockType == PLANK) {
            craftingResult = InventorySlot(CRAFTING_TABLE, 1);
        } 
        // Recipe: 2 Planks (vertical) -> 4 Sticks
        else if ((craftingSlots[0].blockType == PLANK && craftingSlots[2].blockType == PLANK) ||
                 (craftingSlots[1].blockType == PLANK && craftingSlots[3].blockType == PLANK)) {
            craftingResult = InventorySlot(STICK, 4);
        }
        else {
            craftingResult = InventorySlot(AIR, 0);
        }
    };
    
    auto UpdateTableCrafting = [&]() {
        // Wooden Axe Recipe
        // [P P .]
        // [P S .]
        // [. S .]
        if (tableSlots[0].blockType == PLANK && tableSlots[1].blockType == PLANK &&
            tableSlots[3].blockType == PLANK && tableSlots[4].blockType == STICK &&
            tableSlots[7].blockType == STICK) {
            tableResult = InventorySlot(WOOD_AXE, 1);
        }
        // Sticks (vertical anywhere)
        else if ((tableSlots[0].blockType == PLANK && tableSlots[3].blockType == PLANK) ||
                 (tableSlots[1].blockType == PLANK && tableSlots[4].blockType == PLANK) ||
                 (tableSlots[2].blockType == PLANK && tableSlots[5].blockType == PLANK) ||
                 (tableSlots[3].blockType == PLANK && tableSlots[6].blockType == PLANK) ||
                 (tableSlots[4].blockType == PLANK && tableSlots[7].blockType == PLANK) ||
                 (tableSlots[5].blockType == PLANK && tableSlots[8].blockType == PLANK)) {
            tableResult = InventorySlot(STICK, 4);
        }
        // 4 Planks -> 1 Table (3x3 grid)
        else if (tableSlots[0].blockType == PLANK && tableSlots[1].blockType == PLANK &&
                 tableSlots[3].blockType == PLANK && tableSlots[4].blockType == PLANK) {
            tableResult = InventorySlot(CRAFTING_TABLE, 1);
        }
        else {
            tableResult = InventorySlot(AIR, 0);
        }
    };
    // Block Selection State (for wireframe)
    bool hitBlock = false;
    int hitX = -1, hitY = -1, hitZ = -1;
    Vector3 closestNormal = {0};
    
    while (!WindowShouldClose())    // Detect window close button or ESC key
    {
        // Update
        //----------------------------------------------------------------------------------
        // Update ONLY active music streams and ensure others are fully stopped
        bool inGame = (currentState == GAMEPLAY || currentState == PAUSE_MENU || currentState == CRAFTING_GUI || (currentState == OPTIONS_MENU && optionsReturnState != MAIN_MENU));
        
        if (!inGame) {
            UpdateMusicStream(titleMusic);
            if (IsMusicStreamPlaying(gameplayMusic)) StopMusicStream(gameplayMusic);
            if (IsMusicStreamPlaying(nightMusic)) StopMusicStream(nightMusic);
        } else {
            UpdateMusicStream(gameplayMusic);
            UpdateMusicStream(nightMusic);
            if (IsMusicStreamPlaying(titleMusic)) StopMusicStream(titleMusic);
        }

        // --- NETWORK UPDATE ---
        if (isConnecting) {
            fd_set writefds;
            FD_ZERO(&writefds);
            FD_SET(clientSocket, &writefds);
            struct timeval tv = {0, 0};
            if (select((int)clientSocket + 1, NULL, &writefds, NULL, &tv) > 0) {
                isConnecting = false;
                currentState = GAMEPLAY;
                DisableCursor();
                // Send Handshake
                PacketHeader head = { (uint8_t)PACKET_HANDSHAKE, (uint32_t)sizeof(PacketHandshake) };
                PacketHandshake hand;
                strncpy(hand.name, playerName.c_str(), 31);
                send(clientSocket, (char*)&head, sizeof(head), 0);
                send(clientSocket, (char*)&hand, sizeof(hand), 0);
            }
        }
        
        // Handle incoming data
        auto handleIncoming = [&](Socket sock, bool isServer, int clientIdx = -1) {
            PacketHeader head;
            int bytes = recv(sock, (char*)&head, sizeof(head), 0);
            if (bytes > 0) {
                if (head.type == PACKET_HANDSHAKE) {
                    PacketHandshake hand;
                    recv(sock, (char*)&hand, sizeof(hand), 0);
                    if (isServer) {
                        RemotePlayer rp;
                        rp.sock = sock;
                        rp.name = hand.name;
                        rp.position = (Vector3){0,0,0};
                        remotePlayers.push_back(rp);
                        // Send seed to new client
                        PacketHeader sHead = { (uint8_t)PACKET_SEED_SYNC, (uint32_t)sizeof(PacketSeedSync) };
                        PacketSeedSync sData = { globalSeedHash };
                        send(sock, (char*)&sHead, sizeof(sHead), 0);
                        send(sock, (char*)&sData, sizeof(sData), 0);
                    }
                } else if (head.type == PACKET_PLAYER_UPDATE) {
                    PacketPlayerUpdate pu;
                    recv(sock, (char*)&pu, sizeof(pu), 0);
                    for (auto& rp : remotePlayers) {
                        if (rp.sock == sock) {
                            rp.position = (Vector3){ pu.x, pu.y, pu.z };
                            rp.yaw = pu.yaw;
                            break;
                        }
                    }
                    if (isServer) {
                        // Broadcast to others
                        for (auto& other : clientSockets) {
                            if (other != sock) {
                                send(other, (char*)&head, sizeof(head), 0);
                                send(other, (char*)&pu, sizeof(pu), 0);
                            }
                        }
                    }
                } else if (head.type == PACKET_BLOCK_CHANGE) {
                    PacketBlockChange bc;
                    recv(sock, (char*)&bc, sizeof(bc), 0);
                    SetBlock(bc.x, bc.y, bc.z, bc.blockType);
                    if (isServer) {
                        for (auto& other : clientSockets) {
                            if (other != sock) {
                                send(other, (char*)&head, sizeof(head), 0);
                                send(other, (char*)&bc, sizeof(bc), 0);
                            }
                        }
                    }
                } else if (head.type == PACKET_TIME_SYNC) {
                    PacketTimeSync ts;
                    recv(sock, (char*)&ts, sizeof(ts), 0);
                    if (!isServer) gameTime = ts.gameTime;
                } else if (head.type == PACKET_SEED_SYNC) {
                    PacketSeedSync ss;
                    recv(sock, (char*)&ss, sizeof(ss), 0);
                    if (!isServer) {
                        globalSeedHash = ss.seed;
                        // Regerate world if seed changed
                        for (auto& pair : worldChunks) delete pair.second;
                        worldChunks.clear();
                    }
                }
            } else if (bytes == 0 || (bytes < 0 && SOCKET_ERROR_VAL != -1)) {
                // Disconnect handling
                if (isServer && clientIdx != -1) {
                    for (auto it = remotePlayers.begin(); it != remotePlayers.end(); ++it) {
                        if (it->sock == sock) {
                            remotePlayers.erase(it);
                            break;
                        }
                    }
                    closesocket(sock);
                    clientSockets.erase(clientSockets.begin() + clientIdx);
                }
            }
        };

        if (clientSocket != INVALID_SOCKET_VAL && !isConnecting) {
            handleIncoming(clientSocket, false);
            // Send our position
            static float netTimer = 0.0f;
            netTimer += GetFrameTime();
            if (netTimer > 0.05f) { // 20Hz update
                PacketHeader head = { (uint8_t)PACKET_PLAYER_UPDATE, (uint32_t)sizeof(PacketPlayerUpdate) };
                PacketPlayerUpdate pu = { camera3D.position.x, camera3D.position.y - 1.6f, camera3D.position.z, camYaw, 0 };
                send(clientSocket, (char*)&head, sizeof(head), 0);
                send(clientSocket, (char*)&pu, sizeof(pu), 0);
                netTimer = 0.0f;
            }
        }
        
        if (serverSocket != INVALID_SOCKET_VAL) {
            struct sockaddr_in client_addr;
            socklen_t client_len = sizeof(client_addr);
            Socket newClient = accept(serverSocket, (struct sockaddr*)&client_addr, &client_len);
            if (newClient != INVALID_SOCKET_VAL) {
                SetNonBlocking(newClient);
                clientSockets.push_back(newClient);
            }
            for (size_t i = 0; i < clientSockets.size(); i++) {
                handleIncoming(clientSockets[i], true, i);
            }
            // Send time sync periodically
            static float timeSyncTimer = 0.0f;
            timeSyncTimer += GetFrameTime();
            if (timeSyncTimer > 2.0f) {
                PacketHeader head = { (uint8_t)PACKET_TIME_SYNC, (uint32_t)sizeof(PacketTimeSync) };
                PacketTimeSync ts = { gameTime };
                for (auto& s : clientSockets) {
                    send(s, (char*)&head, sizeof(head), 0);
                    send(s, (char*)&ts, sizeof(ts), 0);
                }
                timeSyncTimer = 0.0f;
            }
        }

        // Handle title music loop fading
        float fadeTime = 2.0f; // 2 seconds fade
        float timePlayed = GetMusicTimePlayed(titleMusic);
        float timeLength = GetMusicTimeLength(titleMusic);
        float titleLoopFade = 1.0f;

        if (timePlayed < fadeTime) {
            titleLoopFade = timePlayed / fadeTime;
        } else if (timeLength > 0.0f && (timeLength - timePlayed) < fadeTime) {
            titleLoopFade = (timeLength - timePlayed) / fadeTime;
        }
        
        // Handle crossfading based on state
        static float crossfade = 0.0f; // 0.0 = title, 1.0 = gameplay
        
        if (inGame) {
            crossfade += 0.02f;
            if (crossfade > 1.0f) crossfade = 1.0f;
        } else {
            crossfade -= 0.02f;
            if (crossfade < 0.0f) crossfade = 0.0f;
        }


        // --- GLOBAL TIME & AUDIO MANAGEMENT ---
        float cycleLength = 300.0f;
        if (currentState == GAMEPLAY) gameTime += GetFrameTime();
        float timeOfDay = fmodf(gameTime, cycleLength) / cycleLength;
        float sunAngle = timeOfDay * 2.0f * 3.14159f - 3.14159f/2.0f;
        float dayFactor = (sinf(sunAngle) + 1.0f) / 2.0f;
        float quickMix = (dayFactor - 0.5f) * 5.0f + 0.5f;
        if (quickMix > 1.0f) quickMix = 1.0f;
        if (quickMix < 0.0f) quickMix = 0.0f;

        SetMusicVolume(titleMusic, titleLoopFade * masterMusicVolume * (1.0f - crossfade));
        SetMusicVolume(gameplayMusic, masterMusicVolume * crossfade * quickMix);
        SetMusicVolume(nightMusic, masterMusicVolume * crossfade * (1.0f - quickMix));

        // Ensure gameplay streams are playing when crossfaded in
        if (crossfade > 0.01f) {
            if (!IsMusicStreamPlaying(gameplayMusic)) PlayMusicStream(gameplayMusic);
            if (!IsMusicStreamPlaying(nightMusic)) PlayMusicStream(nightMusic);
        }
        
        // Handle window resize dynamically
        int currentWidth = GetScreenWidth();
        int currentHeight = GetScreenHeight();
        
        camera.offset = (Vector2){ currentWidth/2.0f, currentHeight/2.0f };
        camera.target = (Vector2){ currentWidth/2.0f, currentHeight/2.0f };
        
        // Smooth camera zoom
        currentZoom += (targetZoom - currentZoom) * 0.05f;
        camera.zoom = currentZoom;
        
        // Gameplay Update
        if (currentState == GAMEPLAY) {
            gameTime += GetFrameTime();
            
            // Hotbar slot selection (keys 1-9)
            if (IsKeyPressed(KEY_ONE))   activeHotbarSlot = 0;
            if (IsKeyPressed(KEY_TWO))   activeHotbarSlot = 1;
            if (IsKeyPressed(KEY_THREE)) activeHotbarSlot = 2;
            if (IsKeyPressed(KEY_FOUR))  activeHotbarSlot = 3;
            if (IsKeyPressed(KEY_FIVE))  activeHotbarSlot = 4;
            if (IsKeyPressed(KEY_SIX))   activeHotbarSlot = 5;
            if (IsKeyPressed(KEY_SEVEN)) activeHotbarSlot = 6;
            if (IsKeyPressed(KEY_EIGHT)) activeHotbarSlot = 7;
            if (IsKeyPressed(KEY_NINE))  activeHotbarSlot = 8;
            
            // Scroll wheel cycles hotbar
            float scroll = GetMouseWheelMove();
            if (scroll > 0.0f) activeHotbarSlot = (activeHotbarSlot - 1 + 9) % 9;
            if (scroll < 0.0f) activeHotbarSlot = (activeHotbarSlot + 1) % 9;
            
            // Toggle inventory
            if (IsKeyPressed(KEY_E)) {
                inventoryOpen = !inventoryOpen;
                if (inventoryOpen) EnableCursor();
                else DisableCursor();
            }
            
            // Dynamic Chunk Loading
            int playerCX = (int)floorf(camera3D.position.x / CHUNK_SIZE);
            int playerCZ = (int)floorf(camera3D.position.z / CHUNK_SIZE);
            for (int x = playerCX - RENDER_DISTANCE; x <= playerCX + RENDER_DISTANCE; x++) {
                for (int z = playerCZ - RENDER_DISTANCE; z <= playerCZ + RENDER_DISTANCE; z++) {
                    GenerateChunk(x, z);
                }
            }

            // ---- Manual Camera System (Look + WASD) ----
            if (!inventoryOpen) {
                const float MOUSE_SENS = 0.002f;
                Vector2 md = GetMouseDelta();
                camYaw   -= md.x * MOUSE_SENS;
                camPitch -= md.y * MOUSE_SENS;
                if (camPitch >  1.5f) camPitch =  1.5f;
                if (camPitch < -1.5f) camPitch = -1.5f;
            }

            // Direction vectors (horizontal)
            Vector3 forward = { sinf(camYaw), 0, cosf(camYaw) };
            Vector3 right   = { cosf(camYaw), 0, -sinf(camYaw) };
            
            Vector3 oldPos = camera3D.position;
            Vector3 moveVec = { 0, 0, 0 };
            
            if (!inventoryOpen) {
                if (IsKeyDown(KEY_W)) moveVec = Vector3Add(moveVec, forward);
                if (IsKeyDown(KEY_S)) moveVec = Vector3Subtract(moveVec, forward);
                if (IsKeyDown(KEY_A)) moveVec = Vector3Add(moveVec, right);
                if (IsKeyDown(KEY_D)) moveVec = Vector3Subtract(moveVec, right);
            }
            
            if (Vector3Length(moveVec) > 0) {
                moveVec = Vector3Normalize(moveVec);
                float speed = 5.0f * GetFrameTime();
                
                Vector3 tryX = { oldPos.x + moveVec.x * speed, oldPos.y, oldPos.z };
                if (!CheckPlayerCollision(tryX)) camera3D.position.x = tryX.x;
                
                Vector3 tryZ = { camera3D.position.x, oldPos.y, oldPos.z + moveVec.z * speed };
                if (!CheckPlayerCollision(tryZ)) camera3D.position.z = tryZ.z;
            }

            // ---- Vertical Physics (Ground-Lock System) ----
            if (isGrounded) {
                playerVelocityY = 0.0f;
                
                // Keep player exactly on top of the block with a small epsilon
                float feetY = camera3D.position.y - 1.6f;
                float expectedFeetY = floorf(feetY + 0.1f) + 0.5f;
                camera3D.position.y = expectedFeetY + 1.6f + 0.01f;

                // Jump
                if (IsKeyPressed(KEY_SPACE) && !inventoryOpen) {
                    playerVelocityY = 8.5f;
                    isGrounded = false;
                } else {
                    // Check if we walked off an edge (use a generous 0.2f margin)
                    Vector3 checkBelow = camera3D.position;
                    checkBelow.y -= 0.2f; 
                    if (!CheckPlayerCollision(checkBelow)) isGrounded = false;
                }
            } else {
                // Falling / Jumping
                playerVelocityY -= 25.0f * GetFrameTime();
                float dy = playerVelocityY * GetFrameTime();
                
                Vector3 nextYPos = camera3D.position;
                nextYPos.y += dy;
                
                if (CheckPlayerCollision(nextYPos)) {
                    if (playerVelocityY < 0.0f) {
                        // Landed: Lock to surface
                        float feetY = nextYPos.y - 1.6f;
                        camera3D.position.y = floorf(feetY + 0.1f) + 0.5f + 1.6f + 0.01f;
                        playerVelocityY = 0.0f;
                        isGrounded = true;
                    } else {
                        // Hit ceiling
                        camera3D.position.y = ceilf(nextYPos.y + 0.1f) - 0.5f - 0.41f;
                        playerVelocityY = 0.0f;
                    }
                } else {
                    camera3D.position.y = nextYPos.y;
                }
            }
            
            // Final Camera state
            camera3D.target.x = camera3D.position.x + sinf(camYaw) * cosf(camPitch);
            camera3D.target.y = camera3D.position.y + sinf(camPitch);
            camera3D.target.z = camera3D.position.z + cosf(camYaw) * cosf(camPitch);
            camera3D.up = (Vector3){ 0, 1, 0 };

            
            // Block Raycasting (moved outside to update every frame for wireframe)
            hitBlock = false;
            if (!inventoryOpen) {
                Ray ray = GetMouseRay((Vector2){ (float)currentWidth / 2, (float)currentHeight / 2 }, camera3D);
                float closestDist = 8.0f;
                
                int startX = (int)floorf(camera3D.position.x - 8);
                int endX = (int)floorf(camera3D.position.x + 8);
                int startY = (int)floorf(camera3D.position.y - 8);
                int endY = (int)floorf(camera3D.position.y + 8);
                int startZ = (int)floorf(camera3D.position.z - 8);
                int endZ = (int)floorf(camera3D.position.z + 8);
                
                for (int x = startX; x <= endX; x++) {
                    for (int y = startY; y <= endY; y++) {
                        for (int z = startZ; z <= endZ; z++) {
                            if (GetBlock(x, y, z) != AIR) {
                                BoundingBox box = {
                                    (Vector3){ x - 0.5f, y - 0.5f, z - 0.5f },
                                    (Vector3){ x + 0.5f, y + 0.5f, z + 0.5f }
                                };
                                RayCollision collision = GetRayCollisionBox(ray, box);
                                if (collision.hit && collision.distance < closestDist) {
                                    closestDist = collision.distance;
                                    closestNormal = collision.normal;
                                    hitBlock = true;
                                    hitX = x; hitY = y; hitZ = z;
                                }
                            }
                        }
                    }
                }
                
                if (hitBlock) {
                    if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
                        if (hitX != lastHitX || hitY != lastHitY || hitZ != lastHitZ) {
                            breakProgress = 0.0f;
                            lastHitX = hitX; lastHitY = hitY; lastHitZ = hitZ;
                        }

                        int targetBlock = GetBlock(hitX, hitY, hitZ);
                        if (targetBlock != AIR && targetBlock != BEDROCK) {
                            float breakSpeed = 2.0f; // Seconds to break
                            
                            // Axe logic: Wood/Plank/Logs are faster
                            if (targetBlock == LOG || targetBlock == PLANK || targetBlock == CRAFTING_TABLE) {
                                if (hotbar[activeHotbarSlot].blockType == WOOD_AXE) breakSpeed = 0.5f; // Fast
                                else breakSpeed = 1.5f; // Normal
                            } else if (targetBlock == LEAVES) {
                                breakSpeed = 0.2f; // Very fast
                            }

                            breakProgress += GetFrameTime();
                            
                            // Digging sound timer
                            digSoundTimer += GetFrameTime();
                            if (digSoundTimer >= 0.35f) {
                                Sound* s = &digGrass;
                                if (targetBlock == LOG || targetBlock == PLANK) s = &digWood;
                                else if (targetBlock == STONE || targetBlock == COBBLESTONE) s = &digStone;
                                else if (targetBlock == SAND) s = &digSand;
                                PlaySound(*s);
                                digSoundTimer = 0.0f;
                                isSwinging = true;
                            }

                            if (breakProgress >= breakSpeed) {
                                AddToInventory(targetBlock);
                                NetSetBlock(hitX, hitY, hitZ, AIR);
                                breakProgress = 0.0f;
                                isSwinging = true; // Swing when finishing
                            }
                            
                            // Visual swing while mining
                            if (fmodf(breakProgress, 0.4f) < 0.1f) isSwinging = true;
                        }
                    } else {
                        breakProgress = 0.0f;
                    }
                    
                    if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) {
                        int targetBlock = GetBlock(hitX, hitY, hitZ);
                        if (targetBlock == CRAFTING_TABLE) {
                            currentState = CRAFTING_GUI;
                            EnableCursor();
                        } else if (hotbar[activeHotbarSlot].count > 0) {
                            int placeX = hitX + (int)roundf(closestNormal.x);
                            int placeY = hitY + (int)roundf(closestNormal.y);
                            int placeZ = hitZ + (int)roundf(closestNormal.z);
                            NetSetBlock(placeX, placeY, placeZ, hotbar[activeHotbarSlot].blockType);
                            hotbar[activeHotbarSlot].count--;
                            if (hotbar[activeHotbarSlot].count == 0)
                                hotbar[activeHotbarSlot].blockType = AIR;
                            isSwinging = true; // Swing when placing
                        }
                    }
                }
            }
            
            if (IsKeyPressed(KEY_ESCAPE)) {
                if (inventoryOpen) {
                    inventoryOpen = false;
                    DisableCursor();
                } else {
                    currentState = PAUSE_MENU;
                    EnableCursor();
                }
            }
        }
        
        // Text Input Logic
        if (currentState == CREATE_WORLD_MENU) {
            if (activeTextBox > 0) {
                int key = GetCharPressed();
                while (key > 0) {
                    if ((key >= 32) && (key <= 125)) { // printable characters
                        if (activeTextBox == 1 && worldNameLen < 63) {
                            worldName[worldNameLen] = (char)key;
                            worldName[worldNameLen + 1] = '\0';
                            worldNameLen++;
                        } else if (activeTextBox == 2 && worldSeedLen < 63) {
                            worldSeed[worldSeedLen] = (char)key;
                            worldSeed[worldSeedLen + 1] = '\0';
                            worldSeedLen++;
                        }
                    }
                    key = GetCharPressed();
                }
                
                if (IsKeyPressed(KEY_BACKSPACE)) {
                    if (activeTextBox == 1 && worldNameLen > 0) {
                        worldNameLen--;
                        worldName[worldNameLen] = '\0';
                    } else if (activeTextBox == 2 && worldSeedLen > 0) {
                        worldSeedLen--;
                        worldSeed[worldSeedLen] = '\0';
                    }
                }
            }
        }
        //----------------------------------------------------------------------------------

        // Draw
        //----------------------------------------------------------------------------------
        BeginDrawing();

            ClearBackground(BLACK);
            Vector2 mousePos = GetMousePosition();

            if (currentState == CHECKING_UPDATES) {
                updateTimer += GetFrameTime();
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 20, 20, 20, 255 });
                DrawTextEx(customFont, "CHECKING FOR UPDATES...", (Vector2){ (float)currentWidth/2 - 150, (float)currentHeight/2 - 20 }, 24, 1.0f, WHITE);
                
                // Perform real check after 1 second
                if (updateTimer > 1.0f && latestVersion == "") {
                    latestVersion = GetRemoteVersion();
                    if (latestVersion != "error" && latestVersion != localVersion) {
                        updateReady = true;
                    }
                }
                
                if (updateTimer > 2.0f) {
                    if (updateReady) currentState = UPDATE_FOUND;
                    else currentState = MAIN_MENU;
                }
            } else if (currentState == UPDATE_FOUND) {
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 220 });
                int pw = 450, ph = 250;
                Rectangle pBox = { (float)currentWidth/2 - pw/2, (float)currentHeight/2 - ph/2, (float)pw, (float)ph };
                DrawRectangleRec(pBox, (Color){ 40, 40, 40, 255 });
                DrawRectangleLinesEx(pBox, 4.0f, GREEN);
                
                DrawTextEx(customFont, "NEW VERSION AVAILABLE!", (Vector2){ pBox.x + 40, pBox.y + 30 }, 24, 1.0f, GREEN);
                std::string updMsg = latestVersion + " is now ready for download.";
                DrawTextEx(customFont, updMsg.c_str(), (Vector2){ pBox.x + 40, pBox.y + 70 }, 18, 1.0f, LIGHTGRAY);
                
                // Update Button
                Rectangle updBtn = { pBox.x + 40, pBox.y + 120, 370, 40 };
                bool isUpdHovered = CheckCollisionPointRec(mousePos, updBtn);
                DrawRectangleRec(updBtn, isUpdHovered ? GREEN : (Color){ 0, 100, 0, 255 });
                DrawTextEx(customFont, "UPDATE NOW", (Vector2){ updBtn.x + 100, updBtn.y + 10 }, 20, 1.0f, WHITE);
                if (isUpdHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) currentState = DOWNLOADING_UPDATE;
                
                // Update Notes Button
                Rectangle noteBtn = { pBox.x + 40, pBox.y + 175, 370, 40 };
                bool isNoteHovered = CheckCollisionPointRec(mousePos, noteBtn);
                DrawRectangleRec(noteBtn, isNoteHovered ? DARKGRAY : BLACK);
                DrawRectangleLinesEx(noteBtn, 2.0f, GRAY);
                DrawTextEx(customFont, "VIEW UPDATE NOTES", (Vector2){ noteBtn.x + 65, noteBtn.y + 10 }, 20, 1.0f, WHITE);
                if (isNoteHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) currentState = UPDATE_NOTES;

            } else if (currentState == DOWNLOADING_UPDATE) {
                downloadProgress += 0.005f;
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 20, 20, 20, 255 });
                DrawTextEx(customFont, "DOWNLOADING UPDATE...", (Vector2){ (float)currentWidth/2 - 150, (float)currentHeight/2 - 40 }, 24, 1.0f, WHITE);
                
                // Progress Bar
                int bw = 400, bh = 30;
                DrawRectangle(currentWidth/2 - bw/2, currentHeight/2, bw, bh, BLACK);
                DrawRectangle(currentWidth/2 - bw/2, currentHeight/2, (int)(bw * downloadProgress), bh, GREEN);
                DrawRectangleLines(currentWidth/2 - bw/2, currentHeight/2, bw, bh, GRAY);
                
                if (downloadProgress >= 1.0f) {
                    // Simulate restart
                    currentState = MAIN_MENU;
                    updateReady = false;
                }
            } else if (currentState == CONNECT_MENU) {
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 220 });
                int cw = 500, ch = 350;
                Rectangle cBox = { (float)currentWidth/2 - cw/2, (float)currentHeight/2 - ch/2, (float)cw, (float)ch };
                DrawRectangleRec(cBox, (Color){ 30, 30, 30, 255 });
                DrawRectangleLinesEx(cBox, 4.0f, DARKGRAY);
                
                DrawTextEx(customFont, "DIRECT CONNECT", (Vector2){ cBox.x + 110, cBox.y + 30 }, 28, 1.0f, WHITE);
                
                // IP Address Input
                DrawTextEx(customFont, "Server IP Address:", (Vector2){ cBox.x + 50, cBox.y + 90 }, 20, 1.0f, LIGHTGRAY);
                Rectangle ipRect = { cBox.x + 50, cBox.y + 120, 400, 40 };
                bool isIPHovered = CheckCollisionPointRec(mousePos, ipRect);
                DrawRectangleRec(ipRect, (activeNetField == 1) ? BLACK : (isIPHovered ? (Color){ 50, 50, 50, 255 } : (Color){ 40, 40, 40, 255 }));
                DrawRectangleLinesEx(ipRect, 2, (activeNetField == 1) ? GREEN : GRAY);
                DrawTextEx(customFont, targetIP, (Vector2){ ipRect.x + 10, ipRect.y + 10 }, 20, 1.0f, WHITE);
                if (isIPHovered && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) activeNetField = 1;

                // Port Input
                DrawTextEx(customFont, "Server Port:", (Vector2){ cBox.x + 50, cBox.y + 180 }, 20, 1.0f, LIGHTGRAY);
                Rectangle portRect = { cBox.x + 50, cBox.y + 210, 150, 40 };
                bool isPortHovered = CheckCollisionPointRec(mousePos, portRect);
                DrawRectangleRec(portRect, (activeNetField == 2) ? BLACK : (isPortHovered ? (Color){ 50, 50, 50, 255 } : (Color){ 40, 40, 40, 255 }));
                DrawRectangleLinesEx(portRect, 2, (activeNetField == 2) ? GREEN : GRAY);
                DrawTextEx(customFont, targetPort, (Vector2){ portRect.x + 10, portRect.y + 10 }, 20, 1.0f, WHITE);
                if (isPortHovered && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) activeNetField = 2;

                // Input handling for IP/Port
                int key = GetCharPressed();
                while (key > 0) {
                    if (activeNetField == 1 && strlen(targetIP) < 127) {
                        int len = strlen(targetIP);
                        targetIP[len] = (char)key;
                        targetIP[len+1] = '\0';
                    } else if (activeNetField == 2 && strlen(targetPort) < 15) {
                        int len = strlen(targetPort);
                        targetPort[len] = (char)key;
                        targetPort[len+1] = '\0';
                    }
                    key = GetCharPressed();
                }
                if (IsKeyPressed(KEY_BACKSPACE)) {
                    if (activeNetField == 1) {
                        int len = strlen(targetIP);
                        if (len > 0) targetIP[len-1] = '\0';
                    } else if (activeNetField == 2) {
                        int len = strlen(targetPort);
                        if (len > 0) targetPort[len-1] = '\0';
                    }
                }

                // Join Button Logic
                Rectangle joinBtn = { cBox.x + 50, cBox.y + 280, 180, 45 };
                bool isJoinHovered = CheckCollisionPointRec(mousePos, joinBtn);
                DrawRectangleRec(joinBtn, isJoinHovered ? GREEN : (Color){ 0, 120, 0, 255 });
                DrawTextEx(customFont, "JOIN SERVER", (Vector2){ joinBtn.x + 25, joinBtn.y + 12 }, 20, 1.0f, WHITE);
                
                if (isJoinHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    clientSocket = socket(AF_INET, SOCK_STREAM, 0);
                    if (clientSocket != INVALID_SOCKET_VAL) {
                        SetNonBlocking(clientSocket);
                        struct sockaddr_in serv_addr;
                        serv_addr.sin_family = AF_INET;
                        serv_addr.sin_port = htons(atoi(targetPort));
                        inet_pton(AF_INET, targetIP, &serv_addr.sin_addr);
                        
                        connect(clientSocket, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
                        isConnecting = true;
                    }
                }
                
                // Cancel Button
                Rectangle cancelBtn = { cBox.x + 270, cBox.y + 280, 180, 45 };
                bool isCancelHovered = CheckCollisionPointRec(mousePos, cancelBtn);
                DrawRectangleRec(cancelBtn, isCancelHovered ? RED : (Color){ 120, 0, 0, 255 });
                DrawTextEx(customFont, "CANCEL", (Vector2){ cancelBtn.x + 55, cancelBtn.y + 12 }, 20, 1.0f, WHITE);
                if (isCancelHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    currentState = MAIN_MENU;
                    activeNetField = 0;
                }

            } else if (currentState != GAMEPLAY) {
                BeginMode2D(camera);
                    // Draw the texture, scaling it to fit the current window size exactly
                    Rectangle sourceRec = { 0.0f, 0.0f, (float)titleTexture.width, (float)titleTexture.height };
                    Rectangle destRec = { (float)currentWidth/2.0f, (float)currentHeight/2.0f, (float)currentWidth, (float)currentHeight };
                    Vector2 origin = { (float)currentWidth/2.0f, (float)currentHeight/2.0f };
                    
                    DrawTexturePro(titleTexture, sourceRec, destRec, origin, 0.0f, WHITE);
                EndMode2D();
                
                // Show Version Number (v2.0.1) in Red
                DrawTextEx(customFont, "v2.0.1", (Vector2){ (float)currentWidth - 140, (float)currentHeight - 40 }, 22, 1.0f, RED);
                
                // --- PLAYER NAME POPUP (IF MISSING) ---
                if (playerName == "") {
                    DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 200 });
                    int nw = 400, nh = 200;
                    Rectangle nBox = { (float)currentWidth/2 - nw/2, (float)currentHeight/2 - nh/2, (float)nw, (float)nh };
                    DrawRectangleRec(nBox, (Color){ 40, 40, 40, 255 });
                    DrawRectangleLinesEx(nBox, 2.0f, WHITE);
                    DrawTextEx(customFont, "Enter Your Name", (Vector2){ nBox.x + 20, nBox.y + 20 }, 24, 1.0f, WHITE);
                    
                    static char inputName[32] = {0};
                    int c = GetCharPressed();
                    while (c > 0) {
                        if (c >= 32 && c <= 125 && strlen(inputName) < 30) {
                            int len = strlen(inputName);
                            inputName[len] = (char)c;
                            inputName[len+1] = '\0';
                        }
                        c = GetCharPressed();
                    }
                    if (IsKeyPressed(KEY_BACKSPACE)) {
                        int len = strlen(inputName);
                        if (len > 0) inputName[len-1] = '\0';
                    }
                    
                    DrawRectangle(nBox.x + 20, nBox.y + 60, nw - 40, 40, BLACK);
                    DrawTextEx(customFont, inputName, (Vector2){ nBox.x + 30, nBox.y + 70 }, 20, 1.0f, WHITE);
                    
                    if (IsKeyPressed(KEY_ENTER) && strlen(inputName) > 0) {
                        playerName = inputName;
                        SaveConfig();
                    }
                }
            }


            
            if (currentState == MAIN_MENU) {
                targetZoom = 1.1f;
                
                // ONLY show buttons if name is entered
                if (playerName != "") {
                    // UI Buttons
                    const char* buttons[] = { "Create World", "Load World", "Connect", "Options" };
                int numButtons = 4;
                int buttonWidth = 400;
                int buttonHeight = 60;
                int buttonSpacing = 15;
                int fontSize = 24;
                
                // Calculate starting Y position to center buttons in the lower half of the screen
                int totalHeight = numButtons * buttonHeight + (numButtons - 1) * buttonSpacing;
                int startY = (currentHeight * 0.75f) - (totalHeight / 2);
                
                for (int i = 0; i < numButtons; i++) {
                    int posX = (currentWidth / 2) - (buttonWidth / 2);
                    int posY = startY + i * (buttonHeight + buttonSpacing);
                    
                    Rectangle btnBounds = { (float)posX, (float)posY, (float)buttonWidth, (float)buttonHeight };
                    bool isHovered = CheckCollisionPointRec(mousePos, btnBounds);
                    
                    // Draw Button Box
                    Color baseColor = isHovered ? (Color){ 100, 100, 100, 255 } : (Color){ 60, 60, 60, 255 };
                    Color borderColor = isHovered ? (Color){ 200, 200, 200, 255 } : (Color){ 20, 20, 20, 255 };
                    
                    DrawRectangleRec(btnBounds, baseColor);
                    DrawRectangleLinesEx(btnBounds, 3.0f, borderColor);
                    
                    if (isHovered) {
                        DrawRectangleLinesEx((Rectangle){btnBounds.x - 2, btnBounds.y - 2, btnBounds.width + 4, btnBounds.height + 4}, 2.0f, (Color){255, 255, 255, 50});
                        
                        // Handle click
                        if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                            if (i == 0) { // Create World button
                                currentState = CREATE_WORLD_MENU;
                            } else if (i == 1) { // Load World button
                                currentState = LOAD_WORLD_MENU;
                            } else if (i == 2) { // Connect button
                                // Future: Open Direct Connect UI
                            } else if (i == 3) { // Options button
                                optionsReturnState = MAIN_MENU;
                                currentState = OPTIONS_MENU;
                            }
                        }
                    }
                    
                    Vector2 textSize = MeasureTextEx(customFont, buttons[i], fontSize, 1.0f);
                    int textPosX = posX + (buttonWidth / 2) - (textSize.x / 2);
                    int textPosY = posY + (buttonHeight / 2) - (textSize.y / 2);
                    
                    DrawTextEx(customFont, buttons[i], (Vector2){ (float)textPosX + 2, (float)textPosY + 2 }, fontSize, 1.0f, (Color){ 30, 30, 30, 255 });
                    Color textColor = isHovered ? (Color){ 255, 255, 160, 255 } : (Color){ 220, 220, 220, 255 };
                    DrawTextEx(customFont, buttons[i], (Vector2){ (float)textPosX, (float)textPosY }, fontSize, 1.0f, textColor);
                }
                }
            } else if (currentState == LOAD_WORLD_MENU) {
                targetZoom = 1.0f;
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 180 });
                
                int panelWidth = 600;
                int panelHeight = 500;
                int panelX = (currentWidth / 2) - (panelWidth / 2);
                int panelY = (currentHeight / 2) - (panelHeight / 2);
                
                DrawRectangle(panelX, panelY, panelWidth, panelHeight, (Color){ 40, 40, 40, 240 });
                DrawRectangleLinesEx((Rectangle){ (float)panelX, (float)panelY, (float)panelWidth, (float)panelHeight }, 4.0f, (Color){ 100, 100, 100, 255 });
                DrawTextEx(customFont, "Load World", (Vector2){ (float)panelX + 20, (float)panelY + 20 }, 32, 1.0f, WHITE);
                
                // List saves
                std::vector<std::string> savedWorlds;
                if (std::filesystem::exists("saves")) {
                    for (const auto& entry : std::filesystem::directory_iterator("saves")) {
                        if (entry.is_directory()) {
                            savedWorlds.push_back(entry.path().filename().string());
                        }
                    }
                }
                
                if (savedWorlds.empty()) {
                    DrawTextEx(customFont, "No saved worlds found.", (Vector2){ (float)panelX + 40, (float)panelY + 100 }, 20, 1.0f, LIGHTGRAY);
                } else {
                    for (size_t i = 0; i < savedWorlds.size() && i < 5; i++) {
                        Rectangle worldBtn = { (float)panelX + 40, (float)panelY + 100 + (float)(i * 60), 520, 50 };
                        
                        Rectangle deleteBtn = { worldBtn.x + worldBtn.width - 50, worldBtn.y + 5, 40, 40 };
                        bool isDeleteHovered = CheckCollisionPointRec(mousePos, deleteBtn);
                        bool isHovered = CheckCollisionPointRec(mousePos, worldBtn) && !isDeleteHovered;
                        
                        DrawRectangleRec(worldBtn, isHovered ? (Color){ 80, 80, 80, 255 } : DARKGRAY);
                        DrawRectangleLinesEx(worldBtn, 2.0f, isHovered ? WHITE : GRAY);
                        DrawTextEx(customFont, savedWorlds[i].c_str(), (Vector2){ worldBtn.x + 10, worldBtn.y + 15 }, 20, 1.0f, WHITE);
                        
                        // Draw delete button
                        DrawRectangleRec(deleteBtn, isDeleteHovered ? RED : MAROON);
                        DrawRectangleLinesEx(deleteBtn, 2.0f, isDeleteHovered ? WHITE : GRAY);
                        DrawTextEx(customFont, "X", (Vector2){ deleteBtn.x + 13, deleteBtn.y + 10 }, 20, 1.0f, WHITE);
                        
                        if (!showDeleteConfirm) {
                            if (isDeleteHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                                deletingWorldName = savedWorlds[i];
                                showDeleteConfirm = true;
                            } else if (isHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                                // Load this world
                            currentWorldName = savedWorlds[i];
                            
                            // Load seed and player position from world.dat
                            std::ifstream worldFile("saves/" + currentWorldName + "/world.dat");
                            float savedX = 0.0f, savedY = -1.0f, savedZ = 0.0f;
                            if (worldFile.is_open()) {
                                worldFile >> globalSeedHash >> savedX >> savedY >> savedZ;
                                worldFile.close();
                            } else {
                                globalSeedHash = 12345;
                            }
                            
                            // Clear old chunks just in case
                            for (auto& pair : worldChunks) {
                                delete pair.second;
                            }
                            worldChunks.clear();
                            
                            if (serverMode) {
                                serverSocket = socket(AF_INET, SOCK_STREAM, 0);
                                if (serverSocket != INVALID_SOCKET_VAL) {
                                    SetNonBlocking(serverSocket);
                                    struct sockaddr_in serv_addr;
                                    serv_addr.sin_family = AF_INET;
                                    serv_addr.sin_addr.s_addr = INADDR_ANY;
                                    serv_addr.sin_port = htons(12345);
                                    bind(serverSocket, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
                                    listen(serverSocket, 5);
                                }
                            }
                            
                            currentState = GAMEPLAY;
                            DisableCursor();
                            inventoryOpen = false;
                            
                            // Restore saved position, or find surface if no save
                            float spawnY;
                            if (savedY > 0.0f) {
                                spawnY = savedY;
                            } else {
                                spawnY = FindSpawnY((int)savedX, (int)savedZ);
                            }
                            camera3D.position = (Vector3){ savedX, spawnY, savedZ };
                            camera3D.target   = (Vector3){ savedX, spawnY, savedZ + 1.0f };
                            playerVelocityY = 0.0f;
                            camYaw = 0.0f; camPitch = 0.0f;
                            
                            // Load inventory from disk
                            std::ifstream invf("saves/" + currentWorldName + "/inventory.dat", std::ios::binary);
                            if (invf.is_open()) {
                                invf.read((char*)hotbar,    sizeof(hotbar));
                                invf.read((char*)inventory,  sizeof(inventory));
                                invf.read((char*)&activeHotbarSlot, sizeof(activeHotbarSlot));
                                invf.close();
                            }
                            
                            // Pre-generate all chunks around spawn so world appears immediately
                            int spawnCX = (int)floorf(savedX / CHUNK_SIZE);
                            int spawnCZ = (int)floorf(savedZ / CHUNK_SIZE);
                            for (int cx = spawnCX - RENDER_DISTANCE; cx <= spawnCX + RENDER_DISTANCE; cx++)
                                for (int cz = spawnCZ - RENDER_DISTANCE; cz <= spawnCZ + RENDER_DISTANCE; cz++)
                                    GenerateChunk(cx, cz);
                        }
                        }
                    }
                }
                
                // Back Button
                int btnWidth = 200;
                int btnHeight = 50;
                int backBtnX = panelX + (panelWidth / 2) - (btnWidth / 2);
                int btnY = panelY + panelHeight - 80;
                
                Rectangle backBtnBounds = { (float)backBtnX, (float)btnY, (float)btnWidth, (float)btnHeight };
                bool isBackHovered = CheckCollisionPointRec(mousePos, backBtnBounds);
                DrawRectangleRec(backBtnBounds, isBackHovered ? (Color){ 100, 100, 100, 255 } : (Color){ 60, 60, 60, 255 });
                DrawRectangleLinesEx(backBtnBounds, 3.0f, isBackHovered ? WHITE : GRAY);
                Vector2 backTextSize = MeasureTextEx(customFont, "Back", 20, 1.0f);
                DrawTextEx(customFont, "Back", (Vector2){ backBtnX + (btnWidth/2) - (backTextSize.x/2), btnY + (btnHeight/2) - (backTextSize.y/2) }, 20, 1.0f, WHITE);
                
                if (!showDeleteConfirm) {
                    if (isBackHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                        currentState = MAIN_MENU;
                    }
                }
                
                // Draw Confirmation Overlay
                if (showDeleteConfirm) {
                    DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 200 });
                    
                    int confWidth = 400;
                    int confHeight = 200;
                    int confX = (currentWidth / 2) - (confWidth / 2);
                    int confY = (currentHeight / 2) - (confHeight / 2);
                    
                    DrawRectangle(confX, confY, confWidth, confHeight, (Color){ 50, 20, 20, 255 });
                    DrawRectangleLinesEx((Rectangle){ (float)confX, (float)confY, (float)confWidth, (float)confHeight }, 4.0f, RED);
                    
                    Vector2 warnSize = MeasureTextEx(customFont, "Delete World?", 24, 1.0f);
                    DrawTextEx(customFont, "Delete World?", (Vector2){ confX + (confWidth/2) - (warnSize.x/2), confY + 30 }, 24, 1.0f, WHITE);
                    
                    std::string warnText = "Delete '" + deletingWorldName + "'?";
                    Vector2 nameSize = MeasureTextEx(customFont, warnText.c_str(), 20, 1.0f);
                    DrawTextEx(customFont, warnText.c_str(), (Vector2){ confX + (confWidth/2) - (nameSize.x/2), confY + 70 }, 20, 1.0f, LIGHTGRAY);
                    
                    // Yes Button
                    Rectangle yesBtn = { (float)confX + 50, (float)confY + 130, 120, 40 };
                    bool isYesHovered = CheckCollisionPointRec(mousePos, yesBtn);
                    DrawRectangleRec(yesBtn, isYesHovered ? RED : MAROON);
                    DrawRectangleLinesEx(yesBtn, 2.0f, isYesHovered ? WHITE : GRAY);
                    DrawTextEx(customFont, "YES", (Vector2){ yesBtn.x + 40, yesBtn.y + 10 }, 20, 1.0f, WHITE);
                    
                    // No Button
                    Rectangle noBtn = { (float)confX + confWidth - 170, (float)confY + 130, 120, 40 };
                    bool isNoHovered = CheckCollisionPointRec(mousePos, noBtn);
                    DrawRectangleRec(noBtn, isNoHovered ? (Color){ 100, 100, 100, 255 } : DARKGRAY);
                    DrawRectangleLinesEx(noBtn, 2.0f, isNoHovered ? WHITE : GRAY);
                    DrawTextEx(customFont, "NO", (Vector2){ noBtn.x + 45, noBtn.y + 10 }, 20, 1.0f, WHITE);
                    
                    if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                        if (isYesHovered) {
                            std::filesystem::remove_all("saves/" + deletingWorldName);
                            showDeleteConfirm = false;
                        } else if (isNoHovered) {
                            showDeleteConfirm = false;
                        }
                    }
                }
            } else if (currentState == OPTIONS_MENU) {
                targetZoom = 1.0f;
                
                // Draw dark overlay
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 180 });
                
                // Draw options panel
                int panelWidth = 600;
                int panelHeight = 480; // Increased from 400
                int panelX = (currentWidth / 2) - (panelWidth / 2);
                int panelY = (currentHeight / 2) - (panelHeight / 2);
                
                DrawRectangle(panelX, panelY, panelWidth, panelHeight, (Color){ 40, 40, 40, 240 });
                DrawRectangleLinesEx((Rectangle){ (float)panelX, (float)panelY, (float)panelWidth, (float)panelHeight }, 4.0f, (Color){ 100, 100, 100, 255 });
                
                // Title
                DrawTextEx(customFont, "Options", (Vector2){ (float)panelX + 20, (float)panelY + 20 }, 32, 1.0f, WHITE);
                
                // Music Volume Slider
                DrawTextEx(customFont, "Music Volume", (Vector2){ (float)panelX + 40, (float)panelY + 100 }, 20, 1.0f, LIGHTGRAY);
                Rectangle musicSliderBar = { (float)panelX + 40, (float)panelY + 140, 520, 20 };
                DrawRectangleRec(musicSliderBar, DARKGRAY);
                
                Rectangle musicHandle = { musicSliderBar.x + (masterMusicVolume * (musicSliderBar.width - 20)), musicSliderBar.y - 10, 20, 40 };
                
                if (CheckCollisionPointRec(mousePos, (Rectangle){musicSliderBar.x, musicSliderBar.y - 20, musicSliderBar.width, 60})) {
                    if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
                        masterMusicVolume = (mousePos.x - musicSliderBar.x) / (musicSliderBar.width - 20);
                        if (masterMusicVolume < 0.0f) masterMusicVolume = 0.0f;
                        if (masterMusicVolume > 1.0f) masterMusicVolume = 1.0f;
                    }
                }
                DrawRectangleRec(musicHandle, LIGHTGRAY);
                DrawRectangleLinesEx(musicHandle, 2.0f, WHITE);
                
                // Sound Volume Slider
                DrawTextEx(customFont, "Sound Volume", (Vector2){ (float)panelX + 40, (float)panelY + 200 }, 20, 1.0f, LIGHTGRAY);
                Rectangle soundSliderBar = { (float)panelX + 40, (float)panelY + 240, 520, 20 };
                DrawRectangleRec(soundSliderBar, DARKGRAY);
                
                Rectangle soundHandle = { soundSliderBar.x + (masterSoundVolume * (soundSliderBar.width - 20)), soundSliderBar.y - 10, 20, 40 };
                
                if (CheckCollisionPointRec(mousePos, (Rectangle){soundSliderBar.x, soundSliderBar.y - 20, soundSliderBar.width, 60})) {
                    if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) {
                        masterSoundVolume = (mousePos.x - soundSliderBar.x) / (soundSliderBar.width - 20);
                        if (masterSoundVolume < 0.0f) masterSoundVolume = 0.0f;
                        if (masterSoundVolume > 1.0f) masterSoundVolume = 1.0f;
                    }
                }
                DrawRectangleRec(soundHandle, LIGHTGRAY);
                DrawRectangleLinesEx(soundHandle, 2.0f, WHITE);
                
                // Multiplayer Options
                DrawTextEx(customFont, "Multiplayer", (Vector2){ (float)panelX + 40, (float)panelY + 290 }, 20, 1.0f, LIGHTGRAY);
                Rectangle serverCheck = { (float)panelX + 40, (float)panelY + 320, 20, 20 };
                bool isServerHovered = CheckCollisionPointRec(mousePos, serverCheck);
                DrawRectangleRec(serverCheck, serverMode ? GREEN : DARKGRAY);
                DrawRectangleLinesEx(serverCheck, 2.0f, isServerHovered ? WHITE : GRAY);
                DrawTextEx(customFont, "Server Mode (Experimental)", (Vector2){ serverCheck.x + 35, serverCheck.y }, 18, 1.0f, WHITE);
                
                // Connect Button
                Rectangle connBtn = { (float)currentWidth/2 - 100, (float)currentHeight/2 + 70, 200, 40 };
                bool isConnHovered = CheckCollisionPointRec(mousePos, connBtn);
                DrawRectangleRec(connBtn, isConnHovered ? DARKGRAY : BLACK);
                DrawRectangleLinesEx(connBtn, 2, GRAY);
                DrawTextEx(customFont, "CONNECT", (Vector2){ connBtn.x + 50, connBtn.y + 10 }, 20, 1.0f, WHITE);
                if (isConnHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    currentState = CONNECT_MENU;
                }
                
                if (isServerHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    serverMode = !serverMode;
                    SaveConfig();
                }
                
                // Done Button
                int backBtnWidth = 200;
                int backBtnHeight = 50;
                int backBtnX = panelX + (panelWidth / 2) - (backBtnWidth / 2);
                int backBtnY = panelY + panelHeight - 80;
                
                Rectangle backBtnBounds = { (float)backBtnX, (float)backBtnY, (float)backBtnWidth, (float)backBtnHeight };
                bool isBackHovered = CheckCollisionPointRec(mousePos, backBtnBounds);
                
                Color backBaseColor = isBackHovered ? (Color){ 100, 100, 100, 255 } : (Color){ 60, 60, 60, 255 };
                DrawRectangleRec(backBtnBounds, backBaseColor);
                DrawRectangleLinesEx(backBtnBounds, 3.0f, isBackHovered ? WHITE : GRAY);
                
                Vector2 backTextSize = MeasureTextEx(customFont, "Done", 20, 1.0f);
                DrawTextEx(customFont, "Done", (Vector2){ backBtnX + (backBtnWidth/2) - (backTextSize.x/2), backBtnY + (backBtnHeight/2) - (backTextSize.y/2) }, 20, 1.0f, WHITE);
                
                if (isBackHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    currentState = optionsReturnState;
                }
            } else if (currentState == UPDATE_NOTES) {
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 200 });
                int pw = 700, ph = 500;
                Rectangle pBox = { (float)currentWidth/2 - pw/2, (float)currentHeight/2 - ph/2, (float)pw, (float)ph };
                DrawRectangleRec(pBox, (Color){ 40, 40, 40, 255 });
                DrawRectangleLinesEx(pBox, 4.0f, DARKGRAY);
                
                DrawTextEx(customFont, "Update Notes", (Vector2){ pBox.x + 20, pBox.y + 20 }, 28, 1.0f, YELLOW);
                
                // Close Button (X)
                Rectangle xBtn = { pBox.x + pBox.width - 40, pBox.y + 10, 30, 30 };
                bool isXHovered = CheckCollisionPointRec(mousePos, xBtn);
                DrawRectangleRec(xBtn, isXHovered ? RED : MAROON);
                DrawTextEx(customFont, "X", (Vector2){ xBtn.x + 8, xBtn.y + 5 }, 20, 1.0f, WHITE);
                if (isXHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) currentState = MAIN_MENU;

                // Mock Markdown content
                DrawTextEx(customFont, "v1.9.0 Release Notes:", (Vector2){ pBox.x + 30, pBox.y + 80 }, 20, 1.0f, WHITE);
                DrawTextEx(customFont, "- Fixed Frustum Culling gaps", (Vector2){ pBox.x + 40, pBox.y + 110 }, 18, 1.0f, LIGHTGRAY);
                DrawTextEx(customFont, "- Added Auto-Update System", (Vector2){ pBox.x + 40, pBox.y + 140 }, 18, 1.0f, LIGHTGRAY);
                DrawTextEx(customFont, "- Added Player Identity requirement", (Vector2){ pBox.x + 40, pBox.y + 170 }, 18, 1.0f, LIGHTGRAY);
                DrawTextEx(customFont, "- Improved audio stability", (Vector2){ pBox.x + 40, pBox.y + 200 }, 18, 1.0f, LIGHTGRAY);

            } else if (currentState == CREATE_WORLD_MENU) {
                targetZoom = 1.0f;
                
                // Draw dark overlay
                DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 180 });
                
                // Draw Create World panel
                int panelWidth = 600;
                int panelHeight = 500;
                int panelX = (currentWidth / 2) - (panelWidth / 2);
                int panelY = (currentHeight / 2) - (panelHeight / 2);
                
                DrawRectangle(panelX, panelY, panelWidth, panelHeight, (Color){ 40, 40, 40, 240 });
                DrawRectangleLinesEx((Rectangle){ (float)panelX, (float)panelY, (float)panelWidth, (float)panelHeight }, 4.0f, (Color){ 100, 100, 100, 255 });
                
                // Title
                DrawTextEx(customFont, "Create New World", (Vector2){ (float)panelX + 20, (float)panelY + 20 }, 32, 1.0f, WHITE);
                
                // World Name
                DrawTextEx(customFont, "World Name", (Vector2){ (float)panelX + 40, (float)panelY + 100 }, 20, 1.0f, LIGHTGRAY);
                Rectangle nameBox = { (float)panelX + 40, (float)panelY + 130, 520, 40 };
                
                if (CheckCollisionPointRec(mousePos, nameBox) && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) activeTextBox = 1;
                
                DrawRectangleRec(nameBox, DARKGRAY);
                DrawRectangleLinesEx(nameBox, 2.0f, activeTextBox == 1 ? WHITE : GRAY);
                DrawTextEx(customFont, worldName, (Vector2){ nameBox.x + 10, nameBox.y + 10 }, 20, 1.0f, WHITE);
                
                // Blinking cursor
                if (activeTextBox == 1 && ((int)(GetTime() * 2) % 2 == 0)) {
                    int textW = MeasureTextEx(customFont, worldName, 20, 1.0f).x;
                    DrawRectangle(nameBox.x + 12 + textW, nameBox.y + 10, 12, 20, LIGHTGRAY);
                }
                
                // World Seed
                DrawTextEx(customFont, "Seed (Optional)", (Vector2){ (float)panelX + 40, (float)panelY + 200 }, 20, 1.0f, LIGHTGRAY);
                Rectangle seedBox = { (float)panelX + 40, (float)panelY + 230, 520, 40 };
                
                if (CheckCollisionPointRec(mousePos, seedBox) && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) activeTextBox = 2;
                // Click outside to unfocus
                if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON) && !CheckCollisionPointRec(mousePos, nameBox) && !CheckCollisionPointRec(mousePos, seedBox)) {
                    activeTextBox = 0;
                }
                
                DrawRectangleRec(seedBox, DARKGRAY);
                DrawRectangleLinesEx(seedBox, 2.0f, activeTextBox == 2 ? WHITE : GRAY);
                DrawTextEx(customFont, worldSeed, (Vector2){ seedBox.x + 10, seedBox.y + 10 }, 20, 1.0f, WHITE);
                
                if (activeTextBox == 2 && ((int)(GetTime() * 2) % 2 == 0)) {
                    int textW = MeasureTextEx(customFont, worldSeed, 20, 1.0f).x;
                    DrawRectangle(seedBox.x + 12 + textW, seedBox.y + 10, 12, 20, LIGHTGRAY);
                }
                
                // Back Button
                int btnWidth = 200;
                int btnHeight = 50;
                int backBtnX = panelX + 40;
                int btnY = panelY + panelHeight - 80;
                
                Rectangle backBtnBounds = { (float)backBtnX, (float)btnY, (float)btnWidth, (float)btnHeight };
                bool isBackHovered = CheckCollisionPointRec(mousePos, backBtnBounds);
                DrawRectangleRec(backBtnBounds, isBackHovered ? (Color){ 100, 100, 100, 255 } : (Color){ 60, 60, 60, 255 });
                DrawRectangleLinesEx(backBtnBounds, 3.0f, isBackHovered ? WHITE : GRAY);
                Vector2 backTextSize = MeasureTextEx(customFont, "Back", 20, 1.0f);
                DrawTextEx(customFont, "Back", (Vector2){ backBtnX + (btnWidth/2) - (backTextSize.x/2), btnY + (btnHeight/2) - (backTextSize.y/2) }, 20, 1.0f, WHITE);
                
                if (isBackHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    currentState = MAIN_MENU;
                }
                
                // Create Button
                int createBtnX = panelX + panelWidth - 40 - btnWidth;
                Rectangle createBtnBounds = { (float)createBtnX, (float)btnY, (float)btnWidth, (float)btnHeight };
                bool isCreateHovered = CheckCollisionPointRec(mousePos, createBtnBounds);
                DrawRectangleRec(createBtnBounds, isCreateHovered ? (Color){ 100, 100, 100, 255 } : (Color){ 60, 60, 60, 255 });
                DrawRectangleLinesEx(createBtnBounds, 3.0f, isCreateHovered ? WHITE : GRAY);
                Vector2 createTextSize = MeasureTextEx(customFont, "Create", 20, 1.0f);
                DrawTextEx(customFont, "Create", (Vector2){ createBtnX + (btnWidth/2) - (createTextSize.x/2), btnY + (btnHeight/2) - (createTextSize.y/2) }, 20, 1.0f, WHITE);
                
                if (isCreateHovered && IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                    currentWorldName = worldName;
                    int nameCounter = 1;
                    while (std::filesystem::exists("saves/" + currentWorldName)) {
                        currentWorldName = std::string(worldName) + " (" + std::to_string(nameCounter) + ")";
                        nameCounter++;
                    }
                    // Update the worldName string so the HUD shows it correctly
                    snprintf(worldName, sizeof(worldName), "%s", currentWorldName.c_str());
                    worldNameLen = strlen(worldName);
                    
                    if (serverMode) {
                        serverSocket = socket(AF_INET, SOCK_STREAM, 0);
                        if (serverSocket != INVALID_SOCKET_VAL) {
                            SetNonBlocking(serverSocket);
                            struct sockaddr_in serv_addr;
                            serv_addr.sin_family = AF_INET;
                            serv_addr.sin_addr.s_addr = INADDR_ANY;
                            serv_addr.sin_port = htons(12345);
                            bind(serverSocket, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
                            listen(serverSocket, 5);
                        }
                    }

                    currentState = GAMEPLAY;
                    DisableCursor(); // Hide and lock cursor for first-person control
                    
                    std::filesystem::create_directories("saves/" + currentWorldName);
                    
                    // Simple hash for seed string
                    globalSeedHash = 0;
                    for (int i = 0; worldSeed[i] != '\0'; i++) {
                        globalSeedHash = globalSeedHash * 31 + worldSeed[i];
                    }
                    if (worldSeed[0] == '\0') globalSeedHash = GetRandomValue(0, 100000);
                    
                    // Clear old chunks
                    for (auto& pair : worldChunks) {
                        delete pair.second;
                    }
                    worldChunks.clear();
                    
                    // Generate spawn chunk and place player on surface
                    float spawnY = FindSpawnY(0, 0);
                    camera3D.position = (Vector3){ 0.0f, spawnY, 0.0f };
                    camera3D.target   = (Vector3){ 0.0f, spawnY, 1.0f };
                    playerVelocityY = 0.0f;
                    camYaw = 0.0f; camPitch = 0.0f; // Reset look so WASD matches view
                    
                    // Re-write world.dat with correct spawnY now that we know it
                    std::ofstream worldFile2("saves/" + currentWorldName + "/world.dat");
                    if (worldFile2.is_open()) {
                        worldFile2 << globalSeedHash << " "
                                   << camera3D.position.x << " "
                                   << camera3D.position.y << " "
                                   << camera3D.position.z;
                        worldFile2.close();
                    }
                    
                    // Give starter kit to new player
                    for (int i = 0; i < 9; i++) { hotbar[i] = InventorySlot(AIR, 0); }
                    for (int i = 0; i < 27; i++) { inventory[i] = InventorySlot(AIR, 0); }
                    hotbar[0] = InventorySlot(DIRT,        64);
                    hotbar[1] = InventorySlot(COBBLESTONE, 64);
                    hotbar[2] = InventorySlot(PLANK,       64);
                    hotbar[3] = InventorySlot(SAND,        64);
                    hotbar[4] = InventorySlot(GRASS,       64);
                    activeHotbarSlot = 0;
                }
            }

            // Draw Gameplay overlay if we entered gameplay
            if (currentState == GAMEPLAY || currentState == PAUSE_MENU || currentState == CRAFTING_GUI) {
                // ---- Atmospheric Calculations (Previously global) ----
                // lightLevel and blockTint are derived from the global dayFactor
                
                float lightLevel = 0.2f + 0.8f * dayFactor; // Ambient light multiplier
                Color blockTint = { (unsigned char)(255 * lightLevel), (unsigned char)(255 * lightLevel), (unsigned char)(255 * lightLevel), 255 };
                
                Color skyBlue = { 135, 206, 235, 255 };
                Color nightBlue = { 10, 10, 25, 255 };
                Color currentSky = {
                    (unsigned char)(nightBlue.r + dayFactor * (skyBlue.r - nightBlue.r)),
                    (unsigned char)(nightBlue.g + dayFactor * (skyBlue.g - nightBlue.g)),
                    (unsigned char)(nightBlue.b + dayFactor * (skyBlue.b - nightBlue.b)),
                    255
                };

                ClearBackground(currentSky);
                
                BeginMode3D(camera3D);
                    // Draw Sun and Moon (simple billboards or spheres far away)
                    Vector3 sunPos = { camera3D.position.x + cosf(sunAngle) * 100, camera3D.position.y + sinf(sunAngle) * 100, camera3D.position.z };
                    Vector3 moonPos = { camera3D.position.x + cosf(sunAngle + 3.14159f) * 100, camera3D.position.y + sinf(sunAngle + 3.14159f) * 100, camera3D.position.z };
                    
                    DrawSphere(sunPos, 5.0f, YELLOW);
                    DrawSphere(moonPos, 4.0f, LIGHTGRAY);
                    
                    // --- DRAW REMOTE PLAYERS ---
                    for (const auto& rp : remotePlayers) {
                        DrawCapsule(rp.position, (Vector3){ rp.position.x, rp.position.y + 1.8f, rp.position.z }, 0.4f, 8, 8, BLUE);
                        // Draw Nameplate
                        Vector2 namePos = GetWorldToScreen((Vector3){ rp.position.x, rp.position.y + 2.2f, rp.position.z }, camera3D);
                        DrawTextEx(customFont, rp.name.c_str(), (Vector2){ namePos.x - MeasureTextEx(customFont, rp.name.c_str(), 20, 1.0f).x/2, namePos.y }, 20, 1.0f, WHITE);
                    }
                    
                    int playerCX = (int)floorf(camera3D.position.x / CHUNK_SIZE);
                    int playerCZ = (int)floorf(camera3D.position.z / CHUNK_SIZE);
                    
                    Vector3 camForward = Vector3Normalize(Vector3Subtract(camera3D.target, camera3D.position));
                    
                    // --- PERFORMANCE OPTIMIZED BATCHED RENDER LOOP ---
                    // 1. Identify chunks to render and rebuild dirty ones
                    std::vector<Chunk*> visibleChunks;
                    for (int cx = playerCX - RENDER_DISTANCE; cx <= playerCX + RENDER_DISTANCE; cx++) {
                        for (int cz = playerCZ - RENDER_DISTANCE; cz <= playerCZ + RENDER_DISTANCE; cz++) {
                            // FRUSTUM CULLING
                            Vector3 chunkCenter = { (float)(cx * CHUNK_SIZE + 8), 32.0f, (float)(cz * CHUNK_SIZE + 8) };
                            Vector3 toChunk = Vector3Normalize(Vector3Subtract(chunkCenter, camera3D.position));
                            if (Vector3Length(Vector3Subtract(chunkCenter, camera3D.position)) > 24.0f && 
                                Vector3DotProduct(toChunk, camForward) < -0.2f) continue;

                            auto it = worldChunks.find({cx, cz});
                            if (it == worldChunks.end()) continue;
                            Chunk* chunk = it->second;
                            
                            if (chunk->dirty) RebuildChunkRenderList(chunk, cx, cz);
                            visibleChunks.push_back(chunk);
                        }
                    }

                    // 2. Batch render per type
                    for (int renderType = 1; renderType <= 13; renderType++) {
                        if (renderType == GRASS) {
                            for (Chunk* chunk : visibleChunks) {
                                for (auto& pos : chunk->renderLists[GRASS]) {
                                    DrawGrassBlock(pos, blockTextures[GRASS].id, grassTopTexture.id, blockTextures[DIRT].id, blockTint);
                                }
                            }
                        } else if (renderType == CRAFTING_TABLE) {
                            for (Chunk* chunk : visibleChunks) {
                                for (auto& pos : chunk->renderLists[CRAFTING_TABLE]) {
                                    DrawCraftingTable(pos, craftingSideTexture.id, craftingTopTexture.id, blockTextures[DIRT].id, blockTint);
                                }
                            }
                        } else {
                            rlSetTexture(blockTextures[renderType].id);
                            rlBegin(RL_QUADS);
                            rlColor4ub(blockTint.r, blockTint.g, blockTint.b, 255);
                            if (renderType == LEAVES) {
                                rlColor4ub((unsigned char)(blockTint.r * 0.2f), (unsigned char)(blockTint.g * 0.6f), (unsigned char)(blockTint.b * 0.2f), 255);
                            }
                            
                            for (Chunk* chunk : visibleChunks) {
                                for (auto& pos : chunk->renderLists[renderType]) {
                                    DrawCubeVertices(pos.x, pos.y, pos.z, 1.0f, 1.0f, 1.0f);
                                }
                            }
                            rlEnd();
                        }
                    }
                    // Draw Block Selection Wireframe
                    if (hitBlock && !inventoryOpen && currentState != CRAFTING_GUI) {
                        float size = 1.02f;
                        DrawCubeWires((Vector3){(float)hitX, (float)hitY, (float)hitZ}, size, size, size, BLACK);
                        
                        // Draw breaking progress indicator
                        // Draw breaking progress indicator
                        if (breakProgress > 0.0f) {
                            float pSize = (breakProgress / 1.5f) * 1.05f; // Scale visual based on progress
                            if (pSize > 1.05f) pSize = 1.05f;
                            DrawCubeWires((Vector3){(float)hitX, (float)hitY, (float)hitZ}, pSize, pSize, pSize, RED);
                        }
                    }
                    
                    // --- DRAW VIEWMODEL (ARM/HELD ITEM) ---
                    if (!inventoryOpen && currentState != CRAFTING_GUI) {
                        if (isSwinging) {
                            swingTime += GetFrameTime() * 8.0f;
                            if (swingTime >= 1.0f) {
                                swingTime = 0.0f;
                                isSwinging = false;
                            }
                        }
                        
                        float swingVal = sinf(swingTime * PI);
                        
                        rlDisableDepthTest(); // Draw on top
                        rlPushMatrix();
                            // Build a stable viewmodel matrix
                            // We use the camera's right/up/forward but dampen the vertical tilt
                            Vector3 forwardVM = Vector3Subtract(camera3D.target, camera3D.position);
                            forwardVM = Vector3Normalize(forwardVM);
                            Vector3 rightVM = Vector3CrossProduct(forwardVM, camera3D.up);
                            rightVM = Vector3Normalize(rightVM);
                            Vector3 upVM = Vector3CrossProduct(rightVM, forwardVM);
                            upVM = Vector3Normalize(upVM);
                            
                            // Horizontal-only forward for arm orientation
                            Vector3 hForward = { forwardVM.x, 0, forwardVM.z };
                            hForward = Vector3Normalize(hForward);
                            
                            // Hand position relative to camera
                            Vector3 handPos = Vector3Add(camera3D.position, Vector3Scale(forwardVM, 0.45f));
                            handPos = Vector3Add(handPos, Vector3Scale(rightVM, 0.28f));
                            handPos = Vector3Add(handPos, Vector3Scale(upVM, -0.25f - swingVal * 0.15f));
                            
                            // Draw Arm (rotated cube)
                            // We use rlgl to rotate it to point roughly forward
                            rlPushMatrix();
                                rlTranslatef(handPos.x, handPos.y, handPos.z);
                                rlRotatef(camYaw * 180.0f/PI, 0, 1, 0); // Yaw with camera
                                rlRotatef(-20.0f - swingVal * 30.0f, 1, 0, 0); // Slight slant
                                DrawCube((Vector3){0,0,0}, 0.08f, 0.1f, 0.35f, (Color){220, 180, 150, 255});
                            rlPopMatrix();
                            
                            // Draw Held Item
                            int heldBT = hotbar[activeHotbarSlot].blockType;
                            if (heldBT != AIR) {
                                Vector3 itemPos = Vector3Add(handPos, Vector3Scale(forwardVM, 0.12f));
                                itemPos = Vector3Add(itemPos, Vector3Scale(upVM, 0.12f));
                                itemPos = Vector3Add(itemPos, Vector3Scale(rightVM, -0.05f));
                                
                                Texture2D itemTex = (heldBT == GRASS) ? grassTopTexture : (heldBT == CRAFTING_TABLE ? craftingSideTexture : blockTextures[heldBT]);
                                if (itemTex.id > 0) {
                                    if (heldBT < STICK) {
                                        // 3D Block in hand
                                        rlSetTexture(itemTex.id);
                                        rlPushMatrix();
                                            rlTranslatef(itemPos.x, itemPos.y, itemPos.z);
                                            rlRotatef(camYaw * 180.0f/PI + 45.0f, 0, 1, 0); 
                                            rlRotatef(20.0f, 1, 0, 1);
                                            DrawCubeVertices(0,0,0, 0.12f, 0.12f, 0.12f);
                                        rlPopMatrix();
                                        rlSetTexture(0);
                                    } else {
                                        // Item (Stick/Axe) as Billboard - Scaled larger for better visibility
                                        DrawBillboard(camera3D, itemTex, itemPos, 0.35f, WHITE);
                                    }
                                } else {
                                    // Fallback
                                    DrawCube(itemPos, 0.1f, 0.1f, 0.1f, RED);
                                }
                            }
                        rlPopMatrix();
                        rlEnableDepthTest();
                    }
                    
                EndMode3D();
                
                // Draw 2D Crosshair overlay (hide when inventory open)
                if (!inventoryOpen) {
                    DrawRectangle(currentWidth/2 - 2, currentHeight/2 - 10, 4, 20, (Color){255, 255, 255, 150});
                    DrawRectangle(currentWidth/2 - 10, currentHeight/2 - 2, 20, 4, (Color){255, 255, 255, 150});
                }
                
                // Draw debug info (top-left)
                DrawTextEx(customFont, "MorriCraft Pre-Alpha", (Vector2){ 10, 10 }, 20, 1.0f, BLACK);
                DrawTextEx(customFont, TextFormat("World: %s", worldName), (Vector2){ 10, 40 }, 16, 1.0f, BLACK);
                DrawTextEx(customFont, TextFormat("FPS: %i", GetFPS()), (Vector2){ 10, 60 }, 16, 1.0f, RED);
                DrawTextEx(customFont, TextFormat("XYZ: %.1f / %.1f / %.1f",
                    camera3D.position.x, camera3D.position.y - 1.6f, camera3D.position.z),
                    (Vector2){ 10, 80 }, 16, 1.0f, DARKGRAY);

                // --- In-Game Clock ---
                int totalMinutes = (int)(timeOfDay * 24 * 60);
                int hours = (totalMinutes / 60) % 24;
                int minutes = totalMinutes % 60;
                const char* ampm = (hours >= 12) ? "PM" : "AM";
                int displayHours = hours % 12;
                if (displayHours == 0) displayHours = 12;
                
                DrawTextEx(customFont, TextFormat("Time: %i:%02i %s", displayHours, minutes, ampm), (Vector2){ 10, 110 }, 18, 1.0f, (dayFactor > 0.5f) ? BLACK : WHITE);
                DrawTextEx(customFont, (dayFactor > 0.5f) ? "Status: Day" : "Status: Night", (Vector2){ 10, 130 }, 16, 1.0f, (dayFactor > 0.5f) ? (Color){180, 150, 0, 255} : (Color){100, 100, 255, 255});
                
                // ---- HOTBAR ----
                const int slotSize  = 50;
                const int slotGap   = 4;
                int hotbarW = 9 * slotSize + 8 * slotGap;
                int hotbarX = currentWidth  / 2 - hotbarW / 2;
                int hotbarY = currentHeight - slotSize - 12;
                
                // Hotbar background panel
                DrawRectangle(hotbarX - 6, hotbarY - 6, hotbarW + 12, slotSize + 12,
                              (Color){ 30, 30, 30, 180 });
                DrawRectangleLinesEx((Rectangle){ (float)(hotbarX-6), (float)(hotbarY-6),
                                      (float)(hotbarW+12), (float)(slotSize+12) },
                                      2.0f, (Color){ 80, 80, 80, 220 });
                
                for (int s = 0; s < 9; s++) {
                    int sx = hotbarX + s * (slotSize + slotGap);
                    bool selected = (s == activeHotbarSlot);
                    
                    // Slot background
                    DrawRectangle(sx, hotbarY, slotSize, slotSize,
                                  (Color){ 60, 60, 60, 220 });
                    // Slot border (gold for selected, gray otherwise)
                    Color borderCol = selected ? (Color){255, 215, 0, 255} : (Color){100, 100, 100, 255};
                    float borderW   = selected ? 3.0f : 1.5f;
                    DrawRectangleLinesEx((Rectangle){ (float)sx, (float)hotbarY,
                                          (float)slotSize, (float)slotSize },
                                          borderW, borderCol);
                    
                    // Block texture preview
                    if (hotbar[s].count > 0 && hotbar[s].blockType != AIR) {
                        int bt = hotbar[s].blockType;
                        Texture2D tex = (bt == GRASS) ? grassTopTexture : blockTextures[bt];
                        if (tex.id > 0) {
                            Rectangle src = { 0, 0, (float)tex.width, (float)tex.height };
                            Rectangle dst = { (float)(sx+4), (float)(hotbarY+4),
                                              (float)(slotSize-8), (float)(slotSize-8) };
                            Color tint = (bt == GRASS) ? (Color){124,189,107,255} : WHITE;
                            DrawTexturePro(tex, src, dst, (Vector2){0,0}, 0.0f, tint);
                        }
                        // Item count centered bottom
                        Vector2 countSize = MeasureTextEx(customFont, TextFormat("%i", hotbar[s].count), 12, 1.0f);
                        DrawTextEx(customFont, TextFormat("%i", hotbar[s].count),
                                   (Vector2){ (float)(sx + (slotSize/2) - (countSize.x/2)), (float)(hotbarY + slotSize - 14) },
                                   12, 1.0f, WHITE);
                    }
                    
                    // Slot number label
                    DrawTextEx(customFont, TextFormat("%i", s+1),
                               (Vector2){ (float)(sx+3), (float)(hotbarY+2) }, 12, 1.0f,
                               (Color){180,180,180,200});
                }
                
                // ---- UI HELPERS & STATE ----
                const int invSlotSize = 52;
                const int invGap      = 4;
                const int invCols     = 9;
                const int invRows     = 3;
                const int invPanelW   = 550;
                const int invPanelH   = 500;

                auto drawSlotEx = [&](InventorySlot& slot, int px, int py, bool isResultSlot = false, bool isTableResult = false) {
                    Rectangle slotRect = { (float)px, (float)py, (float)invSlotSize, (float)invSlotSize };
                    bool hov = CheckCollisionPointRec(mousePos, slotRect);
                    
                    DrawRectangleRec(slotRect, hov ? (Color){90,90,90,255} : (Color){60,60,60,255});
                    DrawRectangleLinesEx(slotRect, 2.0f, hov ? WHITE : (Color){100,100,100,200});
                    
                    if (slot.count > 0 && slot.blockType != AIR) {
                        int bt = slot.blockType;
                        Texture2D tex = (bt == GRASS) ? grassTopTexture : (bt == CRAFTING_TABLE ? craftingSideTexture : blockTextures[bt]);
                        if (tex.id > 0 && tex.width > 0 && tex.height > 0) {
                            Rectangle src = { 0,0,(float)tex.width,(float)tex.height };
                            Rectangle dst = { (float)(px+5),(float)(py+5), (float)(invSlotSize-10),(float)(invSlotSize-10) };
                            Color tint = (bt == GRASS) ? (Color){124,189,107,255} : WHITE;
                            DrawTexturePro(tex, src, dst, (Vector2){0,0}, 0.0f, tint);
                        } else if (bt >= STICK) {
                            // Fallback rendering for items if texture failed
                            Color itemCol = (bt == STICK) ? BROWN : DARKGRAY;
                            DrawRectangle(px + 10, py + 10, invSlotSize - 20, invSlotSize - 20, itemCol);
                        }
                        Vector2 cSize = MeasureTextEx(customFont, TextFormat("%i", slot.count), 12, 1.0f);
                        DrawTextEx(customFont, TextFormat("%i", slot.count),
                                   (Vector2){ (float)(px + (invSlotSize/2) - (cSize.x/2)), (float)(py + invSlotSize - 14) },
                                   12, 1.0f, WHITE);
                    }
                    
                    if (hov && IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
                        if (isResultSlot) {
                            if (mouseHeldItem.blockType == AIR && slot.blockType != AIR) {
                                mouseHeldItem = slot;
                                slot = InventorySlot(AIR, 0);
                                if (isTableResult) {
                                    for(int i=0; i<9; i++) {
                                        if (tableSlots[i].count > 0) tableSlots[i].count--;
                                        if (tableSlots[i].count == 0) tableSlots[i].blockType = AIR;
                                    }
                                    UpdateTableCrafting();
                                } else {
                                    for(int i=0; i<4; i++) {
                                        if (craftingSlots[i].count > 0) craftingSlots[i].count--;
                                        if (craftingSlots[i].count == 0) craftingSlots[i].blockType = AIR;
                                    }
                                    UpdateCrafting();
                                }
                            }
                        } else {
                            InventorySlot tmp = slot;
                            slot = mouseHeldItem;
                            mouseHeldItem = tmp;
                            UpdateCrafting();
                            UpdateTableCrafting();
                        }
                    }
                    
                    if (hov && IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) {
                        if (!isResultSlot) {
                            if (mouseHeldItem.blockType == AIR) {
                                // Pick up half? Not requested, but common. 
                                // For now just following user request: "holding a stack... right click into a box, place one"
                            } else {
                                // Holding something, place one
                                if (slot.blockType == AIR) {
                                    slot = InventorySlot(mouseHeldItem.blockType, 1);
                                    mouseHeldItem.count--;
                                } else if (slot.blockType == mouseHeldItem.blockType && slot.count < 64) {
                                    slot.count++;
                                    mouseHeldItem.count--;
                                }
                                if (mouseHeldItem.count <= 0) mouseHeldItem = InventorySlot(AIR, 0);
                                UpdateCrafting();
                                UpdateTableCrafting();
                            }
                        }
                    }
                };

                auto drawInvGrid = [&](int startX, int startY) {
                    for (int row = 0; row < invRows; row++) {
                        for (int col = 0; col < invCols; col++) {
                            int si = row * invCols + col;
                            int px = startX + col * (invSlotSize + invGap);
                            int py = startY + row * (invSlotSize + invGap);
                            drawSlotEx(inventory[si], px, py);
                        }
                    }
                    int hotY = startY + invRows * (invSlotSize + invGap) + 12;
                    for (int col = 0; col < invCols; col++) {
                        int px = startX + col * (invSlotSize + invGap);
                        drawSlotEx(hotbar[col], px, hotY);
                    }
                };

                // ---- INVENTORY SCREEN ----
                if (inventoryOpen) {
                    // Dim world
                    DrawRectangle(0, 0, currentWidth, currentHeight, (Color){0,0,0,160});
                    
                    int invPanelX = currentWidth / 2 - invPanelW / 2;
                    int invPanelY = currentHeight / 2 - invPanelH / 2;
                    
                    DrawRectangle(invPanelX, invPanelY, invPanelW, invPanelH, (Color){ 40, 40, 40, 240 });
                    DrawRectangleLinesEx((Rectangle){ (float)invPanelX, (float)invPanelY, (float)invPanelW, (float)invPanelH }, 3.0f, (Color){ 180, 180, 180, 255 });
                    DrawTextEx(customFont, "Inventory", (Vector2){ (float)(invPanelX + 12), (float)(invPanelY + 10) }, 20, 1.0f, WHITE);
                    
                    // --- Player Character Placeholder ---
                    int charW = 100;
                    int charH = 160;
                    int charX = invPanelX + 32;
                    int charY = invPanelY + 40;
                    DrawRectangle(charX, charY, charW, charH, (Color){30, 30, 30, 255});
                    DrawRectangleLinesEx((Rectangle){(float)charX, (float)charY, (float)charW, (float)charH}, 2.0f, DARKGRAY);
                    DrawTextEx(customFont, "PLAYER", (Vector2){(float)charX + 22, (float)charY + 70}, 16, 1.0f, GRAY);
                    
                    // --- 2x2 Crafting Grid ---
                    int craftX = charX + charW + 40;
                    int craftY = charY + 20;
                    DrawTextEx(customFont, "Crafting", (Vector2){(float)craftX, (float)craftY - 18}, 14, 1.0f, LIGHTGRAY);
                    
                    drawSlotEx(craftingSlots[0], craftX, craftY);
                    drawSlotEx(craftingSlots[1], craftX + invSlotSize + invGap, craftY);
                    drawSlotEx(craftingSlots[2], craftX, craftY + invSlotSize + invGap);
                    drawSlotEx(craftingSlots[3], craftX + invSlotSize + invGap, craftY + invSlotSize + invGap);
                    
                    // Arrow and Result
                    int arrowX = craftX + 2*invSlotSize + invGap + 15;
                    DrawTextEx(customFont, "->", (Vector2){(float)arrowX, (float)craftY + invSlotSize/2 + 10}, 24, 1.0f, WHITE);
                    drawSlotEx(craftingResult, arrowX + 40, craftY + invSlotSize/2, true);

                    // --- Main Inventory (3x9) ---
                    int gridStartX = invPanelX + (invPanelW - (invCols * invSlotSize + (invCols-1) * invGap)) / 2;
                    int gridStartY = invPanelY + charH + 60;
                    drawInvGrid(gridStartX, gridStartY);
                    
                    // Close hint
                    DrawTextEx(customFont, "Press E or ESC to close", (Vector2){ (float)(invPanelX + 12), (float)(invPanelY + invPanelH - 22) }, 14, 1.0f, (Color){160, 160, 160, 200});

                    if (IsKeyPressed(KEY_ESCAPE)) {
                        inventoryOpen = false;
                        DisableCursor();
                    }
                }
                
                if (currentState == CRAFTING_GUI) {
                    DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 150 });
                    
                    int guiX = currentWidth/2 - invPanelW/2;
                    int guiY = currentHeight/2 - (invPanelH + 50)/2;
                    
                    DrawRectangle(guiX, guiY, invPanelW, invPanelH + 50, (Color){40, 40, 40, 240});
                    DrawRectangleLinesEx((Rectangle){(float)guiX, (float)guiY, (float)invPanelW, (float)invPanelH + 50}, 3.0f, LIGHTGRAY);
                    DrawTextEx(customFont, "Crafting Table", (Vector2){(float)guiX + 20, (float)guiY + 20}, 24, 1.0f, WHITE);
                    
                    int tableStartX = guiX + 50;
                    int tableStartY = guiY + 80;
                    for(int i=0; i<9; i++) {
                        int px = tableStartX + (i % 3) * (invSlotSize + invGap);
                        int py = tableStartY + (i / 3) * (invSlotSize + invGap);
                        drawSlotEx(tableSlots[i], px, py, false, true);
                    }
                    
                    int arrowX = tableStartX + 3*invSlotSize + 30;
                    DrawTextEx(customFont, "----->", (Vector2){(float)arrowX, (float)tableStartY + invSlotSize + 10}, 24, 1.0f, WHITE);
                    drawSlotEx(tableResult, arrowX + 80, tableStartY + invSlotSize, true, true);
                    
                    drawInvGrid(guiX + 16, tableStartY + 3*(invSlotSize+invGap) + 40);
                    
                    if (IsKeyPressed(KEY_ESCAPE)) {
                        currentState = GAMEPLAY;
                        DisableCursor();
                    }
                }

                // --- Draw Held Item Last ---
                if (mouseHeldItem.blockType != AIR && mouseHeldItem.count > 0) {
                    int bt = mouseHeldItem.blockType;
                    Texture2D tex = (bt == GRASS) ? grassTopTexture : (bt == CRAFTING_TABLE ? craftingSideTexture : blockTextures[bt]);
                    if (tex.id > 0) {
                        Rectangle src = { 0,0,(float)tex.width,(float)tex.height };
                        Rectangle dst = { mousePos.x - (invSlotSize/2), mousePos.y - (invSlotSize/2), (float)invSlotSize, (float)invSlotSize };
                        Color tint = (bt == GRASS) ? (Color){124,189,107,255} : WHITE;
                        DrawTexturePro(tex, src, dst, (Vector2){0,0}, 0.0f, tint);
                        Vector2 hSize = MeasureTextEx(customFont, TextFormat("%i", mouseHeldItem.count), 12, 1.0f);
                        DrawTextEx(customFont, TextFormat("%i", mouseHeldItem.count), (Vector2){ dst.x + invSlotSize/2 - hSize.x/2, dst.y + invSlotSize - 14 }, 12, 1.0f, WHITE);
                    }
                }
                
                if (currentState == PAUSE_MENU) {
                    // Draw dark overlay
                    DrawRectangle(0, 0, currentWidth, currentHeight, (Color){ 0, 0, 0, 150 });
                    
                    const char* pButtons[] = { "Resume", "Options", "Save & Exit" };
                    int pNumButtons = 3;
                    int pBtnWidth = 400;
                    int pBtnHeight = 60;
                    int pBtnSpacing = 15;
                    int pStartY = (currentHeight / 2) - ((pNumButtons * pBtnHeight + (pNumButtons - 1) * pBtnSpacing) / 2);
                    
                    for (int i = 0; i < pNumButtons; i++) {
                        int pPosX = (currentWidth / 2) - (pBtnWidth / 2);
                        int pPosY = pStartY + i * (pBtnHeight + pBtnSpacing);
                        
                        Rectangle btnBounds = { (float)pPosX, (float)pPosY, (float)pBtnWidth, (float)pBtnHeight };
                        bool isHovered = CheckCollisionPointRec(mousePos, btnBounds);
                        
                        Color baseColor = isHovered ? (Color){ 100, 100, 100, 255 } : (Color){ 60, 60, 60, 255 };
                        Color borderColor = isHovered ? (Color){ 200, 200, 200, 255 } : (Color){ 20, 20, 20, 255 };
                        
                        DrawRectangleRec(btnBounds, baseColor);
                        DrawRectangleLinesEx(btnBounds, 3.0f, borderColor);
                        
                        if (isHovered) {
                            DrawRectangleLinesEx((Rectangle){btnBounds.x - 2, btnBounds.y - 2, btnBounds.width + 4, btnBounds.height + 4}, 2.0f, (Color){255, 255, 255, 50});
                            
                            if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) {
                                if (i == 0) { // Resume
                                    currentState = GAMEPLAY;
                                    DisableCursor();
                                } else if (i == 1) { // Options
                                    optionsReturnState = PAUSE_MENU;
                                    currentState = OPTIONS_MENU;
                                } else if (i == 2) { // Save & Exit
                                    currentState = MAIN_MENU;
                                    inventoryOpen = false;
                                    
                                    // Save player position to world.dat
                                    std::ofstream wf("saves/" + currentWorldName + "/world.dat");
                                    if (wf.is_open()) {
                                        wf << globalSeedHash << " "
                                           << camera3D.position.x << " "
                                           << camera3D.position.y << " "
                                           << camera3D.position.z;
                                        wf.close();
                                    }
                                    // Save inventory
                                    std::ofstream invf("saves/" + currentWorldName + "/inventory.dat", std::ios::binary);
                                    if (invf.is_open()) {
                                        invf.write((char*)hotbar,    sizeof(hotbar));
                                        invf.write((char*)inventory,  sizeof(inventory));
                                        invf.write((char*)&activeHotbarSlot, sizeof(activeHotbarSlot));
                                        invf.close();
                                    }
                                    
                                    // Save chunks and clear memory
                                    for (auto& pair : worldChunks) {
                                        SaveChunk(pair.second, pair.first.x, pair.first.z);
                                        delete pair.second;
                                    }
                                    worldChunks.clear();
                                    currentWorldName = "";
                                }
                            }
                        }
                        
                        Vector2 textSize = MeasureTextEx(customFont, pButtons[i], 24, 1.0f);
                        DrawTextEx(customFont, pButtons[i], (Vector2){ (float)pPosX + (pBtnWidth / 2) - (textSize.x / 2) + 2, (float)pPosY + (pBtnHeight / 2) - (textSize.y / 2) + 2 }, 24, 1.0f, (Color){ 30, 30, 30, 255 });
                        Color textColor = isHovered ? (Color){ 255, 255, 160, 255 } : (Color){ 220, 220, 220, 255 };
                        DrawTextEx(customFont, pButtons[i], (Vector2){ (float)pPosX + (pBtnWidth / 2) - (textSize.x / 2), (float)pPosY + (pBtnHeight / 2) - (textSize.y / 2) }, 24, 1.0f, textColor);
                    }
                }
            }

        EndDrawing();
        //----------------------------------------------------------------------------------
    }

    // De-Initialization
    //--------------------------------------------------------------------------------------
    for (int i = 1; i <= 5; i++) UnloadTexture(blockTextures[i]);
    for (int i = 7; i <= 11; i++) UnloadTexture(blockTextures[i]);
    UnloadTexture(grassTopTexture);
    UnloadTexture(titleTexture);       // Texture unloading
    
    for (auto& pair : worldChunks) {
        delete pair.second;
    }
    UnloadFont(customFont);            // Font unloading
    UnloadMusicStream(titleMusic);     // Music unloading
    UnloadMusicStream(gameplayMusic);

    CloseAudioDevice();           // Close audio device
    CloseWindow();                // Close window and OpenGL context
    //--------------------------------------------------------------------------------------

    return 0;
}