main.cpp

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif

#include <GLFW/glfw3.h>

#ifdef __EMSCRIPTEN__
#include <GLES/gl.h>
#elif defined(__APPLE__)
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <string>
#include <functional>

#include "game/player.hpp"
#include "game/character.hpp"
#include "game/camera.hpp"
#ifdef __EMSCRIPTEN__
class MultiplayerClient {
public:
    void setServer(const std::string&, int) {}
    void setPlayerName(const std::string&) {}
    bool initOrJoin(const std::string&) { return false; }
    void shutdown() {}
    void sync(const vec2&) {}
    void drawRemotePlayers(GLuint) {}
    std::string getStatusText() const { return "multiplayer unavailable on web build"; }
};
#else
#include "game/multiplayer.hpp"
#endif
#include "game/tile.hpp"
#include "game/task.hpp"

#include "core/manager.hpp"
#include "core/essentials.hpp"
#include "core/collision.hpp"
#include "core/images/image.hpp"
#include "core/images/stb_image.h"
#include "core/text.hpp"
#include "core/file.hpp"

#ifdef __EMSCRIPTEN__
#include <emscripten/emscripten.h>

static std::function<void()>* gWebFrame = nullptr;

static void WebFrameTrampoline() {
    if (gWebFrame != nullptr) {
        (*gWebFrame)();
    }
}
#endif


// Game Assets

Player player;
Camera camera;

std::vector<Character> characters;
std::vector<Task> objectives;

struct Door {
    vec2 hubPos = vec2(0.0f);
    vec2 roomPos = vec2(0.0f);
    vec2 dim = vec2(32.0f, 64.0f);
    int roomId = 0;
};

std::vector<std::string> loadTileLibrary() {
    std::vector<std::string> files = grabFiles("dist/assets/tiles");
    std::vector<std::string> townFiles = grabFiles("dist/assets/town");
    files.insert(files.end(), townFiles.begin(), townFiles.end());

    if (!files.empty()) {
        return files;
    }

    files = grabFiles("assets/tiles");
    townFiles = grabFiles("assets/town");
    files.insert(files.end(), townFiles.begin(), townFiles.end());
    return files;
}

std::vector<std::string> loadAssetFiles(const std::string& relativePath) {
    std::vector<std::string> files = grabFiles("dist/assets/" + relativePath);
    if (!files.empty()) {
        return files;
    }
    return grabFiles("assets/" + relativePath);
}

std::vector<std::string> tileTex = loadTileLibrary();
std::vector<std::string> itemTex = loadAssetFiles("items");
std::vector<std::string> heartTex = loadAssetFiles("stats/health");

// Game Control Variables

std::string server = "localhost";

int tick = 1;

bool editor = false;
int mode = 0;
int selectMode = 0;
int selected = 0;
int tile = 0;
bool editorNextRoomHeld = false;
bool editorPrevRoomHeld = false;

const std::string fixedDoorTexturePath = "assets/door.png";
const vec2 fixedDoorPosition = vec2(128.0f, 32.0f);
const vec2 fixedDoorSize = vec2(32.0f, 64.0f);
const float doorSpacing = 112.0f;

float zoom = 2.0;

int running = 1;
bool inMainMenu = true;
bool multiplayerStarted = false;

std::string getEnvOrDefault(const char* key, const std::string& fallback) {
    const char* value = std::getenv(key);
    if (value == nullptr || value[0] == '\0') {
        return fallback;
    }
    return std::string(value);
}

int getEnvIntOrDefault(const char* key, int fallback) {
    const char* value = std::getenv(key);
    if (value == nullptr || value[0] == '\0') {
        return fallback;
    }

    try {
        return std::stoi(value);
    } catch (...) {
        return fallback;
    }
}

