space.cpp

Go to the documentation of this file.

 
#include "mxvk/argz.hpp"
#include "mxvk/mxvk.hpp"
#include "mxvk/mxvk_exception.hpp"
 
#include <SDL3/SDL.h>
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <format>
#include <iostream>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
#ifndef asteroids_ASSET_DIR
#define asteroids_ASSET_DIR "."
#endif
 
constexpr int GAME_W = 640;
constexpr int GAME_H = 360;
constexpr int STAR_COUNT = 800;
constexpr int MAX_PROJECTILES = 50;
constexpr int MAX_ASTEROIDS = 30;
constexpr int MAX_PARTICLES = 40;
constexpr int ASTEROID_VERTICES = 8;
constexpr float PROJECTILE_SPEED = 5.0f;
constexpr int PROJECTILE_LIFETIME = 60;
constexpr int FIRE_COOLDOWN = 5;
constexpr int SHOTS_PER_BURST = 5;
constexpr int FIRE_DELAY = 3;
constexpr int EXPLOSION_DURATION = 90;
constexpr float MIN_ASTEROID_RADIUS = 8.0f;
constexpr int LARGE_ASTEROID_POINTS = 20;
constexpr int MEDIUM_ASTEROID_POINTS = 50;
constexpr int SMALL_ASTEROID_POINTS = 100;
 
struct Ship {
    float x, y;
    float vx, vy;
    float angle;
    int lives;
    int fire_cooldown;
    int burst_count;
    bool exploding;
    int explosion_timer;
    int score;
    int continuous_fire_timer;
    bool overheated;
    int overheat_cooldown;
};
 
struct Projectile {
    float x, y;
    float vx, vy;
    float lifetime;
    bool active;
};
 
struct Asteroid {
    float x, y;
    float vx, vy;
    float radius;
    bool active;
    float vertices[ASTEROID_VERTICES][2];
    float rotation_angle;
    float rotation_speed;
};
 
struct Particle {
    float x, y;
    float vx, vy;
    int lifetime;
    bool active;
};
 
struct Star {
    float x, y, speed;
    float size;
    float brightness;
    int layer;
    float r, g, b;
    float twinklePhase;
    float twinkleSpeed;
};
 
enum GameState {
    STATE_COUNTDOWN,
    STATE_LAUNCH,
    STATE_PLAYING,
    STATE_GAMEOVER
};
 
template <typename Func>
void bresenhamLine(int x0, int y0, int x1, int y1, Func plot) {
    int dx = abs(x1 - x0);
    int dy = abs(y1 - y0);
    int sx = (x0 < x1) ? 1 : -1;
    int sy = (y0 < y1) ? 1 : -1;
    int err = dx - dy;
    while (true) {
        plot(x0, y0);
        if (x0 == x1 && y0 == y1)
            break;
        int e2 = 2 * err;
        if (e2 > -dy) {
            err -= dy;
            x0 += sx;
        }
        if (e2 < dx) {
            err += dx;
            y0 += sy;
        }
    }
}
 
class SpaceRoxWindow : public mxvk::VK_Window {
  public:
    SpaceRoxWindow(const std::string &path, int wx, int wy, bool full, bool enable_vsync)
        : mxvk::VK_Window("-[ SpaceRox - MXVK ]-", wx, wy, full, MXVK_VALIDATION, enable_vsync),
          current_path((path.empty() || path == ".") ? std::string(asteroids_ASSET_DIR) : path),
          w(wx),
          h(wy) {
        srand(static_cast<unsigned>(time(nullptr)));
    }
    virtual ~SpaceRoxWindow() {
        if (gamepad != nullptr) {
            SDL_CloseGamepad(gamepad);
            gamepad = nullptr;
        }
    }
 
    void proc() override {
        initializeResources();
        if (!resources_initialized || pixel == nullptr || starSprite == nullptr) {
            return;
        }
 
        refreshWindowSize();
 
        Uint32 currentTime = SDL_GetTicks();
        Uint32 frameTime = currentTime - lastFrameTime;
        if (frameTime < targetFrameTime) {
            SDL_Delay(targetFrameTime - frameTime);
            currentTime = SDL_GetTicks();
            frameTime = currentTime - lastFrameTime;
        }
 
        if (lastFrameTime > 0) {
            float deltaTime = frameTime / 1000.0f;
            globalTime += deltaTime;
        }
        lastFrameTime = currentTime;
 
        updateFontSize();
 
        pollController();
 
        const bool *keys = SDL_GetKeyboardState(nullptr);
 
        switch (state) {
        case STATE_COUNTDOWN:
            updateCountdown();
            drawCountdown();
            break;
        case STATE_LAUNCH:
            updateLaunch();
            drawLaunch();
            break;
        case STATE_PLAYING:
 
            if ((keys[SDL_SCANCODE_SPACE] || joyFire) && canFire()) {
                fireProjectile(ship.x, ship.y, ship.angle);
            }
            updateShip();
            updateFireTimer(keys);
            updateProjectiles();
            updateAsteroids();
            updateExplosion();
            checkAsteroidCollisions();
            checkShipAsteroidCollision();
            checkProjectileAsteroidCollisions();
            checkAndSpawnAsteroids();
            handleDeathSequence();
            drawGame();
            break;
        case STATE_GAMEOVER:
            drawGameOver();
            break;
        }
    }
 
    void event(SDL_Event &e) override {
        switch (e.type) {
        case SDL_EVENT_QUIT:
            exit();
            break;
        case SDL_EVENT_KEY_DOWN:
            if (e.key.key == SDLK_ESCAPE) {
                exit();
            }
            if (e.key.key == SDLK_SPACE && state == STATE_GAMEOVER) {
                restartGame();
            }
            if (state == STATE_PLAYING) {
                if (e.key.key == SDLK_LEFT)
                    keyLeft = true;
                if (e.key.key == SDLK_RIGHT)
                    keyRight = true;
                if (e.key.key == SDLK_UP)
                    keyThrust = true;
            }
            break;
        case SDL_EVENT_KEY_UP:
            if (state == STATE_PLAYING) {
                if (e.key.key == SDLK_LEFT)
                    keyLeft = false;
                if (e.key.key == SDLK_RIGHT)
                    keyRight = false;
                if (e.key.key == SDLK_UP)
                    keyThrust = false;
            }
            break;
        case SDL_EVENT_GAMEPAD_ADDED:
            openGamepad(e.gdevice.which);
            joyRestLX = 0;
            joyRestLY = 0;
            break;
        case SDL_EVENT_GAMEPAD_REMOVED:
            if (gamepad != nullptr && e.gdevice.which == gamepadId) {
                SDL_CloseGamepad(gamepad);
                gamepad = nullptr;
                gamepadId = 0;
                joyLeft = joyRight = joyThrust = joyFire = false;
                joyRestLX = 0;
                joyRestLY = 0;
                joyCenterStable = 0;
            }
            break;
        case SDL_EVENT_GAMEPAD_BUTTON_DOWN:
            handleControllerButton(e.gbutton.button);
            break;
        case SDL_EVENT_GAMEPAD_BUTTON_UP:
            handleControllerButtonUp(e.gbutton.button);
            break;
        }
    }
 
