sprites.hpp

Go to the documentation of this file.

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

    class Sprite final {
        private:
            CmdFX_Sprite* sprite;
 
        public:
            Sprite(CmdFX_Sprite* sprite) : sprite(sprite) {}
            Sprite(char** text, char*** ansi, int z) {
                sprite = Sprite_create(text, ansi, z);
            }
            Sprite(std::vector<std::string> text, std::vector<std::vector<std::string>> ansi, int z) {
                sprite = Sprite_create(to2DArray(text), to3DArray(ansi), z);
            }
 
            ~Sprite() {
                if (sprite) { Sprite_free(sprite); }
            }

            CmdFX_Sprite* getSprite() { return sprite; }
 
            int getX() const {
                return sprite->x;
            }
 
            int getY() const {
                return sprite->y;
            }
 
            int getWidth() const {
                return sprite->width;
            }
 
            int getHeight() const {
                return sprite->height;
            }
            
            int getZ() const {
                return sprite->z;
            }
 
            int draw(int x, int y) {
                return Sprite_draw(x, y, sprite);
            }
 
            void remove() {
                Sprite_remove(sprite);
            }

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

            std::vector<std::vector<std::string>> getAnsi() {
                std::vector<std::vector<std::string>> ansi;
                for (int i = 0; i < sprite->height; i++) {
                    std::vector<std::string> row;
                    for (int j = 0; j < sprite->width; j++) {
                        row.push_back(std::string(sprite->ansi[i][j]));
                    }
                    ansi.push_back(row);
                }
                return ansi;
            }
 
            void setChar(int x, int y, char c) {
                Sprite_setChar(sprite, x, y, c);
            }
 
            int fillChar(int x, int y, int width, int height, char c) {
                return Sprite_fillChar(sprite, x, y, width, height, c);
            }
 
            int fillCharEmpty(int x, int y, int width, int height, char c) {
                return Sprite_fillCharEmpty(sprite, x, y, width, height, c);
            }
 
            int fillCharAll(char c) {
                return Sprite_fillCharAll(sprite, c);
            }
 
            int fillCharAllEmpty(char c) {
                return Sprite_fillCharAllEmpty(sprite, c);
            }
 
            int setAnsi(int x, int y, char* ansi) {
                return Sprite_setAnsi(sprite, x, y, ansi);
            }
 
            int appendAnsi(int x, int y, char* ansi) {
                return Sprite_appendAnsi(sprite, x, y, ansi);
            }
 
            int fillAnsi(int x, int y, char* ansi, int width, int height) {
                return Sprite_fillAnsi(sprite, x, y, ansi, width, height);
            }
 
            int setAnsiAll(char* ansi) {
                return Sprite_setAnsiAll(sprite, ansi);
            }
 
            int appendAnsiAll(char* ansi) {
                return Sprite_appendAnsiAll(sprite, ansi);
            }
 
            int resize(int width, int height) {
                return Sprite_resize(sprite, width, height);
            }
 
            int resizeWithPadding(int width, int height, char padding) {
                return Sprite_resizeWithPadding(sprite, width, height, padding);
            }
 
            int center() {
                return Sprite_center(sprite);
            }
 
            int resizeAndCenter(int width, int height) {
                return Sprite_resizeAndCenter(sprite, width, height);
            }
 
            void moveTo(int x, int y) {
                Sprite_moveTo(sprite, x, y);
            }
 
            void moveBy(int dx, int dy) {
                Sprite_moveBy(sprite, dx, dy);
            }
 
            std::vector<std::unique_ptr<Sprite>> getCollidingSprites() {
                std::vector<std::unique_ptr<Sprite>> collisions;
                CmdFX_Sprite** collisionSprites = Sprite_getCollidingSprites(sprite);
                for (int i = 0; collisionSprites[i] != nullptr; i++) {
                    collisions.push_back(std::make_unique<Sprite>(collisionSprites[i]));
                }
                return collisions;
            }
 
            bool isCollidingWith(std::unique_ptr<Sprite> other) {
                return Sprite_isColliding(sprite, other->getSprite());
            }
 
            bool isOnTop(int x, int y) {
                return Sprite_isOnTop(sprite, x, y);
            }
 
            bool isOnBottom(int x, int y) {
                return Sprite_isOnBottom(sprite, x, y);
            }
 
            int setForeground(int x, int y, int rgb) {
                return Sprite_setForeground(sprite, x, y, rgb);
            }
 
            int setForeground(int rgb) {
                return Sprite_setForegroundAll(sprite, rgb);
            }
 
            int setForeground256(int color) {
                return Sprite_setForegroundAll256(sprite, color);
            }
 
            int setBackground(int x, int y, int rgb) {
                return Sprite_setBackground(sprite, x, y, rgb);
            }
 
            int rotate(double radians) {
                return Sprite_rotate(sprite, radians);
            }
 
            double getRotationAngle() {
                return Sprite_getRotationAngle(sprite);
            }
 
            int hFlip() {
                return Sprite_hFlip(sprite);
            }
 
            int vFlip() {
                return Sprite_vFlip(sprite);
            }
 
            int scale(double scale) {
                return Sprite_scale(sprite, scale);
            }
 
            int transpose() {
                return Sprite_transpose(sprite);
            }
    };
    
    namespace Canvas {

        std::vector<std::unique_ptr<Sprite>> getDrawnSprites() {
            std::vector<std::unique_ptr<Sprite>> sprites;
            CmdFX_Sprite** drawnSprites = Canvas_getDrawnSprites();
            for (int i = 0; i < Canvas_getDrawnSpritesCount(); i++) {
                sprites.push_back(std::make_unique<Sprite>(drawnSprites[i]));
            }
 
            return sprites;
        }

        std::unique_ptr<Sprite> getSpriteAt(int x, int y) {
            CmdFX_Sprite* sprite = Canvas_getSpriteAt(x, y);
            if (sprite) {
                return std::make_unique<Sprite>(sprite);
            }
 
            return nullptr;
        }
 
    }
 
}