scenes.hpp

Go to the documentation of this file.

#pragma once
 
extern "C" {
#include "cmdfx/core/scenes.h"
}
 
#include "cmdfx/core/builder.hpp"
#include <memory>
#include <string>
#include <vector>
 
namespace CmdFX
{

class Scene final {
  private:
    CmdFX_Scene* scene;
 
  public:
    Scene(CmdFX_Scene* scene) : scene(scene) {
    }
    Scene(int width, int height) {
        scene = Scene_create(width, height);
    }
    Scene(int width, int height, char c, char* ansi, int z) {
        scene = Scene_createFilled(width, height, c, ansi, z);
    }
    Scene(
        std::vector<std::string> data,
        std::vector<std::vector<std::string>> ansi
    ) {
        scene = Scene_createFromData(to2DArray(data), to3DArray(ansi));
    }
    Scene(char** data, char*** ansi) {
        scene = Scene_createFromData(data, ansi);
    }
 
    ~Scene() {
        if (scene) {
            Scene_free(scene);
        }
    }

    CmdFX_Scene* getScene() {
        return scene;
    }
 
    int getX() const {
        return scene->x;
    }
 
    int getY() const {
        return scene->y;
    }
 
    int getWidth() const {
        return scene->width;
    }
 
    int getHeight() const {
        return scene->height;
    }
 
    int getZ() const {
        return scene->z;
    }

    int getUniqueId() const {
        return scene->uid;
    }

    std::vector<std::string> getData() {
        std::vector<std::string> data;
        for (int i = 0; i < scene->height; i++) {
            data.push_back(std::string(scene->data[i]));
        }
        return data;
    }
 
    int setData(char** data) {
        return Scene_setData(scene, data);
    }

    int setData(std::vector<std::string> data) {
        char** text = to2DArray(data);
        return Scene_setData(scene, text);
    }

    std::vector<std::vector<std::string>> getAnsi() {
        std::vector<std::vector<std::string>> ansi;
        for (int i = 0; i < scene->height; i++) {
            std::vector<std::string> row;
            for (int j = 0; j < scene->width; j++) {
                row.push_back(std::string(scene->ansiData[i][j]));
            }
            ansi.push_back(row);
        }
        return ansi;
    }
 
    int setAnsi(char*** ansi) {
        return Scene_setAnsiData(scene, ansi);
    }

    int setAnsi(std::vector<std::vector<std::string>> ansi) {
        char*** ansiData = to3DArray(ansi);
        return Scene_setAnsiData(scene, ansiData);
    }
 
    int appendAnsi(char*** ansi) {
        return Scene_appendAnsiData(scene, ansi);
    }

    int appendAnsi(std::vector<std::vector<std::string>> ansi) {
        char*** ansiData = to3DArray(ansi);
        return Scene_appendAnsiData(scene, ansiData);
    }
 
    int setForeground(int x, int y, int width, int height, int rgb) {
        return Scene_setForeground(scene, x, y, width, height, rgb);
    }
 
    int setForegroundAll(int rgb) {
        return Scene_setForegroundAll(scene, rgb);
    }
 
    int setBackground(int x, int y, int width, int height, int rgb) {
        return Scene_setBackground(scene, x, y, width, height, rgb);
    }
 
    int setBackgroundAll(int rgb) {
        return Scene_setBackgroundAll(scene, rgb);
    }
 
    int clear() {
        return Scene_clear(scene);
    }
 
    int draw(int x, int y) {
        return Scene_draw(scene, x, y);
    }
 
    int drawPortion(int x, int y, int sx, int sy, int width, int height) {
        return Scene_drawPortion(scene, x, y, sx, sy, width, height);
    }
 
    bool isOnTop() const {
        return Scene_isOnTop(scene);
    }
 
    bool isOnTopAt(int x, int y) const {
        return Scene_isOnTopAt(scene, x, y);
    }
 
    bool isOnBottom() const {
        return Scene_isOnBottom(scene);
    }
 
    bool isOnBottomAt(int x, int y) const {
        return Scene_isOnBottomAt(scene, x, y);
    }
 
    int remove() {
        return Scene_remove(scene);
    }
 
    bool isEmpty() const {
        return Scene_isEmpty(scene);
    }
 
    int switchTo(int x, int y) {
        return Scene_switchTo(scene, x, y);
    }
 
    static std::unique_ptr<Scene> getSceneAt(int x, int y) {
        CmdFX_Scene* foundScene = Scene_getSceneAt(x, y);
        if (foundScene == nullptr) return nullptr;
        return std::make_unique<Scene>(foundScene);
    }

    int registerScene() {
        return Scene_register(scene);
    }

    int unregisterScene() {
        return Scene_unregister(scene);
    }
 
    static int drawRegistered(int uid, int x, int y) {
        return Scene_drawRegistered(uid, x, y);
    }
 
    static int switchToRegistered(int uid, int x, int y) {
        return Scene_switchToRegistered(uid, x, y);
    }
 
    static int scroll(int uid, int dx, int dy) {
        return Scene_scroll(uid, dx, dy);
    }

    int scroll(int dx, int dy) {
        if (scene->uid < 0) return -1;
        return Scene_scroll(scene->uid, dx, dy);
    }
};
 
namespace Canvas
{

std::vector<std::unique_ptr<Scene>> getDrawnScenes() {
    std::vector<std::unique_ptr<Scene>> scenes;
    CmdFX_Scene** drawnScenes = Canvas_getDrawnScenes();
    for (int i = 0; i < Canvas_getDrawnScenesCount(); i++) {
        scenes.push_back(std::make_unique<Scene>(drawnScenes[i]));
    }
    return scenes;
}

int getDrawnScenesCount() {
    return Canvas_getDrawnScenesCount();
}

std::vector<std::unique_ptr<Scene>> getRegisteredScenes() {
    std::vector<std::unique_ptr<Scene>> scenes;
    CmdFX_Scene** registeredScenes = Scene_getRegisteredScenes();
    for (int i = 0; i < Scene_getRegisteredScenesCount(); i++) {
        scenes.push_back(std::make_unique<Scene>(registeredScenes[i]));
    }
    return scenes;
}

int getRegisteredScenesCount() {
    return Scene_getRegisteredScenesCount();
}

std::unique_ptr<Scene> getRegisteredScene(int uid) {
    CmdFX_Scene* scene = Scene_getRegisteredScene(uid);
    if (scene) {
        return std::make_unique<Scene>(scene);
    }
 
    return nullptr;
}
 
} // namespace Canvas
 
} // namespace CmdFX