PyVector init should be pretty reliable now

src/GameEngine.cpp

@@ -59,7 +59,7 @@ void GameEngine::run()
         if (!paused)
         {
         }
-        currentScene()->render();
+        currentScene()->sRender();
         currentFrame++;
         frameTime = clock.restart().asSeconds();
         fps = 1 / frameTime;

src/McRFPy_API.cpp

@@ -9,11 +9,6 @@ std::vector<sf::SoundBuffer> McRFPy_API::soundbuffers;
 sf::Music McRFPy_API::music;
 sf::Sound McRFPy_API::sfx;
 
-std::shared_ptr<PyFont> McRFPy_API::default_font;
-std::shared_ptr<PyTexture> McRFPy_API::default_texture;
-PyObject* McRFPy_API::mcrf_module;
-
-
 static PyMethodDef mcrfpyMethods[] = {
     {"registerPyAction", McRFPy_API::_registerPyAction, METH_VARARGS,
         "Register a callable Python object to correspond to an action string. (actionstr, callable)"},
@@ -44,15 +39,8 @@ static PyMethodDef mcrfpyMethods[] = {
 };
 
 static PyModuleDef mcrfpyModule = {
-    PyModuleDef_HEAD_INIT, /* m_base - Always initialize this member to PyModuleDef_HEAD_INIT. */
+    PyModuleDef_HEAD_INIT, "mcrfpy", NULL, -1, mcrfpyMethods,
-    "mcrfpy",              /* m_name */
+    NULL, NULL, NULL, NULL
-    NULL,                  /* m_doc - Docstring for the module; usually a docstring variable created with PyDoc_STRVAR is used. */
-    -1,                    /* m_size - Setting m_size to -1 means that the module does not support sub-interpreters, because it has global state. */
-    mcrfpyMethods,         /* m_methods */
-    NULL,                  /* m_slots - An array of slot definitions ...  When using single-phase initialization, m_slots must be NULL. */
-    NULL,                  /* traverseproc m_traverse - A traversal function to call during GC traversal of the module object */
-    NULL,                  /* inquiry m_clear - A clear function to call during GC clearing of the module object */
-    NULL                   /* freefunc m_free - A function to call during deallocation of the module object */
 };
 
 // Module initializer fn, passed to PyImport_AppendInittab
@@ -84,19 +72,11 @@ PyObject* PyInit_mcrfpy()
     auto t = pytypes[i];
     while (t != nullptr)
     {
-        /*std::cout << */ PyType_Ready(t); /*<< std::endl; */
+        PyType_Ready(t);
         PyModule_AddType(m, t);
         t = pytypes[i++];
     }
 
-    // Add default_font and default_texture to module
-    McRFPy_API::default_font = std::make_shared<PyFont>("assets/JetbrainsMono.ttf");
-    McRFPy_API::default_texture = std::make_shared<PyTexture>("assets/kenney_tinydungeon.png", 16, 16);
-    //PyModule_AddObject(m, "default_font", McRFPy_API::default_font->pyObject());
-    //PyModule_AddObject(m, "default_texture", McRFPy_API::default_texture->pyObject());
-    PyModule_AddObject(m, "default_font", Py_None);
-    PyModule_AddObject(m, "default_texture", Py_None);
-    //McRFPy_API::mcrf_module = m;
     return m;
 }
 
@@ -148,13 +128,9 @@ PyStatus init_python(const char *program_name)
 #endif
 
     status = Py_InitializeFromConfig(&config);
-
-    PyConfig_Clear(&config);
-
     return status;
 }
 
-/*
 void McRFPy_API::setSpriteTexture(int ti)
 {
     int tx = ti % texture_width, ty = ti / texture_width;
@@ -163,7 +139,6 @@ void McRFPy_API::setSpriteTexture(int ti)
                 ty * texture_size,
                 texture_size, texture_size));
 }
-*/
 
 // functionality
 //void McRFPy_API::
@@ -180,15 +155,6 @@ void McRFPy_API::api_init() {
     //texture_sprite_count = texture_width * texture_height;
     //texture.setSmooth(false);
 
-    // Add default_font and default_texture to module
-    McRFPy_API::mcrf_module = PyImport_ImportModule("mcrfpy");
-    std::cout << PyUnicode_AsUTF8(PyObject_Repr(McRFPy_API::mcrf_module)) << std::endl;
-
-    //PyModule_AddObject(McRFPy_API::mcrf_module, "default_font", McRFPy_API::default_font->pyObject());
-    PyObject_SetAttrString(McRFPy_API::mcrf_module, "default_font", McRFPy_API::default_font->pyObject());
-    //PyModule_AddObject(McRFPy_API::mcrf_module, "default_texture", McRFPy_API::default_texture->pyObject());
-    PyObject_SetAttrString(McRFPy_API::mcrf_module, "default_texture", McRFPy_API::default_texture->pyObject());
-
     //sprite.setTexture(texture);
     //sprite.setScale(sf::Vector2f(4.0f, 4.0f));
     //setSpriteTexture(0);

src/McRFPy_API.h

@@ -3,9 +3,6 @@
 #include "Python.h"
 #include <list>
 
-#include "PyFont.h"
-#include "PyTexture.h"
-
 class GameEngine; // forward declared (circular members)
 
 class McRFPy_API
@@ -17,14 +14,10 @@ private:
 
     McRFPy_API();
 
-
 public:
-    static PyObject* mcrf_module;
+    inline static sf::Sprite sprite;
-    static std::shared_ptr<PyFont> default_font;
+    inline static sf::Texture texture;
-    static std::shared_ptr<PyTexture> default_texture;
+    static void setSpriteTexture(int);
-    //inline static sf::Sprite sprite;
-    //inline static sf::Texture texture;
-    //static void setSpriteTexture(int);
     inline static GameEngine* game;
     static void api_init();
     static void api_shutdown();

src/PyColor.cpp

@@ -1,5 +1,4 @@
 #include "PyColor.h"
-#include "McRFPy_API.h"
 
 PyGetSetDef PyColor::getsetters[] = {
     {"r", (getter)PyColor::get_member, (setter)PyColor::set_member, "Red component",   (void*)0},
@@ -135,16 +134,3 @@ int PyColor::set_member(PyObject* obj, PyObject* value, void* closure)
     // TODO
     return 0;
 }
-
-PyColorObject* PyColor::from_arg(PyObject* args)
-{
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color");
-    if (PyObject_IsInstance(args, (PyObject*)type)) return (PyColorObject*)args;
-    auto obj = (PyColorObject*)type->tp_alloc(type, 0);
-    int err = init(obj, args, NULL);
-    if (err) {
-        Py_DECREF(obj);
-        return NULL;
-    }
-    return obj;
-}

src/PyColor.h

@@ -29,7 +29,6 @@ public:
     static int set_member(PyObject*, PyObject*, void*);
     
     static PyGetSetDef getsetters[];
-    static PyColorObject* from_arg(PyObject*);
 };
 
 namespace mcrfpydef {

src/PyFont.cpp

@@ -1,63 +0,0 @@
-#include "PyFont.h"
-#include "McRFPy_API.h"
-
-
-PyFont::PyFont(std::string filename)
-: source(filename)
-{
-    font = sf::Font();
-    font.loadFromFile(source);
-}
-
-PyObject* PyFont::pyObject()
-{
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Font");
-    //PyObject* obj = PyType_GenericAlloc(&mcrfpydef::PyFontType, 0);
-    PyObject* obj = PyFont::pynew(type, Py_None, Py_None);
-    try {
-        ((PyFontObject*)obj)->data = shared_from_this();
-    }
-    catch (std::bad_weak_ptr& e)
-    {
-        std::cout << "Bad weak ptr: shared_from_this() failed in PyFont::pyObject(); did you create a PyFont outside of std::make_shared? enjoy your segfault, soon!" << std::endl;
-    }
-    // TODO - shared_from_this will raise an exception if the object does not have a shared pointer. Constructor should be made private; write a factory function
-    return obj;
-}
-
-PyObject* PyFont::repr(PyObject* obj)
-{
-    PyFontObject* self = (PyFontObject*)obj;
-    std::ostringstream ss;
-    if (!self->data)
-    {
-        ss << "<Font [invalid internal object]>";
-        std::string repr_str = ss.str();
-        return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-    }
-    auto& pfont = *(self->data);
-    ss << "<Font (family=" << pfont.font.getInfo().family << ") source=`" << pfont.source << "`>";
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-Py_hash_t PyFont::hash(PyObject* obj)
-{
-    auto self = (PyFontObject*)obj;
-    return reinterpret_cast<Py_hash_t>(self->data.get());
-}
-
-int PyFont::init(PyFontObject* self, PyObject* args, PyObject* kwds)
-{
-    static const char* keywords[] = { "filename", nullptr };
-    char* filename;
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", const_cast<char**>(keywords), &filename))
-        return -1;
-    self->data = std::make_shared<PyFont>(filename);
-    return 0;
-}
-
-PyObject* PyFont::pynew(PyTypeObject* type, PyObject* args, PyObject* kwds)
-{
-    return (PyObject*)type->tp_alloc(type, 0);
-}

src/PyFont.h

@@ -1,39 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-
-class PyFont;
-
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<PyFont> data;
-} PyFontObject;
-
-class PyFont : public std::enable_shared_from_this<PyFont>
-{
-private:
-    std::string source;
-public:
-    PyFont(std::string filename);
-    sf::Font font;
-    PyObject* pyObject();
-    static PyObject* repr(PyObject*);
-    static Py_hash_t hash(PyObject*);
-    static int init(PyFontObject*, PyObject*, PyObject*);
-    static PyObject* pynew(PyTypeObject* type, PyObject* args=NULL, PyObject* kwds=NULL);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyFontType = {
-        .tp_name = "mcrfpy.Font",
-        .tp_basicsize = sizeof(PyFontObject),
-        .tp_itemsize = 0,
-        .tp_repr = PyFont::repr,
-        //.tp_hash = PyFont::hash,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("SFML Font Object"),
-        //.tp_base = &PyBaseObject_Type,
-        .tp_init = (initproc)PyFont::init,
-        .tp_new = PyType_GenericNew, //PyFont::pynew,
-    };
-}

src/PyScene.cpp

@@ -59,7 +59,7 @@ void PyScene::doAction(std::string name, std::string type)
     }
 }
 
-void PyScene::render()
+void PyScene::sRender()
 {
     game->getWindow().clear();
     

src/PyScene.h

@@ -11,7 +11,7 @@ public:
     PyScene(GameEngine*);
     void update() override final;
     void doAction(std::string, std::string) override final;
-    void render() override final;
+    void sRender() override final;
 
     void do_mouse_input(std::string, std::string);
 };

src/PyTexture.cpp

@@ -1,5 +1,5 @@
 #include "PyTexture.h"
-#include "McRFPy_API.h"
+
 
 PyTexture::PyTexture(std::string filename, int sprite_w, int sprite_h)
 : source(filename), sprite_width(sprite_w), sprite_height(sprite_h)
@@ -28,10 +28,7 @@ sf::Sprite PyTexture::sprite(int index, sf::Vector2f pos,  sf::Vector2f s)
 
 PyObject* PyTexture::pyObject()
 {
-    std::cout << "Find type" << std::endl;
+    PyObject* obj = PyType_GenericAlloc(&mcrfpydef::PyTextureType, 0);
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Texture");
-    PyObject* obj = PyTexture::pynew(type, Py_None, Py_None);
-
     try {
         ((PyTextureObject*)obj)->data = shared_from_this();
     }
@@ -43,22 +40,6 @@ PyObject* PyTexture::pyObject()
     return obj;
 }
 