std::string getRandomUsername() {
    const std::vector<std::string> adjectives = {
        "brisk", "calm", "clever", "fuzzy", "gentle", "lucky", "mellow", "nimble", "quiet", "rapid", "sunny", "zesty"
    };

    const std::vector<std::string> nouns = {
        "otter", "fox", "raven", "koala", "panda", "sparrow", "beaver", "lynx", "wolf", "badger", "falcon", "gecko"
    };

    int adjectiveIndex = randInt(0, static_cast<int>(adjectives.size()) - 1);
    int nounIndex = randInt(0, static_cast<int>(nouns.size()) - 1);
    int suffix = randInt(100, 999);

    return adjectives[adjectiveIndex] + "-" + nouns[nounIndex] + std::to_string(suffix);
}

std::vector<std::string> getCharacterTasks() {
    return {"wash dishes", "take out trash", "do laundry"};
}

Character makeCharacterForRoom(int roomId, int stageIndex) {
    Character c;
    c.room = roomId;
    c.pos = vec2(300.0f + (stageIndex * 96.0f), 0.0f);
    c.target = c.pos;
    c.roamCenter = c.pos;
    c.name = "Character " + std::to_string(stageIndex + 1);
    c.level = 0;
    c.isRoaming = false;
    c.tasksGiven = 0;
    c.tasksCompleted = 0;
    c.nextStageSpawned = false;
    c.tasks = getCharacterTasks();
    return c;
}

Door makeDoorForRoom(int roomId) {
    Door door;
    door.roomId = roomId;
    door.hubPos = fixedDoorPosition + vec2(doorSpacing * static_cast<float>(roomId - 1), 0.0f);
    door.roomPos = fixedDoorPosition;
    door.dim = fixedDoorSize;
    return door;
}

Character* getCharacterForRoom(std::vector<Character>& chars, int roomId) {
    for (Character& c : chars) {
        if (c.room == roomId) {
            return &c;
        }
    }
    return nullptr;
}

void spawnNextStage(std::vector<Character>& chars, std::vector<Door>& doors, int& nextRoomId, Character& completedCharacter) {
    if (completedCharacter.nextStageSpawned) {
        return;
    }

    const int roomId = nextRoomId;
    nextRoomId += 1;

    doors.push_back(makeDoorForRoom(roomId));
    chars.push_back(makeCharacterForRoom(roomId, roomId - 1));
    chars.back().texture = Image::Load("assets/npcs/character.png");
    completedCharacter.nextStageSpawned = true;
}


std::vector<Tile> genWorld(vec2 dim) {
    std::vector<Tile> ts; // Nora shhhhh
    Tile t;
    for (int x = 0; x < dim.x; ++x) {
        for (int y = 0; y < dim.y; ++y) {
            if (randInt(0, 1) == 0) {
                t.id = 1;
            } else {
                t.id = randInt(2, 3);
            }
            t.pos = snap(vec2((x - dim.x/2.0)*64, (y - dim.y/2.0)*64), 64.0);
            ts.push_back(t);
        }
    }
    return ts;
}


vec2 GetMouseWorld(GLFWwindow* window) {
    vec2 world;

    int windowWidth, windowHeight;
    glfwGetWindowSize(window, &windowWidth, &windowHeight);

    float mouseNDC_X = (float)Mouse::X() / windowWidth;
    float mouseNDC_Y = (float)Mouse::Y() / windowHeight;

    world.x = (mouseNDC_X * 2.0f - 1.0f) * screen.x / zoom + camera.pos.x;
    world.y = (1.0f - mouseNDC_Y * 2.0f) * screen.y / zoom + camera.pos.y;

    return world;
}

vec2 GetMouseUI(GLFWwindow* window) {
    vec2 ui;

    int windowWidth, windowHeight;
    glfwGetWindowSize(window, &windowWidth, &windowHeight);

    float mouseNDC_X = static_cast<float>(Mouse::X()) / static_cast<float>(windowWidth);
    float mouseNDC_Y = static_cast<float>(Mouse::Y()) / static_cast<float>(windowHeight);

    ui.x = (mouseNDC_X * 2.0f - 1.0f) * screen.x / zoom;
    ui.y = (1.0f - mouseNDC_Y * 2.0f) * screen.y / zoom;

    return ui;
}