    void handleControllerButton(Uint8 button) {
        switch (state) {
        case STATE_GAMEOVER:
            if (button == SDL_GAMEPAD_BUTTON_SOUTH || button == SDL_GAMEPAD_BUTTON_START) {
                restartGame();
            }
            break;
        case STATE_PLAYING:
            if (button == SDL_GAMEPAD_BUTTON_SOUTH) {
                joyFire = true;
            } else if (button == SDL_GAMEPAD_BUTTON_EAST || button == SDL_GAMEPAD_BUTTON_BACK) {
 
            } else if (button == SDL_GAMEPAD_BUTTON_START) {
            }
            break;
        default:
            break;
        }
    }
 
    void handleControllerButtonUp(Uint8 button) {
        if (state == STATE_PLAYING) {
            if (button == SDL_GAMEPAD_BUTTON_SOUTH) {
                joyFire = false;
            }
        }
    }
 
    void pollController() {
        if (gamepad == nullptr) {
            joyLeft = joyRight = joyThrust = joyFire = false;
            joyCenterStable = 0;
            return;
        }
 
        if (SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_START)) {
            exit();
            return;
        }
 
        if (state != STATE_PLAYING || ship.exploding) {
            joyLeft = joyRight = joyThrust = joyFire = false;
            return;
        }
 