-PyObject* PyTexture::repr(PyObject* obj)
-{
-    PyTextureObject* self = (PyTextureObject*)obj;
-    std::ostringstream ss;
-    if (!self->data)
-    {
-        ss << "<Texture [invalid internal object]>";
-        std::string repr_str = ss.str();
-        return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-    }
-    auto& ptex = *(self->data);
-    ss << "<Texture " << ptex.sheet_height << " rows, " << ptex.sheet_width << " columns; " << ptex.sprite_width << "x" << ptex.sprite_height << "px sprites. source='" << ptex.source << "'>";
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
 Py_hash_t PyTexture::hash(PyObject* obj)
 {
     auto self = (PyTextureObject*)obj;

src/PyTexture.h

@@ -21,7 +21,6 @@ public:
     sf::Sprite sprite(int index, sf::Vector2f pos = sf::Vector2f(0, 0), sf::Vector2f s = sf::Vector2f(1.0, 1.0));
 
     PyObject* pyObject();
-    static PyObject* repr(PyObject*);
     static Py_hash_t hash(PyObject*);
     static int init(PyTextureObject*, PyObject*, PyObject*);
     static PyObject* pynew(PyTypeObject* type, PyObject* args=NULL, PyObject* kwds=NULL);
@@ -32,12 +31,10 @@ namespace mcrfpydef {
         .tp_name = "mcrfpy.Texture",
         .tp_basicsize = sizeof(PyTextureObject),
         .tp_itemsize = 0,
-        .tp_repr = PyTexture::repr,
         .tp_hash = PyTexture::hash,
         .tp_flags = Py_TPFLAGS_DEFAULT,
         .tp_doc = PyDoc_STR("SFML Texture Object"),
-        //.tp_base = &PyBaseObject_Type,
         .tp_init = (initproc)PyTexture::init,
-        .tp_new = PyType_GenericNew, //PyTexture::pynew,
+        .tp_new = PyTexture::pynew,
     };
 }

src/Scene.h

@@ -31,7 +31,7 @@ public:
     //Scene();
     Scene(GameEngine*);
     virtual void update() = 0;
-    virtual void render() = 0;
+    virtual void sRender() = 0;
     virtual void doAction(std::string, std::string) = 0;
     bool hasAction(std::string);
     bool hasAction(int);

src/UI.cpp

@@ -0,0 +1,527 @@
+#include "UI.h"
+#include "Resources.h"
+#include "GameEngine.h"
+
+/* //callability fields & methods
+    PyObject* click_callable;
+    virtual UIDrawable* click_at(sf::Vector2f point);
+    void click_register(PyObject*);
+    void click_unregister();
+*/
+
+UIDrawable::UIDrawable() { click_callable = NULL;  }
+
+UIDrawable* UIFrame::click_at(sf::Vector2f point)
+{
+    for (auto e: *children)
+    {
+        auto p = e->click_at(point + box.getPosition());
+        if (p)
+            return p;
+    }
+    if (click_callable)
+    {
+        float x = box.getPosition().x, y = box.getPosition().y, w = box.getSize().x, h = box.getSize().y;
+        if (point.x > x && point.y > y && point.x < x+w && point.y < y+h) return this;
+    }
+    return NULL;
+}
+
+UIDrawable* UICaption::click_at(sf::Vector2f point)
+{
+    if (click_callable)
+    {
+        if (text.getGlobalBounds().contains(point)) return this;
+    }
+    return NULL;
+}
+
+UIDrawable* UISprite::click_at(sf::Vector2f point)
+{
+    if (click_callable)
+    {
+        if(sprite.getGlobalBounds().contains(point)) return this;
+    }
+    return NULL;
+}
+
+UIDrawable* UIGrid::click_at(sf::Vector2f point)
+{
+    if (click_callable)
+    {
+        if(box.getGlobalBounds().contains(point)) return this;
+    }
+    return NULL;
+}
+
+void UIDrawable::click_register(PyObject* callable)
+{
+    /*
+    if (click_callable)
+    {
+        // decrement reference before overwriting
+        Py_DECREF(click_callable);
+    }
+    click_callable = callable;
+    Py_INCREF(click_callable);
+    */
+    click_callable = std::make_unique<PyClickCallable>(callable);
+}
+
+void UIDrawable::click_unregister()
+{
+    /*
+    if (click_callable == NULL) return;
+    Py_DECREF(click_callable);
+    click_callable = NULL;
+    */
+    click_callable.reset();
+}
+
+void UIDrawable::render()
+{
+    //std::cout << "Rendering base UIDrawable\n";
+    render(sf::Vector2f());
+}
+UIFrame::UIFrame():
+//x(0), y(0), w(0), h(0), 
+outline(0)
+{
+    children = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
+    box.setPosition(0, 0);
+    box.setSize(sf::Vector2f(0, 0));
+    /*
+    pyOutlineColor = NULL;
+    pyFillColor = NULL;
+    _outlineColor = NULL;
+    _fillColor = NULL;
+    */
+}
+
+UIFrame::UIFrame(float _x, float _y, float _w, float _h):
+//x(_x), y(_y), w(_w), h(_h),
+outline(0)
+{
+    box.setPosition(_x, _y);
+    box.setSize(sf::Vector2f(_w, _h));
+    children = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
+    /*
+    pyOutlineColor = NULL;
+    pyFillColor = NULL;
+    _outlineColor = NULL;
+    _fillColor = NULL;
+    */
+}
+
+UIFrame::~UIFrame()
+{
+    children.reset();
+    /*
+    if (pyOutlineColor) Py_DECREF(pyOutlineColor);
+    else if (_outlineColor) delete _outlineColor;
+    if (pyFillColor) Py_DECREF(pyFillColor);
+    else if (_fillColor) delete _fillColor;
+    */
+}
+
+/*
+    sf::Color& fillColor(); // getter
+    void fillColor(sf::Color c); // C++ setter
+    void fillColor(PyObject* pyColor); // Python setter
+    
+    sf::Color& outlineColor(); // getter
+    void outlineColor(sf::Color c); // C++ setter
+    void outlineColor(PyObject* pyColor); // Python setter
+*/
+
+
+PyObjectsEnum UIFrame::derived_type()
+{
+    return PyObjectsEnum::UIFRAME;
+}
+
+void UIFrame::render(sf::Vector2f offset)
+{
+    //std::cout << "Rendering UIFrame w/ offset " << offset.x << ", " << offset.y << "\n";
+    //std::cout << "position = " << x << ", " << y << "\n";
+    box.move(offset);
+    Resources::game->getWindow().draw(box);
+    box.move(-offset);
+    //sf::RectangleShape box = sf::RectangleShape(sf::Vector2f(w,h));
+    //sf::Vector2f pos = sf::Vector2f(x, y);
+    //box.setPosition(offset + pos);
+    //if (_fillColor) { box.setFillColor(fillColor()); }
+    //if (_outlineColor) { box.setOutlineColor(outlineColor()); }
+    //box.setOutlineThickness(outline);
+    //Resources::game->getWindow().draw(box);
+    for (auto drawable : *children) {
+        drawable->render(offset + box.getPosition());
+    }
+}
+
+void UICaption::render(sf::Vector2f offset)
+{
+    //std::cout << "Rendering Caption with offset\n";
+    text.move(offset);
+    Resources::game->getWindow().draw(text);
+    text.move(-offset);
+}
+
+UISprite::UISprite() {}
+/*
+ // * tearing down the old IndexTexture way of life 
+UISprite::UISprite(IndexTexture* _itex, int _sprite_index, float x = 0.0, float y = 0.0, float s = 1.0)
+: itex(_itex), sprite_index(_sprite_index)
+{
+    sprite.setTexture(_itex->texture);
+    sprite.setTextureRect(_itex->spriteCoordinates(_sprite_index));
+    sprite.setPosition(sf::Vector2f(x, y));
+    sprite.setScale(sf::Vector2f(s, s));
+}
+
+UISprite::UISprite(IndexTexture* _itex, int _sprite_index, sf::Vector2f pos, float s = 1.0)
+: itex(_itex), sprite_index(_sprite_index)
+{
+    sprite.setTexture(_itex->texture);
+    sprite.setTextureRect(_itex->spriteCoordinates(_sprite_index));
+    sprite.setPosition(pos);
+    sprite.setScale(sf::Vector2f(s, s));
+}
+*/
+
+UISprite::UISprite(std::shared_ptr<PyTexture> _ptex, int _sprite_index, sf::Vector2f _pos, float _scale)
+: ptex(_ptex), sprite_index(_sprite_index)
+{
+    sprite = ptex->sprite(sprite_index, _pos, sf::Vector2f(_scale, _scale));
+}
+
+//void UISprite::update()
+//{
+    //auto& tex = Resources::game->textures[texture_index];
+    //sprite.setTexture(tex.texture);
+    //sprite.setScale(sf::Vector2f(scale, scale));
+    //sprite.setPosition(sf::Vector2f(x, y));
+    //std::cout << "Drawable position: " << x << ", " << y << " -> " << s.getPosition().x << ", " << s.getPosition().y << std::endl;
+    //sprite.setTextureRect(tex.spriteCoordinates(sprite_index));
+//}
+
+void UISprite::render(sf::Vector2f offset)
+{
+    sprite.move(offset);
+    Resources::game->getWindow().draw(sprite);
+    sprite.move(-offset);
+}
+
+// 7DRL hack; needed to draw entities to UIGrid. TODO, apply this technique to all UIDrawables
+void UISprite::render(sf::Vector2f offset, sf::RenderTexture& target)
+{
+    sprite.move(offset);
+    target.draw(sprite);
+    sprite.move(-offset);
+}
+
+/*
+void UISprite::setPosition(float x, float y)
+{
+    setPosition(sf::Vector2f(x, y));
+}
+*/
+
+void UISprite::setPosition(sf::Vector2f pos)
+{
+    sprite.setPosition(pos);
+}
+
+void UISprite::setScale(sf::Vector2f s)
+{
+    sprite.setScale(s);
+}
+
+void UISprite::setTexture(std::shared_ptr<PyTexture> _ptex, int _sprite_index)
+{
+    ptex = _ptex;
+    if (_sprite_index != -1) // if you are changing textures, there's a good chance you need a new index too
+        sprite_index = _sprite_index;
+    sprite = ptex->sprite(sprite_index, sprite.getPosition(), sprite.getScale());
+}
+
+void UISprite::setSpriteIndex(int _sprite_index)
+{
+    sprite_index = _sprite_index;
+    sprite = ptex->sprite(sprite_index, sprite.getPosition(), sprite.getScale());
+}
+
+sf::Vector2f UISprite::getScale()
+{
+    return sprite.getScale();
+}
+
+sf::Vector2f UISprite::getPosition()
+{
+    return sprite.getPosition();
+}
+
+std::shared_ptr<PyTexture> UISprite::getTexture()
+{
+    return ptex;
+}
+
+int UISprite::getSpriteIndex()
+{
+    return sprite_index;
+}
+
+PyObjectsEnum UICaption::derived_type()
+{
+    return PyObjectsEnum::UICAPTION;
+}
+
+PyObjectsEnum UISprite::derived_type()
+{
+    return PyObjectsEnum::UISPRITE;
+}
+
+// UIGrid support classes' methods
+
+UIGridPoint::UIGridPoint()
+:color(1.0f, 1.0f, 1.0f), color_overlay(0.0f, 0.0f, 0.0f), walkable(false), transparent(false),
+ tilesprite(-1), tile_overlay(-1), uisprite(-1)
+{
+}
+
+UIEntity::UIEntity() {} // this will not work lol. TODO remove default constructor by finding the shared pointer inits that use it
+
+UIEntity::UIEntity(UIGrid& grid)
+: gridstate(grid.grid_x * grid.grid_y)
+{
+}
+
+// UIGrid methods
+
+UIGrid::UIGrid()
+{
+}
+
+/*
+UIGrid::UIGrid(int gx, int gy, std::shared_ptr<PyTexture> _ptex, float _x, float _y, float _w, float _h)
+: grid_x(gx), grid_y(gy),
+  zoom(1.0f), center_x((gx/2) * _ptex->sheet_width), center_y((gy/2) * _ptex->sheet_height),
+  itex(_itex), points(gx * gy)
+{
+    // set up blank list of entities
+    entities = std::make_shared<std::list<std::shared_ptr<UIEntity>>>();
+
+    box.setSize(sf::Vector2f(_w, _h));
+    box.setPosition(sf::Vector2f(_x, _y));
+
+    box.setFillColor(sf::Color(0,0,0,0));
+    renderTexture.create(_w, _h);
+    sprite.setTexture(_itex->texture);
+    output.setTextureRect(
+         sf::IntRect(0, 0,
+         box.getSize().x, box.getSize().y));
+     output.setPosition(box.getPosition());
+     // textures are upside-down inside renderTexture
+     output.setTexture(renderTexture.getTexture());
+}
+*/
+
+UIGrid::UIGrid(int gx, int gy, std::shared_ptr<PyTexture> _ptex, sf::Vector2f _xy, sf::Vector2f _wh)
+: grid_x(gx), grid_y(gy),
+  zoom(1.0f), center_x((gx/2) * _ptex->sprite_width), center_y((gy/2) * _ptex->sprite_height),
+  ptex(_ptex), points(gx * gy)
+{
+    // set up blank list of entities
+    entities = std::make_shared<std::list<std::shared_ptr<UIEntity>>>();
+
+    box.setSize(_wh);
+    box.setPosition(_xy); 
+
+    box.setFillColor(sf::Color(0,0,0,0));
+    //renderTexture.create(_wh.x, _wh.y);
+    // create renderTexture with maximum theoretical size; sprite can resize to show whatever amount needs to be rendered
+    renderTexture.create(1920, 1080); // TODO - renderTexture should be window size; above 1080p this will cause rendering errors
+    
+    //sprite.setTexture(_itex->texture);
+    sprite = ptex->sprite(0);
+
+    output.setTextureRect(
+         sf::IntRect(0, 0,
+         box.getSize().x, box.getSize().y));
+     output.setPosition(box.getPosition());
+     // textures are upside-down inside renderTexture
+     output.setTexture(renderTexture.getTexture());
+
+}
+
+void UIGrid::update()
+{
+}
+
+/*
+void UIGrid::setSprite(int ti)
+{
+    //int tx = ti % itex->grid_width, ty = ti / itex->grid_width;
+    //    sprite.setTextureRect(sf::IntRect(tx * itex->grid_size, ty * itex->grid_size, itex->grid_size, itex->grid_size));
+    sprite = ptex->sprite(ti);
+}
+*/
+
+void UIGrid::render(sf::Vector2f)
+{
+    output.setPosition(box.getPosition()); // output sprite can move; update position when drawing
+    // output size can change; update size when drawing
+    output.setTextureRect(
+         sf::IntRect(0, 0,
+         box.getSize().x, box.getSize().y));
+    renderTexture.clear(sf::Color(8, 8, 8, 255)); // TODO - UIGrid needs a "background color" field
+    // sprites that are visible according to zoom, center_x, center_y, and box width
+    float center_x_sq = center_x / ptex->sprite_width;
+    float center_y_sq = center_y / ptex->sprite_height;
+
+    float width_sq = box.getSize().x / (ptex->sprite_width * zoom);
+    float height_sq = box.getSize().y / (ptex->sprite_height * zoom);
+    float left_edge = center_x_sq - (width_sq / 2.0);
+    float top_edge = center_y_sq - (height_sq / 2.0);
+
+    int left_spritepixels = center_x - (box.getSize().x / 2.0 / zoom);
+    int top_spritepixels = center_y - (box.getSize().y / 2.0 / zoom);
+
+    //sprite.setScale(sf::Vector2f(zoom, zoom));
+    sf::RectangleShape r; // for colors and overlays
+    r.setSize(sf::Vector2f(ptex->sprite_width * zoom, ptex->sprite_height * zoom));
+    r.setOutlineThickness(0);
+
+    int x_limit = left_edge + width_sq + 2;
+    if (x_limit > grid_x) x_limit = grid_x;
+
+    int y_limit = top_edge + height_sq + 2;
+    if (y_limit > grid_y) y_limit = grid_y;
+
+    // base layer - bottom color, tile sprite ("ground")
+    for (int x = (left_edge - 1 >= 0 ? left_edge - 1 : 0);
+        x < x_limit; //x < view_width; 
+        x+=1)
+    {
+        //for (float y = (top_edge >= 0 ? top_edge : 0); 
+        for (int y = (top_edge - 1 >= 0 ? top_edge - 1 : 0);
+            y < y_limit; //y < view_height;
+            y+=1)
+        {
+            auto pixel_pos = sf::Vector2f(
+                    (x*ptex->sprite_width - left_spritepixels) * zoom,
+                    (y*ptex->sprite_height - top_spritepixels) * zoom );
+
+            auto gridpoint = at(std::floor(x), std::floor(y));
+
+            //sprite.setPosition(pixel_pos);
+
+            r.setPosition(pixel_pos);
+            r.setFillColor(gridpoint.color);
+            renderTexture.draw(r);
+
+            // tilesprite
+            // if discovered but not visible, set opacity to 90%
+            // if not discovered... just don't draw it?
+            if (gridpoint.tilesprite != -1) {
+                sprite = ptex->sprite(gridpoint.tilesprite, pixel_pos, sf::Vector2f(zoom, zoom)); //setSprite(gridpoint.tilesprite);;
+                renderTexture.draw(sprite);
+            }
+        }
+    }
+
+    // middle layer - entities
+    // disabling entity rendering until I can render their UISprite inside the rendertexture (not directly to window)
+    for (auto e : *entities) {
+        // TODO skip out-of-bounds entities (grid square not visible at all, check for partially on visible grid squares / floating point grid position)
+        //auto drawent = e->cGrid->indexsprite.drawable();
+        auto& drawent = e->sprite;
+        //drawent.setScale(zoom, zoom);
+        drawent.setScale(sf::Vector2f(zoom, zoom));
+        auto pixel_pos = sf::Vector2f(
+            (e->position.x*ptex->sprite_width - left_spritepixels) * zoom,
+            (e->position.y*ptex->sprite_height - top_spritepixels) * zoom );
+        //drawent.setPosition(pixel_pos);
+        //renderTexture.draw(drawent);
+        drawent.render(pixel_pos, renderTexture);
+    }
+    
+
+    // top layer - opacity for discovered / visible status (debug, basically)
+    /* // Disabled until I attach a "perspective"
+    for (int x = (left_edge - 1 >= 0 ? left_edge - 1 : 0);
+        x < x_limit; //x < view_width; 
+        x+=1)
+    {
+        //for (float y = (top_edge >= 0 ? top_edge : 0); 
+        for (int y = (top_edge - 1 >= 0 ? top_edge - 1 : 0);
+            y < y_limit; //y < view_height;
+            y+=1)
+        {
+
+            auto pixel_pos = sf::Vector2f(
+                    (x*itex->grid_size - left_spritepixels) * zoom,
+                    (y*itex->grid_size - top_spritepixels) * zoom );
+
+            auto gridpoint = at(std::floor(x), std::floor(y));
+
+            sprite.setPosition(pixel_pos);
+
+            r.setPosition(pixel_pos);
+
+            // visible & discovered layers for testing purposes
+            if (!gridpoint.discovered) {
+                r.setFillColor(sf::Color(16, 16, 20, 192)); // 255 opacity for actual blackout
+                renderTexture.draw(r);
+            } else if (!gridpoint.visible) {
+                r.setFillColor(sf::Color(32, 32, 40, 128));
+                renderTexture.draw(r);
+            }
+
+            // overlay
+
+            // uisprite
+        }
+    }
+    */
+
+    // grid lines for testing & validation
+    /*
+    sf::Vertex line[] =
+    {
+        sf::Vertex(sf::Vector2f(0, 0), sf::Color::Red),
+        sf::Vertex(box.getSize(), sf::Color::Red),
+
+    };
+
+    renderTexture.draw(line, 2, sf::Lines);
+    sf::Vertex lineb[] =
+    {
+        sf::Vertex(sf::Vector2f(0, box.getSize().y), sf::Color::Blue),
+        sf::Vertex(sf::Vector2f(box.getSize().x, 0), sf::Color::Blue),
+
+    };
+
+    renderTexture.draw(lineb, 2, sf::Lines);
+    */
+
+    // render to window
+    renderTexture.display();
+    Resources::game->getWindow().draw(output);
+
+}
+
+UIGridPoint& UIGrid::at(int x, int y)
+{
+    return points[y * grid_x + x];
+}
+
+PyObjectsEnum UIGrid::derived_type()
+{
+    return PyObjectsEnum::UIGRID;
+}
+
+std::shared_ptr<PyTexture> UIGrid::getTexture()
+{
+    return ptex;
+}

src/UIBase.h

@@ -1,32 +0,0 @@
-#pragma once
-
-class UIEntity;
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<UIEntity> data;
-} PyUIEntityObject;
-
-class UIFrame;
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<UIFrame> data;
-} PyUIFrameObject;
-
-class UICaption;
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<UICaption> data;
-    PyObject* font;
-} PyUICaptionObject;
-
-class UIGrid;
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<UIGrid> data;
-} PyUIGridObject;
-
-class UISprite;
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<UISprite> data;
-} PyUISpriteObject;

src/UICaption.cpp