void windowResizeCallback(GLFWwindow* window, int width, int height) {
    // Update the screen variable with new dimensions
    screen = vec2(width, height);
    
    // Update the OpenGL viewport
    glViewport(0, 0, width, height);
    
    // Update the projection matrix with new dimensions
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-screen.x / zoom, screen.x / zoom, -screen.y / zoom, screen.y / zoom, -1.0, 1.0);
    glMatrixMode(GL_MODELVIEW);
}

bool addTaskForCharacter(Character& character, Player& localPlayer) {
    if (character.tasksGiven >= static_cast<int>(character.tasks.size())) {
        return false;
    }

    int taskId = character.tasksGiven;
    Task task;
    task.id = taskId;
    task.pos = GetTaskSpawnPosition(character.tasks[taskId], taskId);
    task.room = character.room;
    objectives.push_back(task);

    localPlayer.tasks.push_back(character.tasks[taskId]);
    character.tasksGiven += 1;
    return true;
}


int main()
{
    srand((unsigned int)time(nullptr));

    std::vector<Tile> tiles;
    tiles = genWorld(vec2(120,100));

    if (!isEmpty("game/data/map.dat")) {
        std::vector<Tile> lst = load("game/data/map.dat");
        tiles.insert(tiles.end(), lst.begin(), lst.end());
    }

    if (!glfwInit())
        return -1;

    GLFWwindow* window = glfwCreateWindow(screen.x, screen.y, "Community", nullptr, nullptr);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    // Load and set window icon
    int iconWidth, iconHeight, iconChannels;
    unsigned char* iconPixels = stbi_load("assets/icon.png", &iconWidth, &iconHeight, &iconChannels, 4);
    if (iconPixels) {
        GLFWimage icon;
        icon.width = iconWidth;
        icon.height = iconHeight;
        icon.pixels = iconPixels;
        glfwSetWindowIcon(window, 1, &icon);
        stbi_image_free(iconPixels);
    }

    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);

    // Register window resize callback
    glfwSetWindowSizeCallback(window, windowResizeCallback);
    
    // Initialize screen variable with actual window size
    int windowWidth, windowHeight;
    glfwGetWindowSize(window, &windowWidth, &windowHeight);
    screen = vec2(windowWidth, windowHeight);

    Manager::Init(window);
    Image::Init();
    if (!Text::Init()) {
        std::cout << "Failed to initialize text glyph textures." << std::endl;
    }

    std::vector<GLuint> tileTextures = loadTextures(tileTex);
    std::vector<GLuint> itemTextures = loadTextures(itemTex);
    std::vector<GLuint> heartTextures = loadTextures(heartTex);


    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-screen.x / zoom, screen.x / zoom, -screen.y / zoom, screen.y / zoom, -1.0, 1.0);
    glMatrixMode(GL_MODELVIEW);

    player.texture = Image::Load("assets/agent-bullet.png");
    characters.push_back(makeCharacterForRoom(1, 0));
    characters[0].texture = Image::Load("assets/npcs/character.png");

    std::vector<Door> doors;
    doors.push_back(makeDoorForRoom(1));
    int nextRoomId = 2;

    GLuint taskTex = Image::Load("assets/box.png");
    GLuint pause = Image::Load("assets/pause-improved.png");
    GLuint deleteTex = Image::Load("assets/delete.png");
    GLuint selectTex = Image::Load("assets/interact-select.png");
    GLuint fixedDoorTex = Image::Load(fixedDoorTexturePath.c_str());

    // Main Menu

    GLuint playButton = Image::Load("assets/menu/play-button.png");

    MultiplayerClient multiplayer;
    multiplayer.setServer(getEnvOrDefault("COMMUNITY_BACKEND_HOST", server.c_str()), getEnvIntOrDefault("COMMUNITY_BACKEND_PORT", 8080));
    multiplayer.setPlayerName(getEnvOrDefault("COMMUNITY_PLAYER_NAME", getRandomUsername()));
    std::string requestedRoomCode = getEnvOrDefault("COMMUNITY_ROOM_CODE", "");

    float menuScale = 1.0;

    auto frame = [&]() {
        if (glfwWindowShouldClose(window)) {
        #ifndef __EMSCRIPTEN__
            return;
        #else
            emscripten_cancel_main_loop();
            return;
        #endif
        }

        glfwPollEvents();

        glClearColor(0.8f, 0.8f, 0.8f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        glLoadIdentity();

        timer += 0.01;

        if (inMainMenu) {
            vec2 mouseUI = GetMouseUI(window);
            vec2 playCenter = vec2(0.0f, -80.0f + 10.0*sin(timer * 0.1));
            vec2 playHalfSize = vec2(220.0f, 70.0f);
            bool hoveringPlay = BoxCollide(playCenter, playHalfSize, mouseUI, vec2(0.0f));

            Image::DrawRect(vec2(0.0f, 0.0f), vec2(screen.x / zoom, screen.y / zoom), 0.94f, 0.97f, 0.92f);
            if (hoveringPlay) {
                menuScale += 0.05 * (1.2 - menuScale);
            } else {
                menuScale += 0.05 * (1.0 - menuScale);
            }
            
            Image::Draw(playButton, playCenter, vec2(140.0, 70.0) * menuScale);

            Text::DrawStringCentered("welcome to your community", vec2(0.0f, 180.0f), 42.0f / zoom, 1.35f);
            Text::DrawStringCentered("play", playCenter, 28.0f * menuScale / zoom, 1.3f);
            Text::DrawStringCentered("click play to start", vec2(0.0f, -220.0f), 18.0f / zoom, 1.3f);
            Text::DrawStringCentered("idiot", vec2(0.0f, -240.0f), 9.0f / zoom, 1.3f);

            if (hoveringPlay && Mouse::IsPressed(0)) {
                inMainMenu = false;
                if (!multiplayerStarted) {
                    multiplayer.initOrJoin(requestedRoomCode);
                    multiplayerStarted = true;
                }
            }

            Manager::Update();
            glfwSwapBuffers(window);
            return;
        }

        glTranslatef(-camera.pos.x, -camera.pos.y, 0);

        vec2 mouse = GetMouseWorld(window);
        int i = 0;
        selected = -1;
        for (const Tile& t : tiles) {
            if (t.room != player.room) {
                ++i;
                continue;
            }

            if (abs(t.pos.x - camera.pos.x) < (screen.x + 64.0) / zoom) {
                if (abs(t.pos.y - camera.pos.y) < (screen.y + 64.0) / zoom) {
                    Image::Draw(tileTextures[t.id], t.pos, 32, 0.0);
                    if (BoxCollide(mouse, vec2(0.0), t.pos, vec2(32.0))) {
                        selected = i;
                    }
                }
            }
            ++i;
        }

        if (fixedDoorTex != 0) {
            for (const Door& door : doors) {
                if (player.room == 0) {
                    Image::Draw(fixedDoorTex, door.hubPos, door.dim);
                } else if (player.room == door.roomId) {
                    Image::Draw(fixedDoorTex, door.roomPos, door.dim);
                }
            }
        }

        if (running) {
            tick += 1;

            if(Input::IsPressed("0")) {
                mode = 1 - mode;
            }

            if (mode) {
                camera.controls();

                bool nextRoomDown = Input::IsPressed("e");
                bool prevRoomDown = Input::IsPressed("q");

                if (nextRoomDown) {
                    player.room += 1;
                }

                if (prevRoomDown) {
                    player.room = std::max(0, player.room - 1);
                }

                if (Input::IsPressed("1")) {
                    selectMode = 0;
                }

                if (Input::IsPressed("2")) {
                    selectMode = 1;
                }

                Tile t;
                t.pos = snap(mouse + 32, 64.0);
                t.room = player.room;

                int tileCount = static_cast<int>(tileTextures.size());

                if (Input::IsPressed("x")) {
                    tile += 1;
                }

                if (Input::IsPressed("z")) {
                    tile -= 1;
                }

                if (Mouse::ScrollY() > 0.0) {
                    tile += 1;
                } else if (Mouse::ScrollY() < 0.0) {
                    tile -= 1;
                }

                if (tileCount > 0) {
                    if (tile < 0) {
                        tile = tileCount - 1;
                    } else if (tile >= tileCount) {
                        tile = 0;
                    }
                } else {
                    tile = 0;
                }

                t.id = tile;

                if (selectMode == 0 && tileCount > 0) {
                    Image::Draw(tileTextures[tile], t.pos, 32);
                } else {
                    Image::Draw(deleteTex, t.pos, 32);
                }
                    
                if (Mouse::IsPressed(0)) {
                    if (selectMode == 0) {
                        tiles.push_back(t);
                    } else {
                        if (selected != -1) {
                            tiles.erase(tiles.begin() + selected);
                        }
                    }

                    save(tiles, "game/data/map.dat");
                } else if (Mouse::IsDown(1)) {
                    if (selectMode == 0) {
                        tiles.push_back(t);
                    } else {
                        if (selected != -1) {
                            tiles.erase(tiles.begin() + selected);
                        }
                    }

                    save(tiles, "game/data/map.dat");
                }

            } else {
                camera.target = player.pos;
                camera.follow();

                player.controls();
                player.pos = player.pos + player.vel;
                multiplayer.sync(player.pos);

                Character* currentCharacter = getCharacterForRoom(characters, player.room);

                if (currentCharacter != nullptr && BoxCollide(player.pos, player.dim, currentCharacter->pos, currentCharacter->dim) && Input::IsPressed("e")) {
                    if (currentCharacter->isRoaming) {
                        std::cout << "This character is dancing. Door opened for the next room." << std::endl;
                    } else if (addTaskForCharacter(*currentCharacter, player)) {
                        std::cout << "Task added: " << player.tasks.back() << std::endl;
                    } else {
                        std::cout << "All tasks completed. No more tasks available." << std::endl;
                    }
                }

                for (const Door& door : doors) {
                    vec2 doorPos = vec2(-999999.0f);
                    if (player.room == 0) {
                        doorPos = door.hubPos;
                    } else if (player.room == door.roomId) {
                        doorPos = door.roomPos;
                    }

                    if (doorPos.x > -999998.0f && BoxCollide(player.pos, player.dim, doorPos, door.dim)) {
                        if (Input::IsPressed("e")) {
                            player.room = (player.room == 0) ? door.roomId : 0;
                            break;
                        }
                    }
                }

                if (currentCharacter != nullptr && currentCharacter->isRoaming) {
                    currentCharacter->roam();
                }

                Image::Draw(selectTex, snap(mouse + 32, 64.0), 32);
            }

            player.health = clamp(0.0, 100.0, player.health);
        } else {
            // Game Paused

            //Image::Draw(pause, camera.pos, 1500);
        }

        int id = 0;
        for (const Task& t : objectives) {
            if (t.room != player.room) {
                ++id;
                continue;
            }

            if (BoxCollide(player.pos, player.dim, t.pos, t.dim)) {
                if (Input::IsPressed("e")) {
                    Character* completedCharacter = getCharacterForRoom(characters, t.room);
                    std::string completedTaskName;
                    if (completedCharacter != nullptr && t.id >= 0 && t.id < static_cast<int>(completedCharacter->tasks.size())) {
                        completedTaskName = completedCharacter->tasks[t.id];
                    }

                    objectives.erase(objectives.begin() + id);
                    if (!completedTaskName.empty()) {
                        auto taskIt = std::find(player.tasks.begin(), player.tasks.end(), completedTaskName);
                        if (taskIt != player.tasks.end()) {
                            player.tasks.erase(taskIt);
                        }
                    }

                    if (completedCharacter != nullptr) {
                        completedCharacter->tasksCompleted = std::min(completedCharacter->tasksCompleted + 1, static_cast<int>(completedCharacter->tasks.size()));
                        completedCharacter->level = completedCharacter->tasksCompleted * 30;
                        if (completedCharacter->tasksCompleted >= static_cast<int>(completedCharacter->tasks.size())) {
                            completedCharacter->isRoaming = true;
                            spawnNextStage(characters, doors, nextRoomId, *completedCharacter);
                        }
                    }
                }
            }
            ++id;
            Image::Draw(taskTex, t.pos, 45.0);
        }

        Image::Draw(player.texture, player.pos, 150);
        multiplayer.drawRemotePlayers(player.texture);
        for (const Character& c : characters) {
            if (c.room == player.room) {
                Image::Draw(c.texture, c.pos, 150);
            }
        }

        // UI
        glLoadIdentity();
        Character* uiCharacter = getCharacterForRoom(characters, player.room);
        int uiLevel = (uiCharacter != nullptr) ? uiCharacter->level : 0;
        
        for (int i = 0; i < 9; ++i) {
            float perc = (uiLevel / 90.0f) - (i * 0.1f);
            GLuint tex;
            if (perc >= 0.1) {
                tex = heartTextures[1];
            } else if (perc >= 0.05) {
                tex = heartTextures[2];
            } else {
                tex = heartTextures[0];
            }
            Image::Draw(tex, vec2(-screen.x + 64*i + 48, screen.y - 48) / zoom, 16);
        }

        std::string levelText = "level " + std::to_string(uiLevel);
        Text::DrawString(levelText, vec2(-screen.x + 40, screen.y - 130) / zoom, 24.0f / zoom, 1.5f);

        std::string taskText = "objectives " + std::to_string(player.tasks.size());
        Text::DrawString(taskText, vec2(screen.x - 600, screen.y - 48) / zoom, 24.0f / zoom, 1.5f);

        std::string roomText = "room " + std::to_string(player.room);
        Text::DrawString(roomText, vec2(-screen.x + 40, screen.y - 230) / zoom, 20.0f / zoom, 1.5f);

        if (mode) {
            std::string editorTileText = "editor tile " + std::to_string(tile + 1) + "/" + std::to_string(tileTextures.size()) + " (x/z or wheel)";
            Text::DrawString(editorTileText, vec2(-screen.x + 40, screen.y - 280) / zoom, 18.0f / zoom, 1.5f);
        }

        Text::DrawString(multiplayer.getStatusText(), vec2(-screen.x + 40, screen.y - 180) / zoom, 20.0f / zoom, 1.5f);

        float y = 112.0;
        for (const std::string& t : player.tasks) {
            taskText = "- " + t;
            Text::DrawString(taskText, vec2(screen.x - 600, screen.y - y) / zoom, 24.0f / zoom, 1.5f);
            y += 64.0;
        }

        if (!running) {
            Text::DrawStringCentered("paused", vec2(0.0f, screen.y - 90.0f) / zoom, 40.0f / zoom, 1.5f);
        }

        if(Input::IsPressed("escape")) {
            running = 1 - running;
        }

        Manager::Update();

        glfwSwapBuffers(window);

    };

#ifdef __EMSCRIPTEN__
    std::function<void()> frameFn = frame;
    gWebFrame = &frameFn;
    emscripten_set_main_loop(WebFrameTrampoline, 0, 1);
#else
    while (!glfwWindowShouldClose(window)) {
        frame();
    }

    multiplayer.shutdown();
    glfwTerminate();
    return 0;
#endif
}