        Sint16 rawLX = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTX);
        Sint16 rawLY = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTY);
 
        if (abs(rawLX) < JOY_RECENTER_ZONE && abs(rawLY) < JOY_RECENTER_ZONE) {
            if (joyCenterStable < JOY_RECENTER_FRAMES) {
                joyCenterStable++;
            }
            if (joyCenterStable >= JOY_RECENTER_FRAMES) {
                joyRestLX = rawLX;
                joyRestLY = rawLY;
            }
        } else {
            joyCenterStable = 0;
        }
 
        int lx = static_cast<int>(rawLX) - static_cast<int>(joyRestLX);
        int ly = static_cast<int>(rawLY) - static_cast<int>(joyRestLY);
        joyLeft = (lx < -JOY_ROTATE_ZONE);
        joyRight = (lx > JOY_ROTATE_ZONE);
        joyThrust = (ly < -JOY_THRUST_ZONE);
        Sint16 rt = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER);
        joyFire = (rt > JOY_THRUST_ZONE) || SDL_GetGamepadButton(gamepad, SDL_GAMEPAD_BUTTON_SOUTH);
    }
 
  private:
    std::string current_path;
    bool resources_initialized = false;
    int w = GAME_W;
    int h = GAME_H;
 
    mxvk::VK_Sprite *pixel = nullptr;
    mxvk::VK_Sprite *starSprite = nullptr;
 
    Uint32 lastFrameTime = 0;
    static constexpr Uint32 targetFrameTime = 1000 / 60;
    float globalTime = 0.0f;
 
    Ship ship{};
    Projectile projectiles[MAX_PROJECTILES]{};
    Asteroid asteroids[MAX_ASTEROIDS]{};
    Particle particles[MAX_PARTICLES]{};
    Star stars[STAR_COUNT * 3]{};
    bool starsInit = false;
 
    GameState state = STATE_COUNTDOWN;
    bool keyLeft = false, keyRight = false, keyThrust = false;
    bool keyFire = false;
    bool joyLeft = false, joyRight = false, joyThrust = false;
    bool joyFire = false;
    bool wasExploding = false;
 
    SDL_Gamepad *gamepad = nullptr;
    SDL_JoystickID gamepadId = 0;
    static constexpr Sint16 JOY_ROTATE_ZONE = 16000;
    static constexpr Sint16 JOY_THRUST_ZONE = 12000;
    static constexpr Sint16 JOY_RECENTER_ZONE = 8000;
    static constexpr int JOY_RECENTER_FRAMES = 12;
    Sint16 joyRestLX = 0, joyRestLY = 0;
    int joyCenterStable = 0;
 
    Uint32 countdownTimer = 0;
    Uint32 countdownDuration = 1000;
    Uint32 countdownStartMs = 0;
    int countdownNumber = 3;
    Uint32 launchTimer = 0;
    Uint32 launchDuration = 1000;
    Uint32 launchStartMs = 0;
    float shipLaunchY = 0;
 
    int lastFontSize = 0;
 
    float sx() const { return static_cast<float>(w) / GAME_W; }
    float sy() const { return static_cast<float>(h) / GAME_H; }
 
    int toScreenX(float gx) const { return static_cast<int>(gx * sx()); }
    int toScreenY(float gy) const { return static_cast<int>(gy * sy()); }
    int toScreenW(float gw) const { return std::max(1, static_cast<int>(gw * sx())); }
    int toScreenH(float gh) const { return std::max(1, static_cast<int>(gh * sy())); }
 
    void refreshWindowSize() {
        if (window != nullptr) {
            SDL_GetWindowSizeInPixels(window.get(), &w, &h);
        }
    }
 
    bool openGamepad(SDL_JoystickID id) {
        if (gamepad != nullptr && gamepadId == id) {
            return true;
        }
        if (gamepad != nullptr) {
            SDL_CloseGamepad(gamepad);
            gamepad = nullptr;
            gamepadId = 0;
        }
        gamepad = SDL_OpenGamepad(id);
        if (gamepad == nullptr) {
            return false;
        }
        gamepadId = id;
        return true;
    }
 
    void tryOpenFirstGamepad() {
        if (gamepad != nullptr) {
            return;
        }
        int count = 0;
        SDL_JoystickID *ids = SDL_GetGamepads(&count);
        if (ids == nullptr || count <= 0) {
            if (ids != nullptr) {
                SDL_free(ids);
            }
            return;
        }
        openGamepad(ids[0]);
        SDL_free(ids);
    }
 
    void initializeResources() {
        if (resources_initialized) {
            return;
        }
 
        tryOpenFirstGamepad();
 
        std::array<std::uint8_t, 4 * 4 * 4> starPixels{};
        for (int y = 0; y < 4; y++) {
            for (int x = 0; x < 4; x++) {
                float dx = (x - 1.5f) / 1.5f;
                float dy = (y - 1.5f) / 1.5f;
                float dist = sqrtf(dx * dx + dy * dy);
                std::uint8_t alpha = (dist < 1.0f) ? static_cast<std::uint8_t>(255.0f * (1.0f - dist)) : 0;
                const int idx = (y * 4 + x) * 4;
                starPixels[idx + 0] = 255;
                starPixels[idx + 1] = 255;
                starPixels[idx + 2] = 255;
                starPixels[idx + 3] = alpha;
            }
        }
 
        starSprite = createSprite(
            4,
            4,
            current_path + "/data/sprite_vert.spv",
            current_path + "/data/sprite_frag.spv");
        starSprite->updateTexture(starPixels.data(), 4, 4, 4 * 4);
 
        const std::array<std::uint8_t, 2 * 2 * 4> whitePixels{
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
            255,
        };
 
        pixel = createSprite(
            2,
            2,
            current_path + "/data/sprite_vert.spv",
            current_path + "/data/solid_frag.spv");
        pixel->updateTexture(whitePixels.data(), 2, 2, 2 * 4);
 
        initGame();
        resources_initialized = true;
    }
 
    void setColor(float r, float g, float b, float a = 1.0f) {
        pixel->setShaderParams(r, g, b, a);
    }
 
    void drawPixel(float gx, float gy) {
        int psz = std::max(1, static_cast<int>(2.0f * std::min(sx(), sy())));
        pixel->drawSpriteRect(toScreenX(gx), toScreenY(gy), psz, psz);
    }
 
    void drawRect(float gx, float gy, float gw, float gh) {
        pixel->drawSpriteRect(toScreenX(gx), toScreenY(gy), toScreenW(gw), toScreenH(gh));
    }
 
    void drawLine(float x0f, float y0f, float x1f, float y1f) {
        int x0 = toScreenX(x0f), y0 = toScreenY(y0f);
        int x1 = toScreenX(x1f), y1 = toScreenY(y1f);
        int psz = std::max(1, static_cast<int>(1.5f * std::min(sx(), sy())));
        bresenhamLine(x0, y0, x1, y1, [&](int px, int py) {
            pixel->drawSpriteRect(px, py, psz, psz);
        });
    }
 
    void drawPoint(int screenX, int screenY, int size = 2) {
        pixel->drawSpriteRect(screenX, screenY, size, size);
    }
 
    void updateFontSize() {
        int fontSize = static_cast<int>(20.0f * (static_cast<float>(h) / 480.0f));
        fontSize = std::max(14, std::min(128, fontSize));
        if (fontSize != lastFontSize) {
            lastFontSize = fontSize;
            setFont(current_path + "/data/font.ttf", fontSize);
            clearTextQueue();
        }
    }
 
    void initGame() {
        initShip();
        initProjectiles();
        initAsteroids();
        initStars();
        state = STATE_COUNTDOWN;
        countdownTimer = 0;
        countdownNumber = 3;
        countdownStartMs = SDL_GetTicks();
        launchStartMs = 0;
        wasExploding = false;
    }
 
    void restartGame() {
        initGame();
    }
 
    void initStars() {
        int starIndex = 0;
 
        for (int i = 0; i < STAR_COUNT; ++i, ++starIndex) {
            stars[starIndex].x = static_cast<float>(rand() % GAME_W);
            stars[starIndex].y = static_cast<float>(rand() % GAME_H);
            stars[starIndex].speed = 0.15f + (rand() % 40) / 100.0f;
            stars[starIndex].size = 0.8f + (rand() % 12) / 20.0f;
            stars[starIndex].brightness = 0.25f + (rand() % 45) / 100.0f;
            stars[starIndex].layer = 0;
            assignStarColor(stars[starIndex]);
            stars[starIndex].twinklePhase = (rand() % 628) / 100.0f;
            stars[starIndex].twinkleSpeed = 0.4f + (rand() % 150) / 100.0f;
        }
 
        for (int i = 0; i < STAR_COUNT; ++i, ++starIndex) {
            stars[starIndex].x = static_cast<float>(rand() % GAME_W);
            stars[starIndex].y = static_cast<float>(rand() % GAME_H);
            stars[starIndex].speed = 0.4f + (rand() % 80) / 100.0f;
            stars[starIndex].size = 1.2f + (rand() % 18) / 20.0f;
            stars[starIndex].brightness = 0.45f + (rand() % 55) / 100.0f;
            stars[starIndex].layer = 1;
            assignStarColor(stars[starIndex]);
            stars[starIndex].twinklePhase = (rand() % 628) / 100.0f;
            stars[starIndex].twinkleSpeed = 0.8f + (rand() % 250) / 100.0f;
        }
 
        for (int i = 0; i < STAR_COUNT; ++i, ++starIndex) {
            stars[starIndex].x = static_cast<float>(rand() % GAME_W);
            stars[starIndex].y = static_cast<float>(rand() % GAME_H);
            stars[starIndex].speed = 0.8f + (rand() % 180) / 100.0f;
            stars[starIndex].size = 1.8f + (rand() % 25) / 20.0f;
            stars[starIndex].brightness = 0.65f + (rand() % 35) / 100.0f;
            stars[starIndex].layer = 2;
            assignStarColor(stars[starIndex]);
            stars[starIndex].twinklePhase = (rand() % 628) / 100.0f;
            stars[starIndex].twinkleSpeed = 1.2f + (rand() % 350) / 100.0f;
        }
        starsInit = true;
    }
 
    void assignStarColor(Star &s) {
        float roll = (rand() % 1000) / 1000.0f;
        if (roll < 0.35f) {
 
            s.r = 0.85f + (rand() % 15) / 100.0f;
            s.g = 0.90f + (rand() % 10) / 100.0f;
            s.b = 1.0f;
        } else if (roll < 0.55f) {
 
            s.r = 0.5f + (rand() % 20) / 100.0f;
            s.g = 0.75f + (rand() % 15) / 100.0f;
            s.b = 1.0f;
            s.size *= 1.15f;
            s.brightness *= 1.1f;
        } else if (roll < 0.70f) {
 
            s.r = 1.0f;
            s.g = 0.95f + (rand() % 5) / 100.0f;
            s.b = 0.6f + (rand() % 30) / 100.0f;
            s.size *= 1.05f;
        } else if (roll < 0.82f) {
 
            s.r = 1.0f;
            s.g = 0.6f + (rand() % 20) / 100.0f;
            s.b = 0.2f + (rand() % 20) / 100.0f;
            s.size *= 1.1f;
        } else if (roll < 0.90f) {
 
            s.r = 1.0f;
            s.g = 0.3f + (rand() % 20) / 100.0f;
            s.b = 0.2f + (rand() % 15) / 100.0f;
            s.size *= 1.08f;
        } else if (roll < 0.96f) {
 
            s.r = 1.0f;
            s.g = 1.0f;
            s.b = 1.0f;
            s.size *= 1.4f;
            s.brightness *= 1.4f;
        } else {
 
            s.r = 0.9f;
            s.g = 0.95f;
            s.b = 1.0f;
            s.size *= 1.6f;
            s.brightness *= 1.5f;
        }
    }
 
    void initShip() {
        ship.x = GAME_W / 2.0f;
        ship.y = GAME_H / 2.0f;
        ship.vx = 0;
        ship.vy = 0;
        ship.angle = 0;
        ship.lives = 3;
        ship.fire_cooldown = 0;
        ship.burst_count = 0;
        ship.exploding = false;
        ship.explosion_timer = 0;
        ship.score = 0;
        ship.continuous_fire_timer = 0;
        ship.overheated = false;
        ship.overheat_cooldown = 0;
        for (auto &p : particles)
            p.active = false;
    }
 
    void initProjectiles() {
        for (auto &p : projectiles)
            p.active = false;
    }
 
    void initAsteroids() {
        for (auto &a : asteroids)
            a.active = false;
        for (int i = 0; i < 4; ++i) {
            float x, y;
            do {
                x = static_cast<float>(rand() % GAME_W);
                y = static_cast<float>(rand() % GAME_H);
            } while (hypotf(x - ship.x, y - ship.y) < 100);
            float vx = ((rand() % 100) - 50) / 50.0f;
            float vy = ((rand() % 100) - 50) / 50.0f;
            float radius = 20.0f + (rand() % 20);
            spawnAsteroid(x, y, vx, vy, radius);
        }
    }
 
    void updateShip() {
        if (ship.exploding)
            return;
        if (keyLeft || joyLeft)
            ship.angle -= 0.15f;
        if (keyRight || joyRight)
            ship.angle += 0.15f;
        if (keyThrust || joyThrust) {
            float thrust = 0.2f;
            ship.vx += sinf(ship.angle) * thrust;
            ship.vy += -cosf(ship.angle) * thrust;
            float spd = sqrtf(ship.vx * ship.vx + ship.vy * ship.vy);
            float maxSpd = 4.0f;
            if (spd > maxSpd) {
                ship.vx = (ship.vx / spd) * maxSpd;
                ship.vy = (ship.vy / spd) * maxSpd;
            }
        }
        ship.vx *= 0.98f;
        ship.vy *= 0.98f;
        ship.x += ship.vx;
        ship.y += ship.vy;
 
        if (ship.x < 0)
            ship.x += GAME_W;
        if (ship.x >= GAME_W)
            ship.x -= GAME_W;
        if (ship.y < 0)
            ship.y += GAME_H;
        if (ship.y >= GAME_H)
            ship.y -= GAME_H;
        if (ship.fire_cooldown > 0)
            ship.fire_cooldown--;
    }
 
    void updateFireTimer(const bool *keys) {
        bool firing = keys[SDL_SCANCODE_SPACE] || joyFire;
        if (firing && !ship.overheated) {
            ship.continuous_fire_timer++;
            ship.overheat_cooldown = 0;
            if (ship.continuous_fire_timer >= 180) {
                ship.overheated = true;
                ship.overheat_cooldown = 0;
                ship.continuous_fire_timer = 0;
                ship.burst_count = 0;
            }
        } else if (firing && ship.overheated) {
            ship.overheat_cooldown = 0;
        } else {
            if (ship.overheated) {
                ship.overheat_cooldown++;
                if (ship.overheat_cooldown >= 180) {
                    ship.overheated = false;
                    ship.overheat_cooldown = 0;
                    ship.continuous_fire_timer = 0;
                }
            } else {
                if (ship.continuous_fire_timer > 0)
                    ship.continuous_fire_timer--;
            }
        }
    }
 
    bool canFire() {
        if (ship.overheated)
            return false;
        if (ship.fire_cooldown <= 0) {
            if (ship.burst_count < SHOTS_PER_BURST) {
                ship.fire_cooldown = FIRE_DELAY;
                ship.burst_count++;
                return true;
            } else {
                ship.fire_cooldown = FIRE_COOLDOWN;
                ship.burst_count = 0;
                return false;
            }
        }
        return false;
    }
 
    void fireProjectile(float x, float y, float angle) {
        for (auto &p : projectiles) {
            if (!p.active) {
                float c = cosf(angle), s = sinf(angle);
                float lx = 0, ly = -12;
                p.x = x + (lx * c - ly * s);
                p.y = y + (lx * s + ly * c);
                p.vx = sinf(angle) * PROJECTILE_SPEED;
                p.vy = -cosf(angle) * PROJECTILE_SPEED;
                p.lifetime = PROJECTILE_LIFETIME;
                p.active = true;
                break;
            }
        }
    }
 
    void updateProjectiles() {
        for (auto &p : projectiles) {
            if (!p.active)
                continue;
            p.x += p.vx;
            p.y += p.vy;
            if (p.x < 0 || p.x >= GAME_W || p.y < 0 || p.y >= GAME_H) {
                p.active = false;
                continue;
            }
            p.lifetime--;
            if (p.lifetime <= 0)
                p.active = false;
        }
    }
 
    void spawnAsteroid(float x, float y, float vx, float vy, float radius) {
        for (auto &a : asteroids) {
            if (!a.active) {
                a.x = x;
                a.y = y;
                a.vx = vx;
                a.vy = vy;
                a.radius = radius;
                a.active = true;
                a.rotation_angle = 0;
                a.rotation_speed = ((rand() % 100) - 50) / 1000.0f;
                for (int j = 0; j < ASTEROID_VERTICES; ++j) {
                    float ang = static_cast<float>(j) / ASTEROID_VERTICES * 2 * M_PI;
                    float vr = radius * (0.7f + (rand() % 30) / 100.0f);
                    a.vertices[j][0] = cosf(ang) * vr;
                    a.vertices[j][1] = sinf(ang) * vr;
                }
                break;
            }
        }
    }
 
    void updateAsteroids() {
        for (auto &a : asteroids) {
            if (!a.active)
                continue;
            a.x += a.vx;
            a.y += a.vy;
            a.rotation_angle += a.rotation_speed;
            if (a.x < 0)
                a.x += GAME_W;
            if (a.x >= GAME_W)
                a.x -= GAME_W;
            if (a.y < 0)
                a.y += GAME_H;
            if (a.y >= GAME_H)
                a.y -= GAME_H;
        }
    }
 
    void splitAsteroid(int idx) {
        float x = asteroids[idx].x;
        float y = asteroids[idx].y;
        float r = asteroids[idx].radius / 2.0f;
        if (r < MIN_ASTEROID_RADIUS) {
            createAsteroidExplosion(x, y);
            ship.score += SMALL_ASTEROID_POINTS;
            asteroids[idx].active = false;
            return;
        }
        int splits = 2 + (rand() % 2);
        for (int i = 0; i < splits; ++i) {
            float ang = (rand() % 628) / 100.0f;
            float spd = 0.5f + (rand() % 15) / 10.0f;
            float nvx = cosf(ang) * spd + asteroids[idx].vx * 0.3f;
            float nvy = sinf(ang) * spd + asteroids[idx].vy * 0.3f;
            float off = r * 0.5f;
            spawnAsteroid(x + cosf(ang) * off, y + sinf(ang) * off, nvx, nvy, r);
        }
        if (r >= 25.0f)
            ship.score += LARGE_ASTEROID_POINTS;
        else
            ship.score += MEDIUM_ASTEROID_POINTS;
        createAsteroidExplosion(x, y);
        asteroids[idx].active = false;
    }
 
    void checkAndSpawnAsteroids() {
        int active = 0;
        for (auto &a : asteroids)
            if (a.active)
                active++;
        int minAsteroids = 3;
        if (active < minAsteroids) {
            for (int s = 0; s < minAsteroids - active; ++s) {
                float x, y;
                int attempts = 0;
                do {
                    if (rand() % 2) {
                        x = (rand() % 2) ? -30.0f : GAME_W + 30.0f;
                        y = static_cast<float>(rand() % GAME_H);
                    } else {
                        x = static_cast<float>(rand() % GAME_W);
                        y = (rand() % 2) ? -30.0f : GAME_H + 30.0f;
                    }
                    attempts++;
                } while (hypotf(x - ship.x, y - ship.y) < 100.0f && attempts < 10);
                float vx = ((rand() % 100) - 50) / 50.0f;
                float vy = ((rand() % 100) - 50) / 50.0f;
                float radius;
                int roll = rand() % 100;
                if (roll < 20)
                    radius = 30.0f + (rand() % 15);
                else if (roll < 60)
                    radius = 20.0f + (rand() % 10);
                else
                    radius = 12.0f + (rand() % 8);
                spawnAsteroid(x, y, vx, vy, radius);
            }
        }
    }
 
    void checkAsteroidCollisions() {
        for (int i = 0; i < MAX_ASTEROIDS; ++i) {
            if (!asteroids[i].active)
                continue;
            for (int j = i + 1; j < MAX_ASTEROIDS; ++j) {
                if (!asteroids[j].active)
                    continue;
                float dx = asteroids[i].x - asteroids[j].x;
                float dy = asteroids[i].y - asteroids[j].y;
                float dist = sqrtf(dx * dx + dy * dy);
                float minDist = asteroids[i].radius + asteroids[j].radius;
                if (dist < minDist && dist > 0) {
                    float nx = dx / dist, ny = dy / dist;
                    float overlap = (minDist - dist) * 0.5f;
                    asteroids[i].x += nx * overlap;
                    asteroids[i].y += ny * overlap;
                    asteroids[j].x -= nx * overlap;
                    asteroids[j].y -= ny * overlap;
                    float rvx = asteroids[i].vx - asteroids[j].vx;
                    float rvy = asteroids[i].vy - asteroids[j].vy;
                    float van = rvx * nx + rvy * ny;
                    if (van > 0)
                        continue;
                    float restitution = 0.8f;
                    float impulse = -(1 + restitution) * van * 0.5f;
                    asteroids[i].vx += impulse * nx;
                    asteroids[i].vy += impulse * ny;
                    asteroids[j].vx -= impulse * nx;
                    asteroids[j].vy -= impulse * ny;
                }
            }
        }
    }
 
    void checkShipAsteroidCollision() {
        if (ship.exploding)
            return;
        for (int i = 0; i < MAX_ASTEROIDS; ++i) {
            if (!asteroids[i].active)
                continue;
            float dx = ship.x - asteroids[i].x;
            float dy = ship.y - asteroids[i].y;
            float dist = sqrtf(dx * dx + dy * dy);
            float shipRadius = 8.0f;
            if (dist < asteroids[i].radius + shipRadius) {
                startShipExplosion();
                createAsteroidExplosion(ship.x + dx * 0.5f, ship.y + dy * 0.5f);
                if (dist > 0) {
                    float nx = -dx / dist, ny = -dy / dist;
                    asteroids[i].vx += nx * 2.0f;
                    asteroids[i].vy += ny * 2.0f;
                }
                break;
            }
        }
    }
 
    void checkProjectileAsteroidCollisions() {
        for (auto &p : projectiles) {
            if (!p.active)
                continue;
            for (int j = 0; j < MAX_ASTEROIDS; ++j) {
                if (!asteroids[j].active)
                    continue;
                float dx = p.x - asteroids[j].x;
                float dy = p.y - asteroids[j].y;
                if (sqrtf(dx * dx + dy * dy) < asteroids[j].radius) {
                    p.active = false;
                    if (asteroids[j].radius >= 20.0f)
                        ship.score += LARGE_ASTEROID_POINTS;
                    else if (asteroids[j].radius >= MIN_ASTEROID_RADIUS)
                        ship.score += MEDIUM_ASTEROID_POINTS;
                    else
                        ship.score += SMALL_ASTEROID_POINTS;
                    splitAsteroid(j);
                    break;
                }
            }
        }
    }
 
    void startShipExplosion() {
        if (ship.exploding)
            return;
        ship.exploding = true;
        ship.explosion_timer = EXPLOSION_DURATION;
        ship.lives--;
        ship.overheated = false;
        ship.overheat_cooldown = 0;
        ship.continuous_fire_timer = 0;
        ship.burst_count = 0;
        for (auto &p : particles) {
            p.x = ship.x + ((rand() % 20) - 10);
            p.y = ship.y + ((rand() % 20) - 10);
            float ang = (rand() % 628) / 100.0f;
            float spd = 0.5f + (rand() % 20) / 10.0f;
            p.vx = cosf(ang) * spd;
            p.vy = sinf(ang) * spd;
            p.lifetime = 30 + (rand() % 60);
            p.active = true;
        }
    }
 
    void createAsteroidExplosion(float x, float y) {
        int toCreate = 15 + (rand() % 10);
        int created = 0;
        for (auto &p : particles) {
            if (created >= toCreate)
                break;
            if (!p.active) {
                p.x = x + ((rand() % 16) - 8);
                p.y = y + ((rand() % 16) - 8);
                float ang = (rand() % 628) / 100.0f;
                float spd = 1.0f + (rand() % 20) / 10.0f;
                p.vx = cosf(ang) * spd;
                p.vy = sinf(ang) * spd;
                p.lifetime = 15 + (rand() % 25);
                p.active = true;
                created++;
            }
        }
    }
 
    void updateExplosion() {
        for (auto &p : particles) {
            if (!p.active)
                continue;
            p.x += p.vx;
            p.y += p.vy;
            p.vx *= 0.97f;
            p.vy *= 0.97f;
            p.lifetime--;
            if (p.lifetime <= 0) {
                p.active = false;
                continue;
            }
            if (p.x < 0)
                p.x += GAME_W;
            if (p.x >= GAME_W)
                p.x -= GAME_W;
            if (p.y < 0)
                p.y += GAME_H;
            if (p.y >= GAME_H)
                p.y -= GAME_H;
        }
        if (ship.exploding) {
            ship.explosion_timer--;
            if (ship.explosion_timer <= 0)
                ship.exploding = false;
        }
    }
 
    void handleDeathSequence() {
        if (wasExploding && !ship.exploding) {
            if (ship.lives > 0) {
                triggerRespawn();
            } else {
                state = STATE_GAMEOVER;
            }
            wasExploding = false;
        } else if (ship.exploding) {
            wasExploding = true;
        }
    }
 
    void triggerRespawn() {
        ship.x = GAME_W / 2.0f;
        ship.y = GAME_H / 2.0f;
        ship.vx = 0;
        ship.vy = 0;
        ship.angle = 0;
        ship.exploding = false;
        ship.explosion_timer = 0;
        keyLeft = keyRight = keyThrust = keyFire = false;
        joyLeft = joyRight = joyThrust = joyFire = false;
        state = STATE_COUNTDOWN;
        countdownTimer = 0;
        countdownNumber = 3;
        countdownStartMs = SDL_GetTicks();
        launchStartMs = 0;
    }
 
    void updateCountdown() {
        const Uint32 now = SDL_GetTicks();
        const Uint32 elapsed = now - countdownStartMs;
 
        countdownTimer = elapsed % countdownDuration;
        countdownNumber = 3 - static_cast<int>(elapsed / countdownDuration);
 
        if (elapsed >= (countdownDuration * 4U)) {
            state = STATE_LAUNCH;
            launchTimer = 0;
            launchStartMs = now;
            shipLaunchY = static_cast<float>(GAME_H);
        }
    }
 
    void updateLaunch() {
        const Uint32 now = SDL_GetTicks();
        launchTimer = std::min<Uint32>(now - launchStartMs, launchDuration);
        if (launchTimer < launchDuration / 2U) {
            shipLaunchY = static_cast<float>(GAME_H) -
                          (static_cast<float>(launchTimer) * (static_cast<float>(GAME_H) - ship.y) /
                           static_cast<float>(launchDuration / 2U));
        } else {
            shipLaunchY = ship.y;
        }
        if (launchTimer >= launchDuration) {
            state = STATE_PLAYING;
            if (gamepad != nullptr) {
                joyRestLX = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTX);
                joyRestLY = SDL_GetGamepadAxis(gamepad, SDL_GAMEPAD_AXIS_LEFTY);
            }
        }
    }
 
    void drawStars(float speedMul = 1.0f) {
 
        for (auto &s : stars) {
            s.y += s.speed * speedMul;
            if (s.y >= GAME_H) {
                s.x = static_cast<float>(rand() % GAME_W);
                s.y = 0;
 
                if (s.layer == 0) {
                    s.speed = 0.15f + (rand() % 40) / 100.0f;
                    s.size = 0.8f + (rand() % 12) / 20.0f;
                    s.brightness = 0.25f + (rand() % 45) / 100.0f;
                } else if (s.layer == 1) {
                    s.speed = 0.4f + (rand() % 80) / 100.0f;
                    s.size = 1.2f + (rand() % 18) / 20.0f;
                    s.brightness = 0.45f + (rand() % 55) / 100.0f;
                } else {
                    s.speed = 0.8f + (rand() % 180) / 100.0f;
                    s.size = 1.8f + (rand() % 25) / 20.0f;
                    s.brightness = 0.65f + (rand() % 35) / 100.0f;
                }
                assignStarColor(s);
                s.twinklePhase = (rand() % 628) / 100.0f;
            }
 
            s.twinklePhase += s.twinkleSpeed * 0.016f;
            float twinkle = 0.7f + 0.3f * sinf(s.twinklePhase);
            float finalBrightness = s.brightness * twinkle;
 
            starSprite->setShaderParams(
                s.r * finalBrightness,
                s.g * finalBrightness,
                s.b * finalBrightness,
                finalBrightness);
 
            int screenSize = static_cast<int>(s.size * std::min(sx(), sy()));
            screenSize = std::max(2, screenSize);
            starSprite->drawSpriteRect(toScreenX(s.x), toScreenY(s.y), screenSize, screenSize);
        }
    }
 
    void drawShipAt(float px, float py) {
        if (ship.exploding) {
            drawExplosion();
            return;
        }
        float c = cosf(ship.angle), s = sinf(ship.angle);
        auto rot = [&](float lx, float ly, float &ox, float &oy) {
            ox = px + (lx * c - ly * s);
            oy = py + (lx * s + ly * c);
        };
 
        float nose_x, nose_y, lw_x, lw_y, rw_x, rw_y;
        float le_x, le_y, re_x, re_y, ce_x, ce_y;
        float ld_x, ld_y, rd_x, rd_y;
        float cl_x, cl_y, cr_x, cr_y, cc_x, cc_y;
 
        rot(0, -15, nose_x, nose_y);
        rot(-12, 8, lw_x, lw_y);
        rot(12, 8, rw_x, rw_y);
        rot(-8, 12, le_x, le_y);
        rot(8, 12, re_x, re_y);
        rot(0, 10, ce_x, ce_y);
        rot(-6, 2, ld_x, ld_y);
        rot(6, 2, rd_x, rd_y);
        rot(-3, -8, cl_x, cl_y);
        rot(3, -8, cr_x, cr_y);
        rot(0, -5, cc_x, cc_y);
 
        if (ship.overheated) {
            setColor(1.0f, 0.0f, 0.0f, 1.0f);
        } else if (ship.continuous_fire_timer > 120) {
            int heat = ship.continuous_fire_timer - 120;
            setColor(1.0f, std::max(0.0f, 1.0f - heat / 64.0f), 0.0f, 1.0f);
        } else {
            setColor(1.0f, 1.0f, 1.0f, 1.0f);
        }
 
        drawLine(nose_x, nose_y, lw_x, lw_y);
        drawLine(nose_x, nose_y, rw_x, rw_y);
        drawLine(lw_x, lw_y, rw_x, rw_y);
 
        drawLine(lw_x, lw_y, le_x, le_y);
        drawLine(rw_x, rw_y, re_x, re_y);
        drawLine(le_x, le_y, ce_x, ce_y);
        drawLine(re_x, re_y, ce_x, ce_y);
 
        if (ship.overheated)
            setColor(0.78f, 0.0f, 0.0f, 1.0f);
        else if (ship.continuous_fire_timer > 120)
            setColor(0.78f, std::max(0.0f, 0.78f - (ship.continuous_fire_timer - 120) / 80.0f), 0.0f, 1.0f);
        else
            setColor(0.78f, 0.78f, 0.78f, 1.0f);
        drawLine(nose_x, nose_y, ld_x, ld_y);
        drawLine(nose_x, nose_y, rd_x, rd_y);
        drawLine(ld_x, ld_y, rd_x, rd_y);
        drawLine(ld_x, ld_y, lw_x, lw_y);
        drawLine(rd_x, rd_y, rw_x, rw_y);
 
        if (ship.overheated)
            setColor(0.0f, 0.5f, 0.5f, 1.0f);
        else
            setColor(0.0f, 1.0f, 1.0f, 1.0f);
        drawLine(cl_x, cl_y, cr_x, cr_y);
        drawLine(cl_x, cl_y, cc_x, cc_y);
        drawLine(cr_x, cr_y, cc_x, cc_y);
 
        setColor(0.59f, 0.59f, 0.59f, 1.0f);
        drawLine(cc_x, cc_y, ce_x, ce_y);
 
        if (keyThrust || joyThrust) {
            float f1x, f1y, f2x, f2y, f3x, f3y;
            rot(-6, 18, f1x, f1y);
            rot(0, 22, f2x, f2y);
            rot(6, 18, f3x, f3y);
            setColor(1.0f, 0.39f, 0.0f, 1.0f);
            drawLine(le_x, le_y, f1x, f1y);
            drawLine(ce_x, ce_y, f2x, f2y);
            drawLine(re_x, re_y, f3x, f3y);
            float ifx, ify;
            rot(0, 20, ifx, ify);
            setColor(1.0f, 1.0f, 0.0f, 1.0f);
            drawLine(ce_x, ce_y, ifx, ify);
        }
    }
 
    void drawProjectiles() {
        setColor(1.0f, 0.0f, 0.0f, 1.0f);
        for (auto &p : projectiles) {
            if (!p.active)
                continue;
            float endX = p.x - p.vx * 0.5f;
            float endY = p.y - p.vy * 0.5f;
            drawLine(p.x, p.y, endX, endY);
        }
    }
 
    void drawAsteroids() {
        for (int i = 0; i < MAX_ASTEROIDS; ++i) {
            if (!asteroids[i].active)
                continue;
            auto &a = asteroids[i];
            float cosR = cosf(a.rotation_angle);
            float sinR = sinf(a.rotation_angle);
 
            float rv[ASTEROID_VERTICES][2];
            for (int j = 0; j < ASTEROID_VERTICES; ++j) {
                rv[j][0] = a.vertices[j][0] * cosR - a.vertices[j][1] * sinR;
                rv[j][1] = a.vertices[j][0] * sinR + a.vertices[j][1] * cosR;
            }
 
            setColor(1.0f, 1.0f, 1.0f, 1.0f);
            for (int j = 0; j < ASTEROID_VERTICES; ++j) {
                int next = (j + 1) % ASTEROID_VERTICES;
                drawLine(a.x + rv[j][0], a.y + rv[j][1],
                         a.x + rv[next][0], a.y + rv[next][1]);
            }
 
            float iv[ASTEROID_VERTICES][2];
            for (int j = 0; j < ASTEROID_VERTICES; ++j) {
                iv[j][0] = rv[j][0] * 0.6f;
                iv[j][1] = rv[j][1] * 0.6f;
            }
            setColor(0.59f, 0.59f, 0.59f, 1.0f);
            for (int j = 0; j < ASTEROID_VERTICES; ++j) {
                int next = (j + 1) % ASTEROID_VERTICES;
                drawLine(a.x + iv[j][0], a.y + iv[j][1],
                         a.x + iv[next][0], a.y + iv[next][1]);
            }
 
            setColor(0.39f, 0.39f, 0.39f, 1.0f);
            for (int j = 0; j < ASTEROID_VERTICES; j += 2) {
                drawLine(a.x + rv[j][0], a.y + rv[j][1],
                         a.x + iv[j][0], a.y + iv[j][1]);
            }
 
            setColor(0.71f, 0.71f, 0.71f, 1.0f);
            for (int j = 0; j < ASTEROID_VERTICES; j += 2) {
                int next = (j + 1) % ASTEROID_VERTICES;
                drawLine(a.x + rv[j][0], a.y + rv[j][1],
                         a.x + iv[next][0], a.y + iv[next][1]);
            }
        }
    }
 
    void drawExplosion() {
        for (auto &p : particles) {
            if (!p.active)
                continue;
            float lp = static_cast<float>(p.lifetime) / 50.0f;
            if (lp > 0.7f)
                setColor(1.0f, 1.0f, 1.0f, 1.0f);
            else if (lp > 0.5f)
                setColor(1.0f, 1.0f, 0.0f, 1.0f);
            else if (lp > 0.2f)
                setColor(1.0f, 0.5f, 0.0f, 1.0f);
            else
                setColor(1.0f, 0.0f, 0.0f, 1.0f);
            drawRect(p.x, p.y, 2, 2);
        }
    }
 
    void drawHUD() {
        std::string buf = std::format("Score: {}", ship.score);
        printText(buf.c_str(), toScreenX(10), toScreenY(10), {255, 255, 255, 255});
        buf = std::format("Lives: {}", ship.lives);
        printText(buf.c_str(), toScreenX(10), toScreenY(30), {255, 255, 255, 255});
    }
 
    void drawCountdown() {
        drawStars(0.3f);
        if (countdownNumber > 0) {
            std::string buf = std::format("{}", countdownNumber);
 
            int textW, textH;
            if (getTextDimensions(buf.c_str(), textW, textH)) {
 
                int centerX = w / 2;
                int centerY = h / 2;
                int textX = centerX - textW / 2;
                int textY = centerY - textH / 2;
                printText(buf.c_str(), textX, textY, {255, 255, 0, 255});
 
                if (((countdownTimer / 167U) % 2U) != 0U) {
                    setColor(1.0f, 1.0f, 0.0f, 0.5f);
                    int padding = std::max(15, static_cast<int>(15 * std::min(sx(), sy())));
                    int rectX = textX - padding;
                    int rectY = textY - padding;
                    int rectW = textW + padding * 2;
                    int rectH = textH + padding * 2;
                    int thickness = std::max(3, static_cast<int>(3 * std::min(sx(), sy())));
 
                    pixel->drawSpriteRect(rectX, rectY, rectW, thickness);
 
                    pixel->drawSpriteRect(rectX, rectY + rectH - thickness, rectW, thickness);
 
                    pixel->drawSpriteRect(rectX, rectY, thickness, rectH);
 
                    pixel->drawSpriteRect(rectX + rectW - thickness, rectY, thickness, rectH);
                }
            }
        } else {
 
            int textW, textH;
            if (getTextDimensions("LAUNCH!", textW, textH)) {
                printText("LAUNCH!", w / 2 - textW / 2, h / 2 - textH / 2, {0, 255, 0, 255});
            } else {
                printText("LAUNCH!", toScreenX(270), toScreenY(160), {0, 255, 0, 255});
            }
        }
 
        int textW, textH;
        if (getTextDimensions("PREPARE FOR MISSION", textW, textH)) {
            printText("PREPARE FOR MISSION", w / 2 - textW / 2, h / 2 + textH * 2, {255, 255, 255, 255});
        } else {
            printText("PREPARE FOR MISSION", toScreenX(220), toScreenY(195), {255, 255, 255, 255});
        }
 
        std::string lbuf = std::format("Lives: {}", ship.lives);
        std::string sbuf = std::format("Score: {}", ship.score);
        if (getTextDimensions(lbuf.c_str(), textW, textH)) {
            printText(lbuf.c_str(), w / 2 - textW / 2, h / 2 + textH * 3 + 10, {255, 255, 255, 255});
            if (getTextDimensions(sbuf.c_str(), textW, textH)) {
                printText(sbuf.c_str(), w / 2 - textW / 2, h / 2 + textH * 4 + 15, {255, 255, 255, 255});
            }
        } else {
            printText(lbuf.c_str(), toScreenX(260), toScreenY(215), {255, 255, 255, 255});
            printText(sbuf.c_str(), toScreenX(260), toScreenY(235), {255, 255, 255, 255});
        }
    }
 
    void drawLaunch() {
        drawStars(0.5f);
        if (launchTimer > launchDuration / 4)
            drawAsteroids();
 
        float tempY = ship.y;
        ship.y = shipLaunchY;
        drawShipAt(ship.x, shipLaunchY);
        ship.y = tempY;
 
        if (launchTimer < launchDuration / 2) {
            setColor(1.0f, 0.39f, 0.0f, 1.0f);
            for (int i = 0; i < 12; ++i) {
                float tx = ship.x + (rand() % 8) - 4;
                float ty = shipLaunchY + 15 + i * 2;
                if (ty < GAME_H)
                    drawPixel(tx, ty);
            }
        }
        if (launchTimer >= launchDuration / 2) {
            int textW, textH;
            if (getTextDimensions("MISSION START!", textW, textH)) {
                printText("MISSION START!", w / 2 - textW / 2, h / 2 - textH / 2, {0, 255, 255, 255});
            } else {
                printText("MISSION START!", toScreenX(240), toScreenY(170), {0, 255, 255, 255});
            }
        }
    }
 
    void drawGame() {
        drawStars(1.0f);
        drawShipAt(ship.x, ship.y);
        drawProjectiles();
        drawAsteroids();
        drawExplosion();
        drawHUD();
    }
 
    void drawGameOver() {
        drawStars(0.2f);
        printText("GAME OVER", toScreenX(255), toScreenY(130), {255, 0, 0, 255});
 
        std::string buf = std::format("Final Score: {}", ship.score);
        printText(buf.c_str(), toScreenX(235), toScreenY(165), {255, 255, 255, 255});
        printText("Press SPACE to begin", toScreenX(215), toScreenY(195), {255, 255, 0, 255});
    }
};
 
int main(int argc, char **argv) {
    Arguments args = proc_args(argc, argv);
    try {
        SpaceRoxWindow window(args.path, args.width, args.height, args.fullscreen, args.enable_vsync);
        window.loop();
    } catch (mxvk::Exception &e) {
        std::cerr << std::format("mxvk: Exception: {}\n", e.text());
        return EXIT_FAILURE;
    } catch (ArgException<std::string> &e) {
        std::cerr << std::format("mxvk: Argument Exception: {}\n", e.text());
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}