@@ -1,283 +0,0 @@
-#include "UICaption.h"
-#include "GameEngine.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "PyFont.h"
-
-UIDrawable* UICaption::click_at(sf::Vector2f point)
-{
-    if (click_callable)
-    {
-        if (text.getGlobalBounds().contains(point)) return this;
-    }
-    return NULL;
-}
-
-void UICaption::render(sf::Vector2f offset)
-{
-    text.move(offset);
-    Resources::game->getWindow().draw(text);
-    text.move(-offset);
-}
-
-PyObjectsEnum UICaption::derived_type()
-{
-    return PyObjectsEnum::UICAPTION;
-}
-
-PyObject* UICaption::get_float_member(PyUICaptionObject* self, void* closure)
-{
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (member_ptr == 0)
-        return PyFloat_FromDouble(self->data->text.getPosition().x);
-    else if (member_ptr == 1)
-        return PyFloat_FromDouble(self->data->text.getPosition().y);
-    else if (member_ptr == 4)
-        return PyFloat_FromDouble(self->data->text.getOutlineThickness());
-    else if (member_ptr == 5)
-        return PyLong_FromLong(self->data->text.getCharacterSize());
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-}
-
-int UICaption::set_float_member(PyUICaptionObject* self, PyObject* value, void* closure)
-{
-    float val;
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (PyFloat_Check(value))
-    {
-        val = PyFloat_AsDouble(value);
-    }
-    else if (PyLong_Check(value))
-    {
-        val = PyLong_AsLong(value);
-    }
-    else
-    {
-        PyErr_SetString(PyExc_TypeError, "Value must be an integer.");
-        return -1;
-    }
-    if (member_ptr == 0) //x
-        self->data->text.setPosition(val, self->data->text.getPosition().y);
-    else if (member_ptr == 1) //y
-        self->data->text.setPosition(self->data->text.getPosition().x, val);
-    else if (member_ptr == 4) //outline
-        self->data->text.setOutlineThickness(val);
-    else if (member_ptr == 5) // character size
-        self->data->text.setCharacterSize(val);
-    return 0;
-}
-
-PyObject* UICaption::get_vec_member(PyUICaptionObject* self, void* closure)
-{
-    return PyVector(self->data->text.getPosition()).pyObject();
-}
-
-int UICaption::set_vec_member(PyUICaptionObject* self, PyObject* value, void* closure)
-{
-    self->data->text.setPosition(PyVector::fromPy(value));
-    return 0;
-}
-
-PyObject* UICaption::get_color_member(PyUICaptionObject* self, void* closure)
-{
-    // TODO: migrate this code to a switch statement - validate closure & return values in one tighter, more extensible structure
-
-    // validate closure (should be impossible to be wrong, but it's thorough)
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (member_ptr != 0 && member_ptr != 1)
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-
-    // TODO: manually calling tp_alloc to create a PyColorObject seems like an antipattern
-    // fetch correct member data
-    sf::Color color;
-
-    if (member_ptr == 0)
-    {
-        color = self->data->text.getFillColor();
-    }
-    else if (member_ptr == 1)
-    {
-        color = self->data->text.getOutlineColor();
-    }
-
-    return PyColor(color).pyObject();
-}
-
-int UICaption::set_color_member(PyUICaptionObject* self, PyObject* value, void* closure)
-{
-    auto member_ptr = reinterpret_cast<long>(closure);
-    //TODO: this logic of (PyColor instance OR tuple -> sf::color) should be encapsulated for reuse
-    int r, g, b, a;
-    if (PyObject_IsInstance(value, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color")  /*(PyObject*)&mcrfpydef::PyColorType)*/))
-    {
-        // get value from mcrfpy.Color instance
-        auto c = ((PyColorObject*)value)->data;
-        r = c.r; g = c.g; b = c.b; a = c.a;
-        std::cout << "got " << int(r) << ", " << int(g) << ", " << int(b) << ", " << int(a) << std::endl;
-    }
-    else if (!PyTuple_Check(value) || PyTuple_Size(value) < 3 || PyTuple_Size(value) > 4)
-    {
-        // reject non-Color, non-tuple value
-        PyErr_SetString(PyExc_TypeError, "Value must be a tuple of 3 or 4 integers or an mcrfpy.Color object.");
-        return -1;
-    }
-    else // get value from tuples
-    {
-        r = PyLong_AsLong(PyTuple_GetItem(value, 0));
-        g = PyLong_AsLong(PyTuple_GetItem(value, 1));
-        b = PyLong_AsLong(PyTuple_GetItem(value, 2));
-        a = 255;
-
-        if (PyTuple_Size(value) == 4)
-        {
-            a = PyLong_AsLong(PyTuple_GetItem(value, 3));
-        }
-    }
-
-    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255)
-    {
-        PyErr_SetString(PyExc_ValueError, "Color values must be between 0 and 255.");
-        return -1;
-    }
-
-    if (member_ptr == 0)
-    {
-        self->data->text.setFillColor(sf::Color(r, g, b, a));
-    }
-    else if (member_ptr == 1)
-    {
-        self->data->text.setOutlineColor(sf::Color(r, g, b, a));
-    }
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return -1;
-    }
-
-    return 0;
-}
-
-
-//TODO: evaluate use of Resources::caption_buffer... can't I do this with a std::string?
-PyObject* UICaption::get_text(PyUICaptionObject* self, void* closure)
-{
-    Resources::caption_buffer = self->data->text.getString();
-    return PyUnicode_FromString(Resources::caption_buffer.c_str());
-}
-
-int UICaption::set_text(PyUICaptionObject* self, PyObject* value, void* closure)
-{
-    PyObject* s = PyObject_Str(value);
-    PyObject * temp_bytes = PyUnicode_AsEncodedString(s, "UTF-8", "strict"); // Owned reference
-    if (temp_bytes != NULL) {
-        Resources::caption_buffer = PyBytes_AS_STRING(temp_bytes); // Borrowed pointer
-        Py_DECREF(temp_bytes);
-    }
-    self->data->text.setString(Resources::caption_buffer);
-    return 0;
-}
-
-PyGetSetDef UICaption::getsetters[] = {
-    {"x", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "X coordinate of top-left corner",   (void*)0},
-    {"y", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "Y coordinate of top-left corner",   (void*)1},
-    {"pos", (getter)UICaption::get_vec_member, (setter)UICaption::set_vec_member, "(x, y) vector", (void*)0},
-    //{"w", (getter)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "width of the rectangle",   (void*)2},
-    //{"h", (getter)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "height of the rectangle",   (void*)3},
-    {"outline", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "Thickness of the border",   (void*)4},
-    {"fill_color", (getter)UICaption::get_color_member, (setter)UICaption::set_color_member, "Fill color of the text", (void*)0},
-    {"outline_color", (getter)UICaption::get_color_member, (setter)UICaption::set_color_member, "Outline color of the text", (void*)1},
-    //{"children", (getter)PyUIFrame_get_children, NULL, "UICollection of objects on top of this one", NULL},
-    {"text", (getter)UICaption::get_text, (setter)UICaption::set_text, "The text displayed", NULL},
-    {"size", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "Text size (integer) in points", (void*)5},
-    {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UICAPTION},
-    {NULL}
-};
-
-PyObject* UICaption::repr(PyUICaptionObject* self)
-{
-    std::ostringstream ss;
-    if (!self->data) ss << "<Caption (invalid internal object)>";
-    else {
-        auto text = self->data->text;
-        auto fc = text.getFillColor();
-        auto oc = text.getOutlineColor();
-        ss << "<Caption (x=" << text.getPosition().x << ", y=" << text.getPosition().y << ", " <<
-            "text='" << (std::string)text.getString() << "', " <<
-            "outline=" << text.getOutlineThickness() << ", " <<
-            "fill_color=(" << (int)fc.r << ", " << (int)fc.g << ", " << (int)fc.b << ", " << (int)fc.a <<"), " <<
-            "outline_color=(" << (int)oc.r << ", " << (int)oc.g << ", " << (int)oc.b << ", " << (int)oc.a <<"), " <<
-            ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-int UICaption::init(PyUICaptionObject* self, PyObject* args, PyObject* kwds)
-{
-    using namespace mcrfpydef;
-    static const char* keywords[] = { "x", "y", "text", "font", "fill_color", "outline_color", "outline", nullptr };
-    float x = 0.0f, y = 0.0f, outline = 0.0f;
-    char* text;
-    PyObject* font=NULL, *fill_color=NULL, *outline_color=NULL;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ffzOOOf",
-        const_cast<char**>(keywords), &x, &y, &text, &font, &fill_color, &outline_color, &outline))
-    {
-        return -1;
-    }
-
-    // check types for font, fill_color, outline_color
-
-    std::cout << PyUnicode_AsUTF8(PyObject_Repr(font)) << std::endl;
-    if (font != NULL && !PyObject_IsInstance(font, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Font")/*(PyObject*)&PyFontType)*/)){
-        PyErr_SetString(PyExc_TypeError, "font must be a mcrfpy.Font instance");
-        return -1;
-    } else if (font != NULL)
-    {
-        auto font_obj = (PyFontObject*)font;
-        self->data->text.setFont(font_obj->data->font);
-        self->font = font;
-        Py_INCREF(font);
-    } else
-    {
-        // default font
-        //self->data->text.setFont(Resources::game->getFont());
-    }
-
-    self->data->text.setPosition(sf::Vector2f(x, y));
-    self->data->text.setString((std::string)text);
-    self->data->text.setOutlineThickness(outline);
-    if (fill_color) {
-        auto fc = PyColor::from_arg(fill_color);
-        if (!fc) {
-            PyErr_SetString(PyExc_TypeError, "fill_color must be mcrfpy.Color or arguments to mcrfpy.Color.__init__");
-            return -1;
-        }
-        self->data->text.setFillColor(PyColor::fromPy(fc));
-        //Py_DECREF(fc);
-    } else {
-        self->data->text.setFillColor(sf::Color(0,0,0,255));
-    }
-
-    if (outline_color) {
-        auto oc = PyColor::from_arg(outline_color);
-        if (!oc) {
-            PyErr_SetString(PyExc_TypeError, "outline_color must be mcrfpy.Color or arguments to mcrfpy.Color.__init__");
-            return -1;
-        }
-        self->data->text.setOutlineColor(PyColor::fromPy(oc));
-        //Py_DECREF(oc);
-    } else {
-        self->data->text.setOutlineColor(sf::Color(128,128,128,255));
-    }
-
-    return 0;
-}
-

src/UICaption.h

@@ -1,62 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "UIDrawable.h"
-
-class UICaption: public UIDrawable
-{
-public:
-    sf::Text text;
-    void render(sf::Vector2f) override final;
-    PyObjectsEnum derived_type() override final;
-    virtual UIDrawable* click_at(sf::Vector2f point) override final;
-
-    static PyObject* get_float_member(PyUICaptionObject* self, void* closure);
-    static int set_float_member(PyUICaptionObject* self, PyObject* value, void* closure);
-    static PyObject* get_vec_member(PyUICaptionObject* self, void* closure);
-    static int set_vec_member(PyUICaptionObject* self, PyObject* value, void* closure);
-    static PyObject* get_color_member(PyUICaptionObject* self, void* closure);
-    static int set_color_member(PyUICaptionObject* self, PyObject* value, void* closure);
-    static PyObject* get_text(PyUICaptionObject* self, void* closure);
-    static int set_text(PyUICaptionObject* self, PyObject* value, void* closure);
-    static PyGetSetDef getsetters[];
-    static PyObject* repr(PyUICaptionObject* self);
-    static int init(PyUICaptionObject* self, PyObject* args, PyObject* kwds);
-
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUICaptionType = {
-        .tp_name = "mcrfpy.Caption",
-        .tp_basicsize = sizeof(PyUICaptionObject),
-        .tp_itemsize = 0,
-        // TODO - move tp_dealloc to .cpp file as static function (UICaption::dealloc)
-        .tp_dealloc = (destructor)[](PyObject* self)
-        {
-            PyUICaptionObject* obj = (PyUICaptionObject*)self;
-            // TODO - reevaluate with PyFont usage; UICaption does not own the font
-            // release reference to font object
-            if (obj->font) Py_DECREF(obj->font);
-            obj->data.reset();
-            Py_TYPE(self)->tp_free(self);
-        },
-        .tp_repr = (reprfunc)UICaption::repr,
-        //.tp_hash = NULL,
-        //.tp_iter
-        //.tp_iternext
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("docstring"),
-        //.tp_methods = PyUIFrame_methods,
-        //.tp_members = PyUIFrame_members,
-        .tp_getset = UICaption::getsetters,
-        //.tp_base = NULL,
-        .tp_init = (initproc)UICaption::init,
-        // TODO - move tp_new to .cpp file as a static function (UICaption::new)
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            PyUICaptionObject* self = (PyUICaptionObject*)type->tp_alloc(type, 0);
-            if (self) self->data = std::make_shared<UICaption>();
-            return (PyObject*)self;
-        }
-    };
-}

src/UICollection.cpp

@@ -1,203 +0,0 @@
-#include "UICollection.h"
-
-#include "UIFrame.h"
-#include "UICaption.h"
-#include "UISprite.h"
-#include "UIGrid.h"
-#include "McRFPy_API.h"
-
-using namespace mcrfpydef;
-
-int UICollectionIter::init(PyUICollectionIterObject* self, PyObject* args, PyObject* kwds)
-{
-    PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
-    return -1;
-}
-
-PyObject* UICollectionIter::next(PyUICollectionIterObject* self)
-{
-    if (self->data->size() != self->start_size)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "collection changed size during iteration");
-        return NULL;
-    }
-
-    if (self->index > self->start_size - 1)
-    {
-        PyErr_SetNone(PyExc_StopIteration);
-        return NULL;
-    }
-	self->index++;
-    auto vec = self->data.get();
-    if (!vec)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "the collection store returned a null pointer");
-        return NULL;
-    }
-    auto target = (*vec)[self->index-1];
-    // TODO build PyObject* of the correct UIDrawable subclass to return
-    //return py_instance(target);
-    return NULL;
-}
-
-PyObject* UICollectionIter::repr(PyUICollectionIterObject* self)
-{
-	std::ostringstream ss;
-	if (!self->data) ss << "<UICollectionIter (invalid internal object)>";
-	else {
-	    ss << "<UICollectionIter (" << self->data->size() << " child objects, @ index " << self->index  << ")>";
-	}
-	std::string repr_str = ss.str();
-	return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-Py_ssize_t UICollection::len(PyUICollectionObject* self) {
-	return self->data->size();
-}
-
-PyObject* UICollection::getitem(PyUICollectionObject* self, Py_ssize_t index) {
-	// build a Python version of item at self->data[index]
-    //  Copy pasted::
-    auto vec = self->data.get();
-    if (!vec)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "the collection store returned a null pointer");
-        return NULL;
-    }
-    while (index < 0) index += self->data->size();
-    if (index > self->data->size() - 1)
-    {
-        PyErr_SetString(PyExc_IndexError, "UICollection index out of range");
-        return NULL;
-    }
-    auto target = (*vec)[index];
-    RET_PY_INSTANCE(target);
-return NULL;
-
-
-}
-
-PySequenceMethods UICollection::sqmethods = {
-	.sq_length = (lenfunc)UICollection::len,
-	.sq_item = (ssizeargfunc)UICollection::getitem,
-	//.sq_item_by_index = PyUICollection_getitem
-	//.sq_slice - return a subset of the iterable
-	//.sq_ass_item - called when `o[x] = y` is executed (x is any object type)
-	//.sq_ass_slice - cool; no thanks, for now
-	//.sq_contains - called when `x in o` is executed
-	//.sq_ass_item_by_index - called when `o[x] = y` is executed (x is explictly an integer)
-};
-
-/* Idiomatic way to fetch complete types from the API rather than referencing their PyTypeObject struct
-
-auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Texture");
-
-I never identified why `using namespace mcrfpydef;` doesn't solve the segfault issue.
-The horrible macro in UIDrawable was originally a workaround for this, but as I interact with the types outside of the monster UI.h, a more general (and less icky) solution is required.
-
-*/
-
-PyObject* UICollection::append(PyUICollectionObject* self, PyObject* o)
-{
-	// if not UIDrawable subclass, reject it
-	// self->data->push_back( c++ object inside o );
-
-    // this would be a great use case for .tp_base
-    if (!PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Frame")) &&
-        !PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Sprite")) &&
-        !PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Caption")) &&
-        !PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Grid"))
-        )
-    {
-        PyErr_SetString(PyExc_TypeError, "Only Frame, Caption, Sprite, and Grid objects can be added to UICollection");
-        return NULL;
-    }
-
-    if (PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Frame")))
-    {
-        PyUIFrameObject* frame = (PyUIFrameObject*)o;
-        self->data->push_back(frame->data);
-    }
-    if (PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Caption")))
-    {
-        PyUICaptionObject* caption = (PyUICaptionObject*)o;
-        self->data->push_back(caption->data);
-    }
-    if (PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Sprite")))
-    {
-        PyUISpriteObject* sprite = (PyUISpriteObject*)o;
-        self->data->push_back(sprite->data);
-    }
-    if (PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Grid")))
-    {
-        PyUIGridObject* grid = (PyUIGridObject*)o;
-        self->data->push_back(grid->data);
-    }
-
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-PyObject* UICollection::remove(PyUICollectionObject* self, PyObject* o)
-{
-	if (!PyLong_Check(o))
-    {
-        PyErr_SetString(PyExc_TypeError, "UICollection.remove requires an integer index to remove");
-        return NULL;
-    }
-	long index = PyLong_AsLong(o);
-	if (index >= self->data->size())
-    {
-        PyErr_SetString(PyExc_ValueError, "Index out of range");
-        return NULL;
-    }
-    else if (index < 0)
-    {
-        PyErr_SetString(PyExc_NotImplementedError, "reverse indexing is not implemented.");
-        return NULL;
-    }
-
-	// release the shared pointer at self->data[index];
-    self->data->erase(self->data->begin() + index);
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-PyMethodDef UICollection::methods[] = {
-	{"append", (PyCFunction)UICollection::append, METH_O},
-    //{"extend", (PyCFunction)PyUICollection_extend, METH_O}, // TODO
-	{"remove", (PyCFunction)UICollection::remove, METH_O},
-	{NULL, NULL, 0, NULL}
-};
-
-PyObject* UICollection::repr(PyUICollectionObject* self)
-{
-	std::ostringstream ss;
-	if (!self->data) ss << "<UICollection (invalid internal object)>";
-	else {
-	    ss << "<UICollection (" << self->data->size() << " child objects)>";
-	}
-	std::string repr_str = ss.str();
-	return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-int UICollection::init(PyUICollectionObject* self, PyObject* args, PyObject* kwds)
-{
-    PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
-    return -1;
-}
-
-PyObject* UICollection::iter(PyUICollectionObject* self)
-{
-    PyUICollectionIterObject* iterObj;
-    iterObj = (PyUICollectionIterObject*)PyUICollectionIterType.tp_alloc(&PyUICollectionIterType, 0);
-    if (iterObj == NULL) {
-        return NULL;  // Failed to allocate memory for the iterator object
-    }
-
-    iterObj->data = self->data;
-    iterObj->index = 0;
-    iterObj->start_size = self->data->size();
-
-    return (PyObject*)iterObj;
-}

src/UICollection.h

@@ -1,88 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-
-#include "UIDrawable.h"
-
-class UICollectionIter
-{
-    // really more of a namespace: all the members are public and static. But being consistent with other UI objects
-public:
-    static int init(PyUICollectionIterObject* self, PyObject* args, PyObject* kwds);
-    static PyObject* next(PyUICollectionIterObject* self);
-    static PyObject* repr(PyUICollectionIterObject* self);
-};
-
-class UICollection
-{
-    // really more of a namespace: all the members are public and static. But being consistent with other UI objects
-public:
-    static Py_ssize_t len(PyUICollectionObject* self);
-	static PyObject* getitem(PyUICollectionObject* self, Py_ssize_t index);
-	static PySequenceMethods sqmethods;
-	static PyObject* append(PyUICollectionObject* self, PyObject* o);
-	static PyObject* remove(PyUICollectionObject* self, PyObject* o);
-	static PyMethodDef methods[];
-	static PyObject* repr(PyUICollectionObject* self);
-    static int init(PyUICollectionObject* self, PyObject* args, PyObject* kwds);
-    static PyObject* iter(PyUICollectionObject* self);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUICollectionIterType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.UICollectionIter",
-        .tp_basicsize = sizeof(PyUICollectionIterObject),
-        .tp_itemsize = 0,
-        //TODO - as static method, not inline lambda def, please
-        .tp_dealloc = (destructor)[](PyObject* self)
-        {
-            PyUICollectionIterObject* obj = (PyUICollectionIterObject*)self;
-            obj->data.reset();
-            Py_TYPE(self)->tp_free(self);
-        },
-        .tp_repr = (reprfunc)UICollectionIter::repr,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("Iterator for a collection of UI objects"),
-        .tp_iternext = (iternextfunc)UICollectionIter::next,
-        //.tp_getset = PyUICollection_getset,
-        .tp_init = (initproc)UICollectionIter::init, // just raise an exception
-        //TODO - as static method, not inline lambda def, please
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
-            return NULL;
-        }
-    };
-
-	static PyTypeObject PyUICollectionType = {
-		//PyVarObject_/HEAD_INIT(NULL, 0)
-		.tp_name = "mcrfpy.UICollection",
-		.tp_basicsize = sizeof(PyUICollectionObject),
-		.tp_itemsize = 0,
-        //TODO - as static method, not inline lambda def, please
-		.tp_dealloc = (destructor)[](PyObject* self)
-		{
-		    PyUICollectionObject* obj = (PyUICollectionObject*)self;
-		    obj->data.reset();
-		    Py_TYPE(self)->tp_free(self);
-		},
-		.tp_repr = (reprfunc)UICollection::repr,
-		.tp_as_sequence = &UICollection::sqmethods,
-		.tp_flags = Py_TPFLAGS_DEFAULT,
-		.tp_doc = PyDoc_STR("Iterable, indexable collection of UI objects"),
-        .tp_iter = (getiterfunc)UICollection::iter,
-		.tp_methods = UICollection::methods, // append, remove
-        //.tp_getset = PyUICollection_getset,
-		.tp_init = (initproc)UICollection::init, // just raise an exception
-        //TODO - as static method, not inline lambda def, please
-		.tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-		{
-            // Does PyUICollectionType need __new__ if it's not supposed to be instantiable by the user? 
-            // Should I just raise an exception? Or is the uninitialized shared_ptr enough of a blocker?
-            PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
-		    return NULL;
-		}
-	};
-
-}

src/UIDrawable.cpp

@@ -1,81 +0,0 @@
-#include "UIDrawable.h"
-#include "UIFrame.h"
-#include "UICaption.h"
-#include "UISprite.h"
-#include "UIGrid.h"
-
-UIDrawable::UIDrawable() { click_callable = NULL;  }
-
-void UIDrawable::click_unregister()
-{
-    click_callable.reset();
-}
-
-void UIDrawable::render()
-{
-    render(sf::Vector2f());
-}
-
-PyObject* UIDrawable::get_click(PyObject* self, void* closure) {
-    PyObjectsEnum objtype = static_cast<PyObjectsEnum>(reinterpret_cast<long>(closure)); // trust me bro, it's an Enum
-    PyObject* ptr;
-
-    switch (objtype)
-    {
-        case PyObjectsEnum::UIFRAME:
-            ptr = ((PyUIFrameObject*)self)->data->click_callable->borrow();
-            break;
-        case PyObjectsEnum::UICAPTION:
-            ptr = ((PyUICaptionObject*)self)->data->click_callable->borrow();
-            break;
-        case PyObjectsEnum::UISPRITE:
-            ptr = ((PyUISpriteObject*)self)->data->click_callable->borrow();
-            break;
-        case PyObjectsEnum::UIGRID:
-            ptr = ((PyUIGridObject*)self)->data->click_callable->borrow();
-            break;
-        default:
-            PyErr_SetString(PyExc_TypeError, "no idea how you did that; invalid UIDrawable derived instance for _get_click");
-            return NULL;
-    }
-    if (ptr && ptr != Py_None)
-        return ptr;
-    else
-        return Py_None;
-}
-
-int UIDrawable::set_click(PyObject* self, PyObject* value, void* closure) {
-    PyObjectsEnum objtype = static_cast<PyObjectsEnum>(reinterpret_cast<long>(closure)); // trust me bro, it's an Enum
-    UIDrawable* target;
-    switch (objtype)
-    {
-        case PyObjectsEnum::UIFRAME:
-            target = (((PyUIFrameObject*)self)->data.get());
-            break;
-        case PyObjectsEnum::UICAPTION:
-            target = (((PyUICaptionObject*)self)->data.get());
-            break;
-        case PyObjectsEnum::UISPRITE:
-            target = (((PyUISpriteObject*)self)->data.get());
-            break;
-        case PyObjectsEnum::UIGRID:
-            target = (((PyUIGridObject*)self)->data.get());
-            break;
-        default:
-            PyErr_SetString(PyExc_TypeError, "no idea how you did that; invalid UIDrawable derived instance for _set_click");
-            return -1;
-    }
-
-    if (value == Py_None)
-    {
-        target->click_unregister();
-    } else {
-        target->click_register(value);
-    }
-    return 0;
-}
-
-void UIDrawable::click_register(PyObject* callable)
-{
-    click_callable = std::make_unique<PyClickCallable>(callable);
-}

src/UIDrawable.h

@@ -1,176 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "structmember.h"
-#include "IndexTexture.h"
-#include "Resources.h"
-#include <list>
-
-#include "PyCallable.h"
-#include "PyTexture.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "PyFont.h"
-
-#include "Resources.h"
-#include "UIBase.h"
-class UIFrame; class UICaption; class UISprite; class UIEntity; class UIGrid;
-
-enum PyObjectsEnum : int
-{
-    UIFRAME = 1,
-    UICAPTION,
-    UISPRITE,
-    UIGRID
-};
-
-class UIDrawable
-{
-public:
-    void render();
-    virtual void render(sf::Vector2f) = 0;
-    virtual PyObjectsEnum derived_type() = 0;
-
-    // Mouse input handling - callable object, methods to find event's destination
-    std::unique_ptr<PyClickCallable> click_callable;
-    virtual UIDrawable* click_at(sf::Vector2f point) = 0;
-    void click_register(PyObject*);
-    void click_unregister();
-
-    UIDrawable();
-
-    static PyObject* get_click(PyObject* self, void* closure);
-    static int set_click(PyObject* self, PyObject* value, void* closure);
-};
-
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> data;
-} PyUICollectionObject;
-
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> data;
-    int index;
-    int start_size;
-} PyUICollectionIterObject;
-
-namespace mcrfpydef {
-    //PyObject* py_instance(std::shared_ptr<UIDrawable> source);
-    // This function segfaults on tp_alloc for an unknown reason, but works inline with mcrfpydef:: methods.
-
-#define RET_PY_INSTANCE(target) {                       \
-switch (target->derived_type())                         \
-{                                                       \
-    case PyObjectsEnum::UIFRAME:                        \
-    {                                                   \
-        PyUIFrameObject* o = (PyUIFrameObject*)((&PyUIFrameType)->tp_alloc(&PyUIFrameType, 0)); \
-        if (o)                                          \
-        {                                               \
-            auto p = std::static_pointer_cast<UIFrame>(target); \
-            o->data = p;                                \
-            auto utarget = o->data;                     \
-        }                                               \
-        return (PyObject*)o;                            \
-    }                                                   \
-    case PyObjectsEnum::UICAPTION:                        \
-    {                                                   \
-        PyUICaptionObject* o = (PyUICaptionObject*)((&PyUICaptionType)->tp_alloc(&PyUICaptionType, 0)); \
-        if (o)                                          \
-        {                                               \
-            auto p = std::static_pointer_cast<UICaption>(target); \
-            o->data = p;                                \
-            auto utarget = o->data;                     \
-        }                                               \
-        return (PyObject*)o;                            \
-    }                                                   \
-    case PyObjectsEnum::UISPRITE:                        \
-    {                                                   \
-        PyUISpriteObject* o = (PyUISpriteObject*)((&PyUISpriteType)->tp_alloc(&PyUISpriteType, 0)); \
-        if (o)                                          \
-        {                                               \
-            auto p = std::static_pointer_cast<UISprite>(target); \
-            o->data = p;                                \
-            auto utarget = o->data;                     \
-        }                                               \
-        return (PyObject*)o;                            \
-    }                                                   \
-    case PyObjectsEnum::UIGRID:                        \
-    {                                                   \
-        PyUIGridObject* o = (PyUIGridObject*)((&PyUIGridType)->tp_alloc(&PyUIGridType, 0)); \
-        if (o)                                          \
-        {                                               \
-            auto p = std::static_pointer_cast<UIGrid>(target); \
-            o->data = p;                                \
-            auto utarget = o->data;                     \
-        }                                               \
-        return (PyObject*)o;                            \
-    }                                                   \
-}                                                       \
-}
-// end macro definition
-
-//TODO: add this method to class scope; move implementation to .cpp file
-/*
-static PyObject* PyUIDrawable_get_click(PyObject* self, void* closure) {
-    PyObjectsEnum objtype = static_cast<PyObjectsEnum>(reinterpret_cast<long>(closure)); // trust me bro, it's an Enum
-    PyObject* ptr;
-
-    switch (objtype)
-    {
-        case PyObjectsEnum::UIFRAME:
-            ptr = ((PyUIFrameObject*)self)->data->click_callable->borrow();
-            break;
-        case PyObjectsEnum::UICAPTION:
-            ptr = ((PyUICaptionObject*)self)->data->click_callable->borrow();
-            break;
-        case PyObjectsEnum::UISPRITE:
-            ptr = ((PyUISpriteObject*)self)->data->click_callable->borrow();
-            break;
-        case PyObjectsEnum::UIGRID:
-            ptr = ((PyUIGridObject*)self)->data->click_callable->borrow();
-            break;
-        default:
-            PyErr_SetString(PyExc_TypeError, "no idea how you did that; invalid UIDrawable derived instance for _get_click");
-            return NULL;
-    }
-    if (ptr && ptr != Py_None)
-        return ptr;
-    else
-        return Py_None;
-}*/
-
-//TODO: add this method to class scope; move implementation to .cpp file
-/*
-static int PyUIDrawable_set_click(PyObject* self, PyObject* value, void* closure) {
-    PyObjectsEnum objtype = static_cast<PyObjectsEnum>(reinterpret_cast<long>(closure)); // trust me bro, it's an Enum
-    UIDrawable* target;
-    switch (objtype)
-    {
-        case PyObjectsEnum::UIFRAME:
-            target = (((PyUIFrameObject*)self)->data.get());
-            break;
-        case PyObjectsEnum::UICAPTION:
-            target = (((PyUICaptionObject*)self)->data.get());
-            break;
-        case PyObjectsEnum::UISPRITE:
-            target = (((PyUISpriteObject*)self)->data.get());
-            break;
-        case PyObjectsEnum::UIGRID:
-            target = (((PyUIGridObject*)self)->data.get());
-            break;
-        default:
-            PyErr_SetString(PyExc_TypeError, "no idea how you did that; invalid UIDrawable derived instance for _set_click");
-            return -1;
-    }
-
-	if (value == Py_None)
-	{
-		target->click_unregister();
-	} else {
-	    target->click_register(value);
-	}
-    return 0;
-}
-*/
-}

src/UIEntity.cpp

@@ -1,177 +0,0 @@
-#include "UIEntity.h"
-#include "UIGrid.h"
-#include "McRFPy_API.h"
-
-UIEntity::UIEntity() {} // this will not work lol. TODO remove default constructor by finding the shared pointer inits that use it
-
-UIEntity::UIEntity(UIGrid& grid)
-: gridstate(grid.grid_x * grid.grid_y)
-{
-}
-
-PyObject* UIEntity::at(PyUIEntityObject* self, PyObject* o) {
-    int x, y;
-    if (!PyArg_ParseTuple(o, "ii", &x, &y)) {
-        PyErr_SetString(PyExc_TypeError, "UIEntity.at requires two integer arguments: (x, y)");
-        return NULL;
-    }
-    
-    if (self->data->grid == NULL) {
-        PyErr_SetString(PyExc_ValueError, "Entity cannot access surroundings because it is not associated with a grid");
-        return NULL;
-    }
-    /*
-    PyUIGridPointStateObject* obj = (PyUIGridPointStateObject*)((&mcrfpydef::PyUIGridPointStateType)->tp_alloc(&mcrfpydef::PyUIGridPointStateType, 0));
-    */
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "GridPointState");
-    auto obj = (PyUIGridPointStateObject*)type->tp_alloc(type, 0);
-    //auto target = std::static_pointer_cast<UIEntity>(target);
-    obj->data = &(self->data->gridstate[y + self->data->grid->grid_x * x]);
-    obj->grid = self->data->grid;
-    obj->entity = self->data;
-    return (PyObject*)obj;
-
-}
-
-int UIEntity::init(PyUIEntityObject* self, PyObject* args, PyObject* kwds) {
-    static const char* keywords[] = { "x", "y", "texture", "sprite_index", "grid", nullptr };
-    float x = 0.0f, y = 0.0f, scale = 1.0f;
-    int sprite_index = -1;
-    PyObject* texture = NULL;
-    PyObject* grid = NULL;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "ffOi|O",
-        const_cast<char**>(keywords), &x, &y, &texture, &sprite_index, &grid))
-    {
-        return -1;
-    }
-
-    // check types for texture
-    //
-    // Set Texture
-    //
-    if (texture != NULL && !PyObject_IsInstance(texture, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Texture"))){
-        PyErr_SetString(PyExc_TypeError, "texture must be a mcrfpy.Texture instance");
-        return -1;
-    } /*else if (texture != NULL) // this section needs to go; texture isn't optional and isn't managed by the UI objects anymore
-    {
-        self->texture = texture;
-        Py_INCREF(texture);
-    } else
-    {
-        // default tex?
-    }*/
-
-    if (grid != NULL && !PyObject_IsInstance(grid, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Grid"))) {
-        PyErr_SetString(PyExc_TypeError, "grid must be a mcrfpy.Grid instance");
-        return -1;
-    }
-
-    auto pytexture = (PyTextureObject*)texture;
-    if (grid == NULL)
-        self->data = std::make_shared<UIEntity>();
-    else
-        self->data = std::make_shared<UIEntity>(*((PyUIGridObject*)grid)->data);
-
-    // TODO - PyTextureObjects and IndexTextures are a little bit of a mess with shared/unshared pointers
-    self->data->sprite = UISprite(pytexture->data, sprite_index, sf::Vector2f(0,0), 1.0);
-    self->data->position = sf::Vector2f(x, y);
-    if (grid != NULL) {
-        PyUIGridObject* pygrid = (PyUIGridObject*)grid;
-        self->data->grid = pygrid->data;
-        // todone - on creation of Entity with Grid assignment, also append it to the entity list
-        pygrid->data->entities->push_back(self->data);
-    }
-    return 0;
-}
-
-
-
-PyObject* UIEntity::get_spritenumber(PyUIEntityObject* self, void* closure) {
-    return PyLong_FromDouble(self->data->sprite.getSpriteIndex());
-}
-
-PyObject* sfVector2f_to_PyObject(sf::Vector2f vector) {
-    return Py_BuildValue("(ff)", vector.x, vector.y);
-}
-
-sf::Vector2f PyObject_to_sfVector2f(PyObject* obj) {
-    float x, y;
-    if (!PyArg_ParseTuple(obj, "ff", &x, &y)) {
-        return sf::Vector2f(); // TODO / reconsider this default: Return default vector on parse error
-    }
-    return sf::Vector2f(x, y);
-}
-
-// TODO - deprecate / remove this helper
-PyObject* UIGridPointState_to_PyObject(const UIGridPointState& state) {
-    return PyObject_New(PyObject, (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "GridPointState"));
-}
-
-PyObject* UIGridPointStateVector_to_PyList(const std::vector<UIGridPointState>& vec) {
-    PyObject* list = PyList_New(vec.size());
-    if (!list) return PyErr_NoMemory();
-
-    for (size_t i = 0; i < vec.size(); ++i) {
-        PyObject* obj = UIGridPointState_to_PyObject(vec[i]);
-        if (!obj) { // Cleanup on failure
-            Py_DECREF(list);
-            return NULL;
-        }
-        PyList_SET_ITEM(list, i, obj); // This steals a reference to obj
-    }
-
-    return list;
-}
-
-PyObject* UIEntity::get_position(PyUIEntityObject* self, void* closure) {
-    return sfVector2f_to_PyObject(self->data->position);
-}
-
-int UIEntity::set_position(PyUIEntityObject* self, PyObject* value, void* closure) {
-    self->data->position = PyObject_to_sfVector2f(value);
-    return 0;
-}
-
-PyObject* UIEntity::get_gridstate(PyUIEntityObject* self, void* closure) {
-    // Assuming a function to convert std::vector<UIGridPointState> to PyObject* list
-    return UIGridPointStateVector_to_PyList(self->data->gridstate);
-}
-
-int UIEntity::set_spritenumber(PyUIEntityObject* self, PyObject* value, void* closure) {
-    int val;
-    if (PyLong_Check(value))
-        val = PyLong_AsLong(value);
-    else
-    {
-        PyErr_SetString(PyExc_TypeError, "Value must be an integer.");
-        return -1;
-    }
-    //self->data->sprite.sprite_index = val;
-    self->data->sprite.setSpriteIndex(val); // todone - I don't like ".sprite.sprite" in this stack of UIEntity.UISprite.sf::Sprite
-    return 0;
-}
-
-PyMethodDef UIEntity::methods[] = {
-    {"at", (PyCFunction)UIEntity::at, METH_O},
-    {NULL, NULL, 0, NULL}
-};
-
-PyGetSetDef UIEntity::getsetters[] = {
-    {"position", (getter)UIEntity::get_position, (setter)UIEntity::set_position, "Entity position", NULL},
-    {"gridstate", (getter)UIEntity::get_gridstate, NULL, "Grid point states for the entity", NULL},
-    {"sprite_number", (getter)UIEntity::get_spritenumber, (setter)UIEntity::set_spritenumber, "Sprite number (index) on the texture on the display", NULL},
-    {NULL}  /* Sentinel */
-};
-
-PyObject* UIEntity::repr(PyUIEntityObject* self) {
-    std::ostringstream ss;
-    if (!self->data) ss << "<Entity (invalid internal object)>";
-    else {
-        auto ent = self->data;
-        ss << "<Entity (x=" << self->data->position.x << ", y=" << self->data->position.y << ", sprite_number=" << self->data->sprite.getSpriteIndex() <<
-         ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}

src/UIEntity.h

@@ -1,75 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "structmember.h"
-#include "IndexTexture.h"
-#include "Resources.h"
-#include <list>
-
-#include "PyCallable.h"
-#include "PyTexture.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "PyFont.h"
-
-#include "UIGridPoint.h"
-#include "UIDrawable.h"
-#include "UIBase.h"
-#include "UISprite.h"
-
-class UIGrid;
-
-//class UIEntity;
-//typedef struct {
-//    PyObject_HEAD
-//    std::shared_ptr<UIEntity> data;
-//} PyUIEntityObject;
-
-// helper methods with no namespace requirement
-static PyObject* sfVector2f_to_PyObject(sf::Vector2f vector);
-static sf::Vector2f PyObject_to_sfVector2f(PyObject* obj);
-static PyObject* UIGridPointState_to_PyObject(const UIGridPointState& state);
-static PyObject* UIGridPointStateVector_to_PyList(const std::vector<UIGridPointState>& vec);
-
-// TODO: make UIEntity a drawable
-class UIEntity//: public UIDrawable
-{
-public:
-    //PyObject* self;
-    std::shared_ptr<UIGrid> grid;
-    std::vector<UIGridPointState> gridstate;
-    UISprite sprite;
-    sf::Vector2f position; //(x,y) in grid coordinates; float for animation
-    void render(sf::Vector2f); //override final;
-
-    UIEntity();
-    UIEntity(UIGrid&);
-    
-    static PyObject* at(PyUIEntityObject* self, PyObject* o);
-    static int init(PyUIEntityObject* self, PyObject* args, PyObject* kwds);
-
-    static PyObject* get_position(PyUIEntityObject* self, void* closure);
-    static int set_position(PyUIEntityObject* self, PyObject* value, void* closure);
-    static PyObject* get_gridstate(PyUIEntityObject* self, void* closure);
-    static PyObject* get_spritenumber(PyUIEntityObject* self, void* closure);
-    static int set_spritenumber(PyUIEntityObject* self, PyObject* value, void* closure);
-    static PyMethodDef methods[];
-    static PyGetSetDef getsetters[];
-    static PyObject* repr(PyUIEntityObject* self);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUIEntityType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.Entity",
-        .tp_basicsize = sizeof(PyUIEntityObject),
-        .tp_itemsize = 0,
-        .tp_repr = (reprfunc)UIEntity::repr,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = "UIEntity objects",
-        .tp_methods = UIEntity::methods,
-        .tp_getset = UIEntity::getsetters,
-        .tp_init = (initproc)UIEntity::init,
-        .tp_new = PyType_GenericNew,
-    };
-}

src/UIFrame.cpp

@@ -1,265 +0,0 @@
-#include "UIFrame.h"
-#include "UICollection.h"
-#include "GameEngine.h"
-
-UIDrawable* UIFrame::click_at(sf::Vector2f point)
-{
-    for (auto e: *children)
-    {
-        auto p = e->click_at(point + box.getPosition());
-        if (p)
-            return p;
-    }
-    if (click_callable)
-    {
-        float x = box.getPosition().x, y = box.getPosition().y, w = box.getSize().x, h = box.getSize().y;
-        if (point.x > x && point.y > y && point.x < x+w && point.y < y+h) return this;
-    }
-    return NULL;
-}
-
-UIFrame::UIFrame()
-: outline(0)
-{
-    children = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
-    box.setPosition(0, 0);
-    box.setSize(sf::Vector2f(0, 0));
-}
-
-UIFrame::UIFrame(float _x, float _y, float _w, float _h)
-: outline(0)
-{
-    box.setPosition(_x, _y);
-    box.setSize(sf::Vector2f(_w, _h));
-    children = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
-}
-
-UIFrame::~UIFrame()
-{
-    children.reset();
-}
-
-PyObjectsEnum UIFrame::derived_type()
-{
-    return PyObjectsEnum::UIFRAME;
-}
-
-void UIFrame::render(sf::Vector2f offset)
-{
-    box.move(offset);
-    Resources::game->getWindow().draw(box);
-    box.move(-offset);
-
-    for (auto drawable : *children) {
-        drawable->render(offset + box.getPosition());
-    }
-}
-
-PyObject* UIFrame::get_children(PyUIFrameObject* self, void* closure)
-{
-    // create PyUICollection instance pointing to self->data->children
-    //PyUICollectionObject* o = (PyUICollectionObject*)mcrfpydef::PyUICollectionType.tp_alloc(&mcrfpydef::PyUICollectionType, 0);
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "UICollection");
-    auto o = (PyUICollectionObject*)type->tp_alloc(type, 0);
-    if (o)
-        o->data = self->data->children;
-    return (PyObject*)o;
-}
-
-
-PyObject* UIFrame::get_float_member(PyUIFrameObject* self, void* closure)
-{
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (member_ptr == 0)
-        return PyFloat_FromDouble(self->data->box.getPosition().x);
-    else if (member_ptr == 1)
-        return PyFloat_FromDouble(self->data->box.getPosition().y);
-    else if (member_ptr == 2)
-        return PyFloat_FromDouble(self->data->box.getSize().x);
-    else if (member_ptr == 3)
-        return PyFloat_FromDouble(self->data->box.getSize().y);
-    else if (member_ptr == 4)
-        return PyFloat_FromDouble(self->data->box.getOutlineThickness());
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-}
-
-int UIFrame::set_float_member(PyUIFrameObject* self, PyObject* value, void* closure)
-{
-    float val;
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (PyFloat_Check(value))
-    {
-        val = PyFloat_AsDouble(value);
-    }
-    else if (PyLong_Check(value))
-    {
-        val = PyLong_AsLong(value);
-    }
-    else
-    {
-        PyErr_SetString(PyExc_TypeError, "Value must be an integer.");
-        return -1;
-    }
-    if (member_ptr == 0) //x
-        self->data->box.setPosition(val, self->data->box.getPosition().y);
-    else if (member_ptr == 1) //y
-        self->data->box.setPosition(self->data->box.getPosition().x, val);
-    else if (member_ptr == 2) //w
-        self->data->box.setSize(sf::Vector2f(val, self->data->box.getSize().y));
-    else if (member_ptr == 3) //h
-        self->data->box.setSize(sf::Vector2f(self->data->box.getSize().x, val));
-    else if (member_ptr == 4) //outline
-        self->data->box.setOutlineThickness(val);
-    return 0;
-}
-
-PyObject* UIFrame::get_color_member(PyUIFrameObject* self, void* closure)
-{
-    // validate closure (should be impossible to be wrong, but it's thorough)
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (member_ptr != 0 && member_ptr != 1)
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-    //PyTypeObject* colorType = &PyColorType;
-    auto colorType = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color");
-    PyObject* pyColor = colorType->tp_alloc(colorType, 0);
-    if (pyColor == NULL)
-    {
-        std::cout << "failure to allocate mcrfpy.Color / PyColorType" << std::endl;
-        return NULL;
-    }
-    PyColorObject* pyColorObj = reinterpret_cast<PyColorObject*>(pyColor);
-
-    // fetch correct member data
-    sf::Color color;
-    if (member_ptr == 0)
-    {
-        color = self->data->box.getFillColor();
-        //return Py_BuildValue("(iii)", color.r, color.g, color.b);
-    }
-    else if (member_ptr == 1)
-    {
-        color = self->data->box.getOutlineColor();
-        //return Py_BuildValue("(iii)", color.r, color.g, color.b);
-    }
-    
-    return PyColor(color).pyObject();
-}
-
-int UIFrame::set_color_member(PyUIFrameObject* self, PyObject* value, void* closure)
-{
-    //TODO: this logic of (PyColor instance OR tuple -> sf::color) should be encapsulated for reuse
-    auto member_ptr = reinterpret_cast<long>(closure);
-    int r, g, b, a;
-    if (PyObject_IsInstance(value, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color")))
-    {
-        sf::Color c = ((PyColorObject*)value)->data;
-        r = c.r; g = c.g; b = c.b; a = c.a;
-    }
-    else if (!PyTuple_Check(value) || PyTuple_Size(value) < 3 || PyTuple_Size(value) > 4)
-    {
-        // reject non-Color, non-tuple value
-        PyErr_SetString(PyExc_TypeError, "Value must be a tuple of 3 or 4 integers or an mcrfpy.Color object.");
-        return -1;
-    }
-    else // get value from tuples
-    {
-        r = PyLong_AsLong(PyTuple_GetItem(value, 0));
-        g = PyLong_AsLong(PyTuple_GetItem(value, 1));
-        b = PyLong_AsLong(PyTuple_GetItem(value, 2));
-        a = 255;
-
-        if (PyTuple_Size(value) == 4)
-        {
-            a = PyLong_AsLong(PyTuple_GetItem(value, 3));
-        }
-    }
-
-    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255)
-    {
-        PyErr_SetString(PyExc_ValueError, "Color values must be between 0 and 255.");
-        return -1;
-    }
-
-    if (member_ptr == 0)
-    {
-        self->data->box.setFillColor(sf::Color(r, g, b, a));
-    }
-    else if (member_ptr == 1)
-    {
-        self->data->box.setOutlineColor(sf::Color(r, g, b, a));
-    }
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return -1;
-    }
-
-    return 0;
-}
-
-PyGetSetDef UIFrame::getsetters[] = {
-    {"x", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "X coordinate of top-left corner",   (void*)0},
-    {"y", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "Y coordinate of top-left corner",   (void*)1},
-    {"w", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "width of the rectangle",   (void*)2},
-    {"h", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "height of the rectangle",   (void*)3},
-    {"outline", (getter)UIFrame::get_float_member, (setter)UIFrame::set_float_member, "Thickness of the border",   (void*)4},
-    {"fill_color", (getter)UIFrame::get_color_member, (setter)UIFrame::set_color_member, "Fill color of the rectangle", (void*)0},
-    {"outline_color", (getter)UIFrame::get_color_member, (setter)UIFrame::set_color_member, "Outline color of the rectangle", (void*)1},
-    {"children", (getter)UIFrame::get_children, NULL, "UICollection of objects on top of this one", NULL},
-    {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UIFRAME},
-    {NULL}
-};
-
-PyObject* UIFrame::repr(PyUIFrameObject* self)
-{
-    std::ostringstream ss;
-    if (!self->data) ss << "<Frame (invalid internal object)>";
-    else {
-        auto box = self->data->box;
-        auto fc = box.getFillColor();
-        auto oc = box.getOutlineColor();
-        ss << "<Frame (x=" << box.getPosition().x << ", y=" << box.getPosition().y << ", w=" << 
-            box.getSize().x << ", w=" << box.getSize().y << ", " <<
-            "outline=" << box.getOutlineThickness() << ", " << 
-            "fill_color=(" << (int)fc.r << ", " << (int)fc.g << ", " << (int)fc.b << ", " << (int)fc.a <<"), " <<
-            "outline_color=(" << (int)oc.r << ", " << (int)oc.g << ", " << (int)oc.b << ", " << (int)oc.a <<"), " <<
-            self->data->children->size() << " child objects" <<
-            ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-int UIFrame::init(PyUIFrameObject* self, PyObject* args, PyObject* kwds)
-{
-    //std::cout << "Init called\n";
-    const char* keywords[] = { "x", "y", "w", "h", "fill_color", "outline_color", "outline", nullptr }; 
-    float x = 0.0f, y = 0.0f, w = 0.0f, h=0.0f, outline=0.0f;
-    PyObject* fill_color = 0;
-    PyObject* outline_color = 0;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "ffff|OOf", const_cast<char**>(keywords), &x, &y, &w, &h, &fill_color, &outline_color, &outline))
-    {
-        return -1;
-    }
-
-    self->data->box.setPosition(sf::Vector2f(x, y));
-    self->data->box.setSize(sf::Vector2f(w, h));
-    self->data->box.setOutlineThickness(outline);
-    // getsetter abuse because I haven't standardized Color object parsing (TODO)
-    int err_val = 0;
-    if (fill_color && fill_color != Py_None) err_val = UIFrame::set_color_member(self, fill_color, (void*)0);
-    else self->data->box.setFillColor(sf::Color(0,0,0,255));
-    if (err_val) return err_val;
-    if (outline_color && outline_color != Py_None) err_val = UIFrame::set_color_member(self, outline_color, (void*)1);
-    else self->data->box.setOutlineColor(sf::Color(128,128,128,255));
-    if (err_val) return err_val;
-    return 0;
-}

src/UIFrame.h

@@ -1,77 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "structmember.h"
-#include "IndexTexture.h"
-#include "Resources.h"
-#include <list>
-
-#include "PyCallable.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "UIDrawable.h"
-#include "UIBase.h"
-
-//class UIFrame;
-//
-//typedef struct {
-//    PyObject_HEAD
-//    std::shared_ptr<UIFrame> data;
-//} PyUIFrameObject;
-
-class UIFrame: public UIDrawable
-{
-public:
-    UIFrame(float, float, float, float);
-    UIFrame();
-    ~UIFrame();
-    sf::RectangleShape box;
-    float outline;
-    std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> children;
-    void render(sf::Vector2f) override final;
-    void move(sf::Vector2f);
-    PyObjectsEnum derived_type() override final;
-    virtual UIDrawable* click_at(sf::Vector2f point) override final;
-
-    static PyObject* get_children(PyUIFrameObject* self, void* closure);
-
-    static PyObject* get_float_member(PyUIFrameObject* self, void* closure);
-    static int set_float_member(PyUIFrameObject* self, PyObject* value, void* closure);
-    static PyObject* get_color_member(PyUIFrameObject* self, void* closure);
-    static int set_color_member(PyUIFrameObject* self, PyObject* value, void* closure);
-    static PyGetSetDef getsetters[];
-    static PyObject* repr(PyUIFrameObject* self);
-    static int init(PyUIFrameObject* self, PyObject* args, PyObject* kwds);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUIFrameType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.Frame",
-        .tp_basicsize = sizeof(PyUIFrameObject),
-        .tp_itemsize = 0,
-        .tp_dealloc = (destructor)[](PyObject* self)
-        {
-            PyUIFrameObject* obj = (PyUIFrameObject*)self;
-            obj->data.reset();
-            Py_TYPE(self)->tp_free(self);
-        },
-        .tp_repr = (reprfunc)UIFrame::repr,
-        //.tp_hash = NULL,
-        //.tp_iter
-        //.tp_iternext
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("docstring"),
-        //.tp_methods = PyUIFrame_methods,
-        //.tp_members = PyUIFrame_members,
-        .tp_getset = UIFrame::getsetters,
-        //.tp_base = NULL,
-        .tp_init = (initproc)UIFrame::init,
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            PyUIFrameObject* self = (PyUIFrameObject*)type->tp_alloc(type, 0);
-            if (self) self->data = std::make_shared<UIFrame>();
-            return (PyObject*)self;
-        }
-    };
-}

src/UIGrid.cpp

@@ -1,639 +0,0 @@
-#include "UIGrid.h"
-#include "GameEngine.h"
-#include "McRFPy_API.h"
-
-UIGrid::UIGrid() {}
-
-UIGrid::UIGrid(int gx, int gy, std::shared_ptr<PyTexture> _ptex, sf::Vector2f _xy, sf::Vector2f _wh)
-: grid_x(gx), grid_y(gy),
-  zoom(1.0f), center_x((gx/2) * _ptex->sprite_width), center_y((gy/2) * _ptex->sprite_height),
-  ptex(_ptex), points(gx * gy)
-{
-    entities = std::make_shared<std::list<std::shared_ptr<UIEntity>>>();
-
-    box.setSize(_wh);
-    box.setPosition(_xy); 
-
-    box.setFillColor(sf::Color(0,0,0,0));
-    // create renderTexture with maximum theoretical size; sprite can resize to show whatever amount needs to be rendered
-    renderTexture.create(1920, 1080); // TODO - renderTexture should be window size; above 1080p this will cause rendering errors
-    
-    sprite = ptex->sprite(0);
-
-    output.setTextureRect(
-         sf::IntRect(0, 0,
-         box.getSize().x, box.getSize().y));
-     output.setPosition(box.getPosition());
-     // textures are upside-down inside renderTexture
-     output.setTexture(renderTexture.getTexture());
-
-}
-
-void UIGrid::update() {}
-
-
-void UIGrid::render(sf::Vector2f)
-{
-    output.setPosition(box.getPosition()); // output sprite can move; update position when drawing
-    // output size can change; update size when drawing
-    output.setTextureRect(
-         sf::IntRect(0, 0,
-         box.getSize().x, box.getSize().y));
-    renderTexture.clear(sf::Color(8, 8, 8, 255)); // TODO - UIGrid needs a "background color" field
-    // sprites that are visible according to zoom, center_x, center_y, and box width
-    float center_x_sq = center_x / ptex->sprite_width;
-    float center_y_sq = center_y / ptex->sprite_height;
-
-    float width_sq = box.getSize().x / (ptex->sprite_width * zoom);
-    float height_sq = box.getSize().y / (ptex->sprite_height * zoom);
-    float left_edge = center_x_sq - (width_sq / 2.0);
-    float top_edge = center_y_sq - (height_sq / 2.0);
-
-    int left_spritepixels = center_x - (box.getSize().x / 2.0 / zoom);
-    int top_spritepixels = center_y - (box.getSize().y / 2.0 / zoom);
-
-    //sprite.setScale(sf::Vector2f(zoom, zoom));
-    sf::RectangleShape r; // for colors and overlays
-    r.setSize(sf::Vector2f(ptex->sprite_width * zoom, ptex->sprite_height * zoom));
-    r.setOutlineThickness(0);
-
-    int x_limit = left_edge + width_sq + 2;
-    if (x_limit > grid_x) x_limit = grid_x;
-
-    int y_limit = top_edge + height_sq + 2;
-    if (y_limit > grid_y) y_limit = grid_y;
-
-    // base layer - bottom color, tile sprite ("ground")
-    for (int x = (left_edge - 1 >= 0 ? left_edge - 1 : 0);
-        x < x_limit; //x < view_width; 
-        x+=1)
-    {
-        //for (float y = (top_edge >= 0 ? top_edge : 0); 
-        for (int y = (top_edge - 1 >= 0 ? top_edge - 1 : 0);
-            y < y_limit; //y < view_height;
-            y+=1)
-        {
-            auto pixel_pos = sf::Vector2f(
-                    (x*ptex->sprite_width - left_spritepixels) * zoom,
-                    (y*ptex->sprite_height - top_spritepixels) * zoom );
-
-            auto gridpoint = at(std::floor(x), std::floor(y));
-
-            //sprite.setPosition(pixel_pos);
-
-            r.setPosition(pixel_pos);
-            r.setFillColor(gridpoint.color);
-            renderTexture.draw(r);
-
-            // tilesprite
-            // if discovered but not visible, set opacity to 90%
-            // if not discovered... just don't draw it?
-            if (gridpoint.tilesprite != -1) {
-                sprite = ptex->sprite(gridpoint.tilesprite, pixel_pos, sf::Vector2f(zoom, zoom)); //setSprite(gridpoint.tilesprite);;
-                renderTexture.draw(sprite);
-            }
-        }
-    }
-
-    // middle layer - entities
-    // disabling entity rendering until I can render their UISprite inside the rendertexture (not directly to window)
-    for (auto e : *entities) {
-        // TODO skip out-of-bounds entities (grid square not visible at all, check for partially on visible grid squares / floating point grid position)
-        //auto drawent = e->cGrid->indexsprite.drawable();
-        auto& drawent = e->sprite;
-        //drawent.setScale(zoom, zoom);
-        drawent.setScale(sf::Vector2f(zoom, zoom));
-        auto pixel_pos = sf::Vector2f(
-            (e->position.x*ptex->sprite_width - left_spritepixels) * zoom,
-            (e->position.y*ptex->sprite_height - top_spritepixels) * zoom );
-        //drawent.setPosition(pixel_pos);
-        //renderTexture.draw(drawent);
-        drawent.render(pixel_pos, renderTexture);
-    }
-    
-
-    // top layer - opacity for discovered / visible status (debug, basically)
-    /* // Disabled until I attach a "perspective"
-    for (int x = (left_edge - 1 >= 0 ? left_edge - 1 : 0);
-        x < x_limit; //x < view_width; 
-        x+=1)
-    {
-        //for (float y = (top_edge >= 0 ? top_edge : 0); 
-        for (int y = (top_edge - 1 >= 0 ? top_edge - 1 : 0);
-            y < y_limit; //y < view_height;
-            y+=1)
-        {
-
-            auto pixel_pos = sf::Vector2f(
-                    (x*itex->grid_size - left_spritepixels) * zoom,
-                    (y*itex->grid_size - top_spritepixels) * zoom );
-
-            auto gridpoint = at(std::floor(x), std::floor(y));
-
-            sprite.setPosition(pixel_pos);
-
-            r.setPosition(pixel_pos);
-
-            // visible & discovered layers for testing purposes
-            if (!gridpoint.discovered) {
-                r.setFillColor(sf::Color(16, 16, 20, 192)); // 255 opacity for actual blackout
-                renderTexture.draw(r);
-            } else if (!gridpoint.visible) {
-                r.setFillColor(sf::Color(32, 32, 40, 128));
-                renderTexture.draw(r);
-            }
-
-            // overlay
-
-            // uisprite
-        }
-    }
-    */
-
-    // grid lines for testing & validation
-    /*
-    sf::Vertex line[] =
-    {
-        sf::Vertex(sf::Vector2f(0, 0), sf::Color::Red),
-        sf::Vertex(box.getSize(), sf::Color::Red),
-
-    };
-
-    renderTexture.draw(line, 2, sf::Lines);
-    sf::Vertex lineb[] =
-    {
-        sf::Vertex(sf::Vector2f(0, box.getSize().y), sf::Color::Blue),
-        sf::Vertex(sf::Vector2f(box.getSize().x, 0), sf::Color::Blue),
-
-    };
-
-    renderTexture.draw(lineb, 2, sf::Lines);
-    */
-
-    // render to window
-    renderTexture.display();
-    Resources::game->getWindow().draw(output);
-
-}
-
-UIGridPoint& UIGrid::at(int x, int y)
-{
-    return points[y * grid_x + x];
-}
-
-PyObjectsEnum UIGrid::derived_type()
-{
-    return PyObjectsEnum::UIGRID;
-}
-
-std::shared_ptr<PyTexture> UIGrid::getTexture()
-{
-    return ptex;
-}
-
-UIDrawable* UIGrid::click_at(sf::Vector2f point)
-{
-    if (click_callable)
-    {
-        if(box.getGlobalBounds().contains(point)) return this;
-    }
-    return NULL;
-}
-
-
-int UIGrid::init(PyUIGridObject* self, PyObject* args, PyObject* kwds) {
-    int grid_x, grid_y;
-    PyObject* textureObj;
-    float box_x, box_y, box_w, box_h;
-
-    if (!PyArg_ParseTuple(args, "iiOffff", &grid_x, &grid_y, &textureObj, &box_x, &box_y, &box_w, &box_h)) {
-        return -1; // If parsing fails, return an error
-    }
-
-    // Convert PyObject texture to IndexTexture*
-    // This requires the texture object to have been initialized similar to UISprite's texture handling
-
-    //if (!PyObject_IsInstance(textureObj, (PyObject*)&PyTextureType)) {
-    if (!PyObject_IsInstance(textureObj, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Texture"))) {
-        PyErr_SetString(PyExc_TypeError, "texture must be a mcrfpy.Texture instance");
-        return -1;
-    }
-    PyTextureObject* pyTexture = reinterpret_cast<PyTextureObject*>(textureObj);
-    // TODO (7DRL day 2, item 4.) use shared_ptr / PyTextureObject on UIGrid
-    //IndexTexture* texture = pyTexture->data.get();
-    
-    // Initialize UIGrid
-    //self->data = new UIGrid(grid_x, grid_y, texture, sf::Vector2f(box_x, box_y), sf::Vector2f(box_w, box_h));
-    self->data = std::make_shared<UIGrid>(grid_x, grid_y, pyTexture->data, 
-            sf::Vector2f(box_x, box_y), sf::Vector2f(box_w, box_h));
-    return 0; // Success
-}
-
-PyObject* UIGrid::get_grid_size(PyUIGridObject* self, void* closure) {
-    return Py_BuildValue("(ii)", self->data->grid_x, self->data->grid_y);
-}
-
-PyObject* UIGrid::get_position(PyUIGridObject* self, void* closure) {
-    auto& box = self->data->box;
-    return Py_BuildValue("(ff)", box.getPosition().x, box.getPosition().y);
-}
-
-int UIGrid::set_position(PyUIGridObject* self, PyObject* value, void* closure) {
-    float x, y;
-    if (!PyArg_ParseTuple(value, "ff", &x, &y)) {
-        PyErr_SetString(PyExc_ValueError, "Position must be a tuple of two floats");
-        return -1;
-    }
-    self->data->box.setPosition(x, y);
-    return 0;
-}
-
-PyObject* UIGrid::get_size(PyUIGridObject* self, void* closure) {
-    auto& box = self->data->box;
-    return Py_BuildValue("(ff)", box.getSize().x, box.getSize().y);
-}
-
-int UIGrid::set_size(PyUIGridObject* self, PyObject* value, void* closure) {
-    float w, h;
-    if (!PyArg_ParseTuple(value, "ff", &w, &h)) {
-        PyErr_SetString(PyExc_ValueError, "Size must be a tuple of two floats");
-        return -1;
-    }
-    self->data->box.setSize(sf::Vector2f(w, h));
-    return 0;
-}
-
-PyObject* UIGrid::get_center(PyUIGridObject* self, void* closure) {
-    return Py_BuildValue("(ff)", self->data->center_x, self->data->center_y);
-}
-
-int UIGrid::set_center(PyUIGridObject* self, PyObject* value, void* closure) {
-    float x, y;
-    if (!PyArg_ParseTuple(value, "ff", &x, &y)) {
-        PyErr_SetString(PyExc_ValueError, "Size must be a tuple of two floats");
-        return -1;
-    }
-    self->data->center_x = x;
-    self->data->center_y = y;
-    return 0;
-}
-
-PyObject* UIGrid::get_float_member(PyUIGridObject* self, void* closure)
-{
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (member_ptr == 0) // x
-        return PyFloat_FromDouble(self->data->box.getPosition().x);
-    else if (member_ptr == 1) // y
-        return PyFloat_FromDouble(self->data->box.getPosition().y);
-    else if (member_ptr == 2) // w
-        return PyFloat_FromDouble(self->data->box.getSize().x);
-    else if (member_ptr == 3) // h
-        return PyFloat_FromDouble(self->data->box.getSize().y);
-    else if (member_ptr == 4) // center_x
-        return PyFloat_FromDouble(self->data->center_x);
-    else if (member_ptr == 5) // center_y
-        return PyFloat_FromDouble(self->data->center_y);
-    else if (member_ptr == 6) // zoom
-        return PyFloat_FromDouble(self->data->zoom);
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-}
-
-int UIGrid::set_float_member(PyUIGridObject* self, PyObject* value, void* closure)
-{
-    float val;
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (PyFloat_Check(value))
-    {
-        val = PyFloat_AsDouble(value);
-    }
-    else if (PyLong_Check(value))
-    {
-        val = PyLong_AsLong(value);
-    }
-    else
-    {
-        PyErr_SetString(PyExc_TypeError, "Value must be a floating point number.");
-        return -1;
-    }
-    if (member_ptr == 0) // x
-        self->data->box.setPosition(val, self->data->box.getPosition().y);
-    else if (member_ptr == 1) // y
-        self->data->box.setPosition(self->data->box.getPosition().x, val);
-    else if (member_ptr == 2) // w
-        self->data->box.setSize(sf::Vector2f(val, self->data->box.getSize().y));
-    else if (member_ptr == 3) // h
-        self->data->box.setSize(sf::Vector2f(self->data->box.getSize().x, val));
-    else if (member_ptr == 4) // center_x
-        self->data->center_x = val;
-    else if (member_ptr == 5) // center_y
-        self->data->center_y = val;
-    else if (member_ptr == 6) // zoom
-        self->data->zoom = val;
-    return 0;
-}
-// TODO (7DRL Day 2, item 5.) return Texture object
-/*
-PyObject* UIGrid::get_texture(PyUIGridObject* self, void* closure) {
-    Py_INCREF(self->texture);
-    return self->texture;
-}
-*/
-
-PyObject* UIGrid::get_texture(PyUIGridObject* self, void* closure) {
-        //return self->data->getTexture()->pyObject();
-        // PyObject_GetAttrString(McRFPy_API::mcrf_module, "GridPointState")
-        //PyTextureObject* obj = (PyTextureObject*)((&PyTextureType)->tp_alloc(&PyTextureType, 0));
-        auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Texture");
-        auto obj = (PyTextureObject*)type->tp_alloc(type, 0);
-        obj->data = self->data->getTexture();
-        return (PyObject*)obj;
-}
-
-PyObject* UIGrid::py_at(PyUIGridObject* self, PyObject* o)
-{
-    int x, y;
-    if (!PyArg_ParseTuple(o, "ii", &x, &y)) {
-        PyErr_SetString(PyExc_TypeError, "UIGrid.at requires two integer arguments: (x, y)");
-        return NULL;
-    }
-    if (x < 0 || x >= self->data->grid_x) {
-        PyErr_SetString(PyExc_ValueError, "x value out of range (0, Grid.grid_y)");
-        return NULL;
-    }
-    if (y < 0 || y >= self->data->grid_y) {
-        PyErr_SetString(PyExc_ValueError, "y value out of range (0, Grid.grid_y)");
-        return NULL;
-    }
-
-    //PyUIGridPointObject* obj = (PyUIGridPointObject*)((&PyUIGridPointType)->tp_alloc(&PyUIGridPointType, 0));
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "GridPoint");
-    auto obj = (PyUIGridPointObject*)type->tp_alloc(type, 0);
-    //auto target = std::static_pointer_cast<UIEntity>(target);
-    obj->data = &(self->data->points[x + self->data->grid_x * y]);
-    obj->grid = self->data;
-    return (PyObject*)obj;
-}
-
-PyMethodDef UIGrid::methods[] = {
-    {"at", (PyCFunction)UIGrid::py_at, METH_O},
-    {NULL, NULL, 0, NULL}
-};
-
-
-PyGetSetDef UIGrid::getsetters[] = {
-
-    // TODO - refactor into get_vector_member with field identifier values `(void*)n`
-    {"grid_size", (getter)UIGrid::get_grid_size, NULL, "Grid dimensions (grid_x, grid_y)", NULL},
-    {"position", (getter)UIGrid::get_position, (setter)UIGrid::set_position, "Position of the grid (x, y)", NULL},
-    {"size", (getter)UIGrid::get_size, (setter)UIGrid::set_size, "Size of the grid (width, height)", NULL},
-    {"center", (getter)UIGrid::get_center, (setter)UIGrid::set_center, "Grid coordinate at the center of the Grid's view (pan)", NULL},
-
-    {"entities", (getter)UIGrid::get_children, NULL, "EntityCollection of entities on this grid", NULL},
-
-    {"x", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "top-left corner X-coordinate", (void*)0},
-    {"y", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "top-left corner Y-coordinate", (void*)1},
-    {"w", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "visible widget width", (void*)2},
-    {"h", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "visible widget height", (void*)3},
-    {"center_x", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "center of the view X-coordinate", (void*)4},
-    {"center_y", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "center of the view Y-coordinate", (void*)5},
-    {"zoom", (getter)UIGrid::get_float_member, (setter)UIGrid::set_float_member, "zoom factor for displaying the Grid", (void*)6},
-
-    {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UIGRID},
-
-    {"texture", (getter)UIGrid::get_texture, NULL, "Texture of the grid", NULL}, //TODO 7DRL-day2-item5
-    {NULL}  /* Sentinel */
-};
-
-PyObject* UIGrid::get_children(PyUIGridObject* self, void* closure)
-{
-    // create PyUICollection instance pointing to self->data->children
-    //PyUIEntityCollectionObject* o = (PyUIEntityCollectionObject*)PyUIEntityCollectionType.tp_alloc(&PyUIEntityCollectionType, 0);
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "EntityCollection");
-    auto o = (PyUIEntityCollectionObject*)type->tp_alloc(type, 0);
-    if (o) {
-        o->data = self->data->entities; // todone. / BUGFIX - entities isn't a shared pointer on UIGrid, what to do? -- I made it a sp<list<sp<UIEntity>>>
-        o->grid = self->data;
-    }
-    return (PyObject*)o;
-}
-
-PyObject* UIGrid::repr(PyUIGridObject* self)
-{
-
-//    if (member_ptr == 0) // x
-//        self->data->box.setPosition(val, self->data->box.getPosition().y);
-//    else if (member_ptr == 1) // y
-//        self->data->box.setPosition(self->data->box.getPosition().x, val);
-//    else if (member_ptr == 2) // w
-//        self->data->box.setSize(sf::Vector2f(val, self->data->box.getSize().y));
-//    else if (member_ptr == 3) // h
-//        self->data->box.setSize(sf::Vector2f(self->data->box.getSize().x, val));
-//    else if (member_ptr == 4) // center_x
-//        self->data->center_x = val;
-//    else if (member_ptr == 5) // center_y
-//        self->data->center_y = val;
-//    else if (member_ptr == 6) // zoom
-//        self->data->zoom = val;
-
-    std::ostringstream ss;
-    if (!self->data) ss << "<Grid (invalid internal object)>";
-    else {
-        auto grid = self->data;
-        auto box = grid->box;
-        ss << "<Grid (x=" << box.getPosition().x << ", y=" << box.getPosition().y << ", w=" << box.getSize().x << ", h=" << box.getSize().y << ", " <<
-            "center=(" << grid->center_x << ", " << grid->center_y << "), zoom=" << grid->zoom <<
-            ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-/* // TODO standard pointer would need deleted, but I opted for a shared pointer. tp_dealloc currently not even defined in the PyTypeObject
-void PyUIGrid_dealloc(PyUIGridObject* self) {
-    delete self->data; // Clean up the allocated UIGrid object
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-*/
-
-int UIEntityCollectionIter::init(PyUIEntityCollectionIterObject* self, PyObject* args, PyObject* kwds)
-{
-    PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
-    return -1;
-}
-
-PyObject* UIEntityCollectionIter::next(PyUIEntityCollectionIterObject* self)
-{
-    if (self->data->size() != self->start_size)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "collection changed size during iteration");
-        return NULL;
-    }
-
-    if (self->index > self->start_size - 1)
-    {
-        PyErr_SetNone(PyExc_StopIteration);
-        return NULL;
-    }
-    self->index++;
-    auto vec = self->data.get();
-    if (!vec)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "the collection store returned a null pointer");
-        return NULL;
-    }
-    // Advance list iterator since Entities are not stored in a vector (if this code even worked)
-    // vectors only: //auto target = (*vec)[self->index-1];
-    //auto l_front = (*vec).begin();
-    //std::advance(l_front, self->index-1);
-
-    // TODO build PyObject* of the correct UIDrawable subclass to return
-    //return py_instance(target);
-    return NULL;
-}
-
-PyObject* UIEntityCollectionIter::repr(PyUIEntityCollectionIterObject* self)
-{
-    std::ostringstream ss;
-    if (!self->data) ss << "<UICollectionIter (invalid internal object)>";
-    else {
-        ss << "<UICollectionIter (" << self->data->size() << " child objects, @ index " << self->index  << ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-Py_ssize_t UIEntityCollection::len(PyUIEntityCollectionObject* self) {
-    return self->data->size();
-}
-
-PyObject* UIEntityCollection::getitem(PyUIEntityCollectionObject* self, Py_ssize_t index) {
-    // build a Python version of item at self->data[index]
-    //  Copy pasted::
-    auto vec = self->data.get();
-    if (!vec)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "the collection store returned a null pointer");
-        return NULL;
-    }
-    while (index < 0) index += self->data->size();
-    if (index > self->data->size() - 1)
-    {
-        PyErr_SetString(PyExc_IndexError, "EntityCollection index out of range");
-        return NULL;
-    }
-    auto l_begin = (*vec).begin();
-    std::advance(l_begin, index);
-    auto target = *l_begin; //auto target = (*vec)[index];
-    //RET_PY_INSTANCE(target);
-    // construct and return an entity object that points directly into the UIGrid's entity vector
-    //PyUIEntityObject* o = (PyUIEntityObject*)((&PyUIEntityType)->tp_alloc(&PyUIEntityType, 0));
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Entity");
-    auto o = (PyUIEntityObject*)type->tp_alloc(type, 0);
-    auto p = std::static_pointer_cast<UIEntity>(target);
-    o->data = p;
-    return (PyObject*)o;
-return NULL;
-
-
-}
-
-PySequenceMethods UIEntityCollection::sqmethods = {
-    .sq_length = (lenfunc)UIEntityCollection::len,
-    .sq_item = (ssizeargfunc)UIEntityCollection::getitem,
-    //.sq_item_by_index = UIEntityCollection::getitem
-    //.sq_slice - return a subset of the iterable
-    //.sq_ass_item - called when `o[x] = y` is executed (x is any object type)
-    //.sq_ass_slice - cool; no thanks, for now
-    //.sq_contains - called when `x in o` is executed
-    //.sq_ass_item_by_index - called when `o[x] = y` is executed (x is explictly an integer)
-};
-
-PyObject* UIEntityCollection::append(PyUIEntityCollectionObject* self, PyObject* o)
-{
-    // if not UIDrawable subclass, reject it
-    // self->data->push_back( c++ object inside o );
-
-    // this would be a great use case for .tp_base
-    //if (!PyObject_IsInstance(o, (PyObject*)&PyUIEntityType))
-    if (!PyObject_IsInstance(o, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Entity")))
-    {
-        PyErr_SetString(PyExc_TypeError, "Only Entity objects can be added to EntityCollection");
-        return NULL;
-    }
-    PyUIEntityObject* entity = (PyUIEntityObject*)o;
-    self->data->push_back(entity->data);
-    entity->data->grid = self->grid;
-
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-PyObject* UIEntityCollection::remove(PyUIEntityCollectionObject* self, PyObject* o)
-{
-    if (!PyLong_Check(o))
-    {
-        PyErr_SetString(PyExc_TypeError, "UICollection.remove requires an integer index to remove");
-        return NULL;
-    }
-    long index = PyLong_AsLong(o);
-    if (index >= self->data->size())
-    {
-        PyErr_SetString(PyExc_ValueError, "Index out of range");
-        return NULL;
-    }
-    else if (index < 0)
-    {
-        PyErr_SetString(PyExc_NotImplementedError, "reverse indexing is not implemented.");
-        return NULL;
-    }
-
-    // release the shared pointer at correct part of the list
-    self->data->erase(std::next(self->data->begin(), index));
-    Py_INCREF(Py_None);
-    return Py_None;
-}
-
-PyMethodDef UIEntityCollection::methods[] = {
-    {"append", (PyCFunction)UIEntityCollection::append, METH_O},
-    //{"extend", (PyCFunction)UIEntityCollection::extend, METH_O}, // TODO
-    {"remove", (PyCFunction)UIEntityCollection::remove, METH_O},
-    {NULL, NULL, 0, NULL}
-};
-
-PyObject* UIEntityCollection::repr(PyUIEntityCollectionObject* self)
-{
-    std::ostringstream ss;
-    if (!self->data) ss << "<UICollection (invalid internal object)>";
-    else {
-        ss << "<UICollection (" << self->data->size() << " child objects)>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-int UIEntityCollection::init(PyUIEntityCollectionObject* self, PyObject* args, PyObject* kwds)
-{
-    PyErr_SetString(PyExc_TypeError, "EntityCollection cannot be instantiated: a C++ data source is required.");
-    return -1;
-}
-
-PyObject* UIEntityCollection::iter(PyUIEntityCollectionObject* self)
-{
-    //PyUIEntityCollectionIterObject* iterObj;
-    //iterObj = (PyUIEntityCollectionIterObject*)PyUIEntityCollectionIterType.tp_alloc(&PyUIEntityCollectionIterType, 0);
-    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "EntityCollectionIter");
-    auto iterObj = (PyUIEntityCollectionIterObject*)type->tp_alloc(type, 0);
-    if (iterObj == NULL) {
-        return NULL;  // Failed to allocate memory for the iterator object
-    }
-
-    iterObj->data = self->data;
-    iterObj->index = 0;
-    iterObj->start_size = self->data->size();
-
-    return (PyObject*)iterObj;
-}

src/UIGrid.h

@@ -1,184 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "structmember.h"
-#include "IndexTexture.h"
-#include "Resources.h"
-#include <list>
-
-#include "PyCallable.h"
-#include "PyTexture.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "PyFont.h"
-
-#include "UIGridPoint.h"
-#include "UIEntity.h"
-#include "UIDrawable.h"
-#include "UIBase.h"
-
-class UIGrid: public UIDrawable
-{
-private:
-    std::shared_ptr<PyTexture> ptex;
-public:
-    UIGrid();
-    //UIGrid(int, int, IndexTexture*, float, float, float, float);
-    UIGrid(int, int, std::shared_ptr<PyTexture>, sf::Vector2f, sf::Vector2f);
-    void update();
-    void render(sf::Vector2f) override final;
-    UIGridPoint& at(int, int);
-    PyObjectsEnum derived_type() override final;
-    //void setSprite(int);
-    virtual UIDrawable* click_at(sf::Vector2f point) override final;
-
-    int grid_x, grid_y;
-    //int grid_size; // grid sizes are implied by IndexTexture now
-    sf::RectangleShape box;
-    float center_x, center_y, zoom;
-    //IndexTexture* itex;
-    std::shared_ptr<PyTexture> getTexture();
-    sf::Sprite sprite, output;
-    sf::RenderTexture renderTexture;
-    std::vector<UIGridPoint> points;
-    std::shared_ptr<std::list<std::shared_ptr<UIEntity>>> entities;
-
-    static int init(PyUIGridObject* self, PyObject* args, PyObject* kwds);
-    static PyObject* get_grid_size(PyUIGridObject* self, void* closure);
-    static PyObject* get_position(PyUIGridObject* self, void* closure);
-    static int set_position(PyUIGridObject* self, PyObject* value, void* closure);
-    static PyObject* get_size(PyUIGridObject* self, void* closure);
-    static int set_size(PyUIGridObject* self, PyObject* value, void* closure);
-    static PyObject* get_center(PyUIGridObject* self, void* closure);
-    static int set_center(PyUIGridObject* self, PyObject* value, void* closure);
-    static PyObject* get_float_member(PyUIGridObject* self, void* closure);
-    static int set_float_member(PyUIGridObject* self, PyObject* value, void* closure);
-    static PyObject* get_texture(PyUIGridObject* self, void* closure);
-    static PyObject* py_at(PyUIGridObject* self, PyObject* o);
-    static PyMethodDef methods[];
-    static PyGetSetDef getsetters[];
-    static PyObject* get_children(PyUIGridObject* self, void* closure);
-    static PyObject* repr(PyUIGridObject* self);
-    
-};
-
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<std::list<std::shared_ptr<UIEntity>>> data;
-    std::shared_ptr<UIGrid> grid;
-} PyUIEntityCollectionObject;
-
-class UIEntityCollection {
-public:
-    static PySequenceMethods sqmethods;
-    static PyObject* append(PyUIEntityCollectionObject* self, PyObject* o);
-    static PyObject* remove(PyUIEntityCollectionObject* self, PyObject* o);
-    static PyMethodDef methods[];
-    static PyObject* repr(PyUIEntityCollectionObject* self);
-    static int init(PyUIEntityCollectionObject* self, PyObject* args, PyObject* kwds);
-    static PyObject* iter(PyUIEntityCollectionObject* self);
-    static Py_ssize_t len(PyUIEntityCollectionObject* self);
-    static PyObject* getitem(PyUIEntityCollectionObject* self, Py_ssize_t index);
-};
-
-typedef struct {
-    PyObject_HEAD
-    std::shared_ptr<std::list<std::shared_ptr<UIEntity>>> data;
-    int index;
-    int start_size;
-} PyUIEntityCollectionIterObject;
-
-class UIEntityCollectionIter {
-public:
-    static int init(PyUIEntityCollectionIterObject* self, PyObject* args, PyObject* kwds);
-    static PyObject* next(PyUIEntityCollectionIterObject* self);
-    static PyObject* repr(PyUIEntityCollectionIterObject* self);
-    static PyObject* getitem(PyUIEntityCollectionObject* self, Py_ssize_t index);
-    
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUIGridType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.Grid",
-        .tp_basicsize = sizeof(PyUIGridObject),
-        .tp_itemsize = 0,
-        //.tp_dealloc = (destructor)[](PyObject* self)
-        //{
-        //    PyUIGridObject* obj = (PyUIGridObject*)self;
-        //    obj->data.reset();
-        //    Py_TYPE(self)->tp_free(self);
-        //},
-        //TODO - PyUIGrid REPR def:
-        .tp_repr = (reprfunc)UIGrid::repr,
-        //.tp_hash = NULL,
-        //.tp_iter
-        //.tp_iternext
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("docstring"),
-        .tp_methods = UIGrid::methods,
-        //.tp_members = UIGrid::members,
-        .tp_getset = UIGrid::getsetters,
-        //.tp_base = NULL,
-        .tp_init = (initproc)UIGrid::init,
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            PyUIGridObject* self = (PyUIGridObject*)type->tp_alloc(type, 0);
-            if (self) self->data = std::make_shared<UIGrid>();
-            return (PyObject*)self;
-        }
-    };
-
-    static PyTypeObject PyUIEntityCollectionIterType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.UICollectionIter",
-        .tp_basicsize = sizeof(PyUIEntityCollectionIterObject),
-        .tp_itemsize = 0,
-        .tp_dealloc = (destructor)[](PyObject* self)
-        {
-            PyUIEntityCollectionIterObject* obj = (PyUIEntityCollectionIterObject*)self;
-            obj->data.reset();
-            Py_TYPE(self)->tp_free(self);
-        },
-        .tp_repr = (reprfunc)UIEntityCollectionIter::repr,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("Iterator for a collection of UI objects"),
-        .tp_iternext = (iternextfunc)UIEntityCollectionIter::next,
-        //.tp_getset = UIEntityCollection::getset,
-        .tp_init = (initproc)UIEntityCollectionIter::init, // just raise an exception
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
-            return NULL;
-        }
-    };
-
-    static PyTypeObject PyUIEntityCollectionType = {
-        //PyVarObject_/HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.EntityCollection",
-        .tp_basicsize = sizeof(PyUIEntityCollectionObject),
-        .tp_itemsize = 0,
-        .tp_dealloc = (destructor)[](PyObject* self)
-        {
-            PyUIEntityCollectionObject* obj = (PyUIEntityCollectionObject*)self;
-            obj->data.reset();
-            Py_TYPE(self)->tp_free(self);
-        },
-        .tp_repr = (reprfunc)UIEntityCollection::repr,
-        .tp_as_sequence = &UIEntityCollection::sqmethods,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("Iterable, indexable collection of Entities"),
-        .tp_iter = (getiterfunc)UIEntityCollection::iter,
-        .tp_methods = UIEntityCollection::methods, // append, remove
-        //.tp_getset = UIEntityCollection::getset,
-        .tp_init = (initproc)UIEntityCollection::init, // just raise an exception
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            // Does PyUIEntityCollectionType need __new__ if it's not supposed to be instantiable by the user?
-            // Should I just raise an exception? Or is the uninitialized shared_ptr enough of a blocker?
-            PyErr_SetString(PyExc_TypeError, "EntityCollection cannot be instantiated: a C++ data source is required.");
-            return NULL;
-        }
-    };
-
-}

src/UIGridPoint.cpp

@@ -1,158 +0,0 @@
-#include "UIGridPoint.h"
-
-UIGridPoint::UIGridPoint()
-: color(1.0f, 1.0f, 1.0f), color_overlay(0.0f, 0.0f, 0.0f), walkable(false), transparent(false),
- tilesprite(-1), tile_overlay(-1), uisprite(-1)
-{}
-
-// Utility function to convert sf::Color to PyObject*
-PyObject* sfColor_to_PyObject(sf::Color color) {
-    return Py_BuildValue("(iiii)", color.r, color.g, color.b, color.a);
-}
-
-// Utility function to convert PyObject* to sf::Color
-sf::Color PyObject_to_sfColor(PyObject* obj) {
-    int r, g, b, a = 255; // Default alpha to fully opaque if not specified
-    if (!PyArg_ParseTuple(obj, "iii|i", &r, &g, &b, &a)) {
-        return sf::Color(); // Return default color on parse error
-    }
-    return sf::Color(r, g, b, a);
-}
-
-PyObject* UIGridPoint::get_color(PyUIGridPointObject* self, void* closure) {
-    if (reinterpret_cast<long>(closure) == 0) { // color
-        return sfColor_to_PyObject(self->data->color);
-    } else { // color_overlay
-        return sfColor_to_PyObject(self->data->color_overlay);
-    }
-}
-
-int UIGridPoint::set_color(PyUIGridPointObject* self, PyObject* value, void* closure) {
-    sf::Color color = PyObject_to_sfColor(value);
-    if (reinterpret_cast<long>(closure) == 0) { // color
-        self->data->color = color;
-    } else { // color_overlay
-        self->data->color_overlay = color;
-    }
-    return 0;
-}
-
-PyObject* UIGridPoint::get_bool_member(PyUIGridPointObject* self, void* closure) {
-    if (reinterpret_cast<long>(closure) == 0) { // walkable
-        return PyBool_FromLong(self->data->walkable);
-    } else { // transparent
-        return PyBool_FromLong(self->data->transparent);
-    }
-}
-
-int UIGridPoint::set_bool_member(PyUIGridPointObject* self, PyObject* value, void* closure) {
-    if (value == Py_True) {
-        if (reinterpret_cast<long>(closure) == 0) { // walkable
-            self->data->walkable = true;
-        } else { // transparent
-            self->data->transparent = true;
-        }
-    } else if (value == Py_False) {
-        if (reinterpret_cast<long>(closure) == 0) { // walkable
-            self->data->walkable = false;
-        } else { // transparent
-            self->data->transparent = false;
-        }
-    } else {
-        PyErr_SetString(PyExc_ValueError, "Expected a boolean value");
-        return -1;
-    }
-    return 0;
-}
-
-PyObject* UIGridPoint::get_int_member(PyUIGridPointObject* self, void* closure) {
-    switch(reinterpret_cast<long>(closure)) {
-        case 0: return PyLong_FromLong(self->data->tilesprite);
-        case 1: return PyLong_FromLong(self->data->tile_overlay);
-        case 2: return PyLong_FromLong(self->data->uisprite);
-        default: PyErr_SetString(PyExc_RuntimeError, "Invalid closure"); return nullptr;
-    }
-}
-
-int UIGridPoint::set_int_member(PyUIGridPointObject* self, PyObject* value, void* closure) {
-    long val = PyLong_AsLong(value);
-    if (PyErr_Occurred()) return -1;
-
-    switch(reinterpret_cast<long>(closure)) {
-        case 0: self->data->tilesprite = val; break;
-        case 1: self->data->tile_overlay = val; break;
-        case 2: self->data->uisprite = val; break;
-        default: PyErr_SetString(PyExc_RuntimeError, "Invalid closure"); return -1;
-    }
-    return 0;
-}
-
-PyGetSetDef UIGridPoint::getsetters[] = {
-    {"color", (getter)UIGridPoint::get_color, (setter)UIGridPoint::set_color, "GridPoint color", (void*)0},
-    {"color_overlay", (getter)UIGridPoint::get_color, (setter)UIGridPoint::set_color, "GridPoint color overlay", (void*)1},
-    {"walkable", (getter)UIGridPoint::get_bool_member, (setter)UIGridPoint::set_bool_member, "Is the GridPoint walkable", (void*)0},
-    {"transparent", (getter)UIGridPoint::get_bool_member, (setter)UIGridPoint::set_bool_member, "Is the GridPoint transparent", (void*)1},
-    {"tilesprite", (getter)UIGridPoint::get_int_member, (setter)UIGridPoint::set_int_member, "Tile sprite index", (void*)0},
-    {"tile_overlay", (getter)UIGridPoint::get_int_member, (setter)UIGridPoint::set_int_member, "Tile overlay sprite index", (void*)1},
-    {"uisprite", (getter)UIGridPoint::get_int_member, (setter)UIGridPoint::set_int_member, "UI sprite index", (void*)2},
-    {NULL}  /* Sentinel */
-};
-
-PyObject* UIGridPoint::repr(PyUIGridPointObject* self) {
-    std::ostringstream ss;
-    if (!self->data) ss << "<GridPoint (invalid internal object)>";
-    else {
-        auto gp = self->data;
-        ss << "<GridPoint (walkable=" << (gp->walkable ? "True" : "False") << ", transparent=" << (gp->transparent ? "True" : "False") << 
-              ", tilesprite=" << gp->tilesprite << ", tile_overlay=" << gp->tile_overlay << ", uisprite=" << gp->uisprite <<
-        ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-PyObject* UIGridPointState::get_bool_member(PyUIGridPointStateObject* self, void* closure) {
-    if (reinterpret_cast<long>(closure) == 0) { // visible
-        return PyBool_FromLong(self->data->visible);
-    } else { // discovered
-        return PyBool_FromLong(self->data->discovered);
-    }
-}
-
-int UIGridPointState::set_bool_member(PyUIGridPointStateObject* self, PyObject* value, void* closure) {
-    if (!PyBool_Check(value)) {
-        PyErr_SetString(PyExc_TypeError, "Value must be a boolean");
-        return -1;
-    }
-
-    int truthValue = PyObject_IsTrue(value);
-    if (truthValue < 0) {
-        return -1; // PyObject_IsTrue returns -1 on error
-    }
-
-    if (reinterpret_cast<long>(closure) == 0) { // visible
-        self->data->visible = truthValue;
-    } else { // discovered
-        self->data->discovered = truthValue;
-    }
-
-    return 0;
-}
-
-PyGetSetDef UIGridPointState::getsetters[] = {
-    {"visible", (getter)UIGridPointState::get_bool_member, (setter)UIGridPointState::set_bool_member, "Is the GridPointState visible", (void*)0},
-    {"discovered", (getter)UIGridPointState::get_bool_member, (setter)UIGridPointState::set_bool_member, "Has the GridPointState been discovered", (void*)1},
-    {NULL}  /* Sentinel */
-};
-
-PyObject* UIGridPointState::repr(PyUIGridPointStateObject* self) {
-    std::ostringstream ss;
-    if (!self->data) ss << "<GridPointState (invalid internal object)>";
-    else {
-        auto gps = self->data;
-        ss << "<GridPointState (visible=" << (gps->visible ? "True" : "False") << ", discovered=" << (gps->discovered ? "True" : "False") << 
-        ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}

src/UIGridPoint.h

@@ -1,92 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "structmember.h"
-#include "IndexTexture.h"
-#include "Resources.h"
-#include <list>
-
-#include "PyCallable.h"
-#include "PyTexture.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "PyFont.h"
-
-static PyObject* sfColor_to_PyObject(sf::Color color);
-static sf::Color PyObject_to_sfColor(PyObject* obj);
-
-class UIGrid;
-class UIEntity;
-class UIGridPoint;
-class UIGridPointState;
-
-typedef struct {
-    PyObject_HEAD
-    UIGridPoint* data;
-    std::shared_ptr<UIGrid> grid;
-} PyUIGridPointObject;
-
-typedef struct {
-    PyObject_HEAD
-    UIGridPointState* data;
-    std::shared_ptr<UIGrid> grid;
-    std::shared_ptr<UIEntity> entity;
-} PyUIGridPointStateObject;
-
-// UIGridPoint - revised grid data for each point
-class UIGridPoint
-{
-public:
-    sf::Color color, color_overlay;
-    bool walkable, transparent;
-    int tilesprite, tile_overlay, uisprite;
-    UIGridPoint();
-
-    static int set_int_member(PyUIGridPointObject* self, PyObject* value, void* closure);
-    static PyGetSetDef getsetters[];
-    static PyObject* get_color(PyUIGridPointObject* self, void* closure);
-    static PyObject* get_int_member(PyUIGridPointObject* self, void* closure);
-    static int set_bool_member(PyUIGridPointObject* self, PyObject* value, void* closure);
-    static PyObject* get_bool_member(PyUIGridPointObject* self, void* closure);
-    static int set_color(PyUIGridPointObject* self, PyObject* value, void* closure);
-    static PyObject* repr(PyUIGridPointObject* self);
-};
-
-// UIGridPointState - entity-specific info for each cell
-class UIGridPointState
-{
-public:
-    bool visible, discovered;
-
-    static PyObject* get_bool_member(PyUIGridPointStateObject* self, void* closure);
-    static int set_bool_member(PyUIGridPointStateObject* self, PyObject* value, void* closure);
-    static PyGetSetDef getsetters[];
-    static PyObject* repr(PyUIGridPointStateObject* self);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUIGridPointType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.GridPoint",
-        .tp_basicsize = sizeof(PyUIGridPointObject),
-        .tp_itemsize = 0,
-        .tp_repr = (reprfunc)UIGridPoint::repr,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = "UIGridPoint object",
-        .tp_getset = UIGridPoint::getsetters,
-        //.tp_init = (initproc)PyUIGridPoint_init, // TODO Define the init function
-        .tp_new = PyType_GenericNew,
-    };
-
-    static PyTypeObject PyUIGridPointStateType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.GridPointState",
-        .tp_basicsize = sizeof(PyUIGridPointStateObject),
-        .tp_itemsize = 0,
-        .tp_repr = (reprfunc)UIGridPointState::repr,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = "UIGridPointState object", // TODO: Add PyUIGridPointState tp_init
-        .tp_getset = UIGridPointState::getsetters,
-        .tp_new = PyType_GenericNew,
-    };
-}

src/UISprite.cpp

@@ -1,215 +0,0 @@
-#include "UISprite.h"
-#include "GameEngine.h"
-
-UIDrawable* UISprite::click_at(sf::Vector2f point)
-{
-    if (click_callable)
-    {
-        if(sprite.getGlobalBounds().contains(point)) return this;
-    }
-    return NULL;
-}
-
-UISprite::UISprite() {}
-
-UISprite::UISprite(std::shared_ptr<PyTexture> _ptex, int _sprite_index, sf::Vector2f _pos, float _scale)
-: ptex(_ptex), sprite_index(_sprite_index)
-{
-    sprite = ptex->sprite(sprite_index, _pos, sf::Vector2f(_scale, _scale));
-}
-
-void UISprite::render(sf::Vector2f offset)
-{
-    sprite.move(offset);
-    Resources::game->getWindow().draw(sprite);
-    sprite.move(-offset);
-}
-
-void UISprite::render(sf::Vector2f offset, sf::RenderTexture& target)
-{
-    sprite.move(offset);
-    target.draw(sprite);
-    sprite.move(-offset);
-}
-
-void UISprite::setPosition(sf::Vector2f pos)
-{
-    sprite.setPosition(pos);
-}
-
-void UISprite::setScale(sf::Vector2f s)
-{
-    sprite.setScale(s);
-}
-
-void UISprite::setTexture(std::shared_ptr<PyTexture> _ptex, int _sprite_index)
-{
-    ptex = _ptex;
-    if (_sprite_index != -1) // if you are changing textures, there's a good chance you need a new index too
-        sprite_index = _sprite_index;
-    sprite = ptex->sprite(sprite_index, sprite.getPosition(), sprite.getScale());
-}
-
-void UISprite::setSpriteIndex(int _sprite_index)
-{
-    sprite_index = _sprite_index;
-    sprite = ptex->sprite(sprite_index, sprite.getPosition(), sprite.getScale());
-}
-
-sf::Vector2f UISprite::getScale()
-{
-    return sprite.getScale();
-}
-
-sf::Vector2f UISprite::getPosition()
-{
-    return sprite.getPosition();
-}
-
-std::shared_ptr<PyTexture> UISprite::getTexture()
-{
-    return ptex;
-}
-
-int UISprite::getSpriteIndex()
-{
-    return sprite_index;
-}
-
-PyObjectsEnum UISprite::derived_type()
-{
-    return PyObjectsEnum::UISPRITE;
-}
-
-PyObject* UISprite::get_float_member(PyUISpriteObject* self, void* closure)
-{
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (member_ptr == 0)
-        return PyFloat_FromDouble(self->data->getPosition().x);
-    else if (member_ptr == 1)
-        return PyFloat_FromDouble(self->data->getPosition().y);
-    else if (member_ptr == 2)
-        return PyFloat_FromDouble(self->data->getScale().x); // scale X and Y are identical, presently
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-}
-
-int UISprite::set_float_member(PyUISpriteObject* self, PyObject* value, void* closure)
-{
-    float val;
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (PyFloat_Check(value))
-    {
-        val = PyFloat_AsDouble(value);
-    }
-    else if (PyLong_Check(value))
-    {
-        val = PyLong_AsLong(value);
-    }
-    else
-    {
-        PyErr_SetString(PyExc_TypeError, "Value must be a floating point number.");
-        return -1;
-    }
-    if (member_ptr == 0) //x
-        self->data->setPosition(sf::Vector2f(val, self->data->getPosition().y));
-    else if (member_ptr == 1) //y
-        self->data->setPosition(sf::Vector2f(self->data->getPosition().x, val));
-    else if (member_ptr == 2) // scale
-        self->data->setScale(sf::Vector2f(val, val));
-    return 0;
-}
-
-PyObject* UISprite::get_int_member(PyUISpriteObject* self, void* closure)
-{
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (true) {}
-    else
-    {
-        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
-        return nullptr;
-    }
-    
-    return PyLong_FromDouble(self->data->getSpriteIndex());
-}
-
-int UISprite::set_int_member(PyUISpriteObject* self, PyObject* value, void* closure)
-{
-    int val;
-    auto member_ptr = reinterpret_cast<long>(closure);
-    if (PyLong_Check(value))
-    {
-        val = PyLong_AsLong(value);
-    }
-    else
-    {
-        PyErr_SetString(PyExc_TypeError, "Value must be an integer.");
-        return -1;
-    }
-    self->data->setSpriteIndex(val);
-    return 0;
-}
-
-PyObject* UISprite::get_texture(PyUISpriteObject* self, void* closure)
-{
-    return self->data->getTexture()->pyObject();
-}
-
-int UISprite::set_texture(PyUISpriteObject* self, PyObject* value, void* closure)
-{
-    return -1;
-}
-
-PyGetSetDef UISprite::getsetters[] = {
-    {"x", (getter)UISprite::get_float_member, (setter)UISprite::set_float_member, "X coordinate of top-left corner",   (void*)0},
-    {"y", (getter)UISprite::get_float_member, (setter)UISprite::set_float_member, "Y coordinate of top-left corner",   (void*)1},
-    {"scale", (getter)UISprite::get_float_member, (setter)UISprite::set_float_member, "Size factor",                   (void*)2},
-    {"sprite_number", (getter)UISprite::get_int_member, (setter)UISprite::set_int_member, "Which sprite on the texture is shown", NULL},
-    {"texture", (getter)UISprite::get_texture, (setter)UISprite::set_texture,     "Texture object",                    NULL},
-    {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UISPRITE},
-    {NULL}
-};
-
-PyObject* UISprite::repr(PyUISpriteObject* self)
-{
-    std::ostringstream ss;
-    if (!self->data) ss << "<Sprite (invalid internal object)>";
-    else {
-        //auto sprite = self->data->sprite;
-        ss << "<Sprite (x=" << self->data->getPosition().x << ", y=" << self->data->getPosition().y << ", " <<
-            "scale=" << self->data->getScale().x << ", " <<
-            "sprite_number=" << self->data->getSpriteIndex() << ")>";
-    }
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-int UISprite::init(PyUISpriteObject* self, PyObject* args, PyObject* kwds)
-{
-    //std::cout << "Init called\n";
-    static const char* keywords[] = { "x", "y", "texture", "sprite_index", "scale", nullptr };
-    float x = 0.0f, y = 0.0f, scale = 1.0f;
-    int sprite_index;
-    PyObject* texture;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ffOif",
-        const_cast<char**>(keywords), &x, &y, &texture, &sprite_index, &scale))
-    {
-        return -1;
-    }
-
-    // check types for texture
-    //if (texture != NULL && !PyObject_IsInstance(texture, (PyObject*)&PyTextureType)){
-    if (texture != NULL && !PyObject_IsInstance(texture, PyObject_GetAttrString(McRFPy_API::mcrf_module, "Texture"))){
-        PyErr_SetString(PyExc_TypeError, "texture must be a mcrfpy.Texture instance");
-        return -1;
-    }
-    auto pytexture = (PyTextureObject*)texture;
-    self->data = std::make_shared<UISprite>(pytexture->data, sprite_index, sf::Vector2f(x, y), scale);
-    self->data->setPosition(sf::Vector2f(x, y));
-
-    return 0;
-}

src/UISprite.h

@@ -1,90 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-#include "structmember.h"
-#include "IndexTexture.h"
-#include "Resources.h"
-#include <list>
-
-#include "PyCallable.h"
-#include "PyTexture.h"
-#include "PyColor.h"
-#include "PyVector.h"
-#include "PyFont.h"
-#include "UIDrawable.h"
-#include "UIBase.h"
-
-class UISprite: public UIDrawable
-{
-private:
-    int sprite_index;
-    sf::Sprite sprite;
-protected:
-    std::shared_ptr<PyTexture> ptex;
-public:
-    UISprite();
-    UISprite(std::shared_ptr<PyTexture>, int, sf::Vector2f, float);
-    void update();
-    void render(sf::Vector2f) override final;
-    virtual UIDrawable* click_at(sf::Vector2f point) override final;
-    
-    void render(sf::Vector2f, sf::RenderTexture&);
-
-    void setPosition(sf::Vector2f);
-    sf::Vector2f getPosition();
-    void setScale(sf::Vector2f);
-    sf::Vector2f getScale();
-    void setSpriteIndex(int);
-    int getSpriteIndex();
-
-    void setTexture(std::shared_ptr<PyTexture> _ptex, int _sprite_index=-1);
-    std::shared_ptr<PyTexture> getTexture();
-
-    PyObjectsEnum derived_type() override final;
-
-
-    static PyObject* get_float_member(PyUISpriteObject* self, void* closure);
-    static int set_float_member(PyUISpriteObject* self, PyObject* value, void* closure);
-    static PyObject* get_int_member(PyUISpriteObject* self, void* closure);
-    static int set_int_member(PyUISpriteObject* self, PyObject* value, void* closure);
-    static PyObject* get_texture(PyUISpriteObject* self, void* closure);
-    static int set_texture(PyUISpriteObject* self, PyObject* value, void* closure);
-    static PyGetSetDef getsetters[];
-    static PyObject* repr(PyUISpriteObject* self);
-    static int init(PyUISpriteObject* self, PyObject* args, PyObject* kwds);
-    
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyUISpriteType = {
-        //PyVarObject_HEAD_INIT(NULL, 0)
-        .tp_name = "mcrfpy.Sprite",
-        .tp_basicsize = sizeof(PyUISpriteObject),
-        .tp_itemsize = 0,
-        .tp_dealloc = (destructor)[](PyObject* self)
-        {
-            PyUISpriteObject* obj = (PyUISpriteObject*)self;
-            // release reference to font object
-            //if (obj->texture) Py_DECREF(obj->texture);
-            obj->data.reset();
-            Py_TYPE(self)->tp_free(self);
-        },
-        .tp_repr = (reprfunc)UISprite::repr,
-        //.tp_hash = NULL,
-        //.tp_iter
-        //.tp_iternext
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("docstring"),
-        //.tp_methods = PyUIFrame_methods,
-        //.tp_members = PyUIFrame_members,
-        .tp_getset = UISprite::getsetters,
-        //.tp_base = NULL,
-        .tp_init = (initproc)UISprite::init,
-        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
-        {
-            PyUISpriteObject* self = (PyUISpriteObject*)type->tp_alloc(type, 0);
-            //if (self) self->data = std::make_shared<UICaption>();
-            return (PyObject*)self;
-        }
-    }; 
-}

src/UITestScene.cpp

@@ -154,7 +154,7 @@ void UITestScene::doAction(std::string name, std::string type)
     */
 }
 
-void UITestScene::render()
+void UITestScene::sRender()
 {
     game->getWindow().clear();
     game->getWindow().draw(text);

src/UITestScene.h

@@ -18,5 +18,5 @@ public:
     UITestScene(GameEngine*);
     void update() override final;
     void doAction(std::string, std::string) override final;
-    void render() override final;
+    void sRender() override final;
 };

src/scripts/game.py

@@ -2,10 +2,6 @@ import mcrfpy
 font = mcrfpy.Font("assets/JetbrainsMono.ttf")
 texture = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 16)
 
-print("[game.py] Default texture:")
-print(mcrfpy.default_texture)
-print(type(mcrfpy.default_texture))
-
 # build test widgets
 
 mcrfpy.createScene("pytest")
@@ -14,23 +10,18 @@ ui = mcrfpy.sceneUI("pytest")
 
 # Frame
 f = mcrfpy.Frame(25, 19, 462, 346, fill_color=(255, 92, 92))
-print("Frame alive")
 # fill (LinkedColor / Color):    f.fill_color
 # outline (LinkedColor / Color): f.outline_color
 # pos (LinkedVector / Vector):   f.pos
 # size (LinkedVector / Vector):  f.size
 
 # Caption
-print("Caption attempt w/ fill_color:")
+c = mcrfpy.Caption(512+25, 19, "Hi.", font)
-#c = mcrfpy.Caption(512+25, 19, "Hi.", font)
-#c = mcrfpy.Caption(512+25, 19, "Hi.", font, fill_color=(255, 128, 128))
-c = mcrfpy.Caption(512+25, 19, "Hi.", font, fill_color=mcrfpy.Color(255, 128, 128), outline_color=(128, 255, 128))
-print("Caption alive")
 # fill (LinkedColor / Color):    c.fill_color
 #color_val = c.fill_color
 print(c.fill_color)
-#print("Set a fill color")
+print("Set a fill color")
-#c.fill_color = (255, 255, 255)
+c.fill_color = (255, 255, 255)
 print("Lol, did it segfault?")
 # outline (LinkedColor / Color): c.outline_color
 # font (Font):                   c.font