doesn't compile, but UI.h/.cpp code has been divvy'd up.

refs #43 @2h

src/UICaption.cpp

@@ -0,0 +1,22 @@
+#include "UICaption.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;
+}

src/UICaption.h

@@ -0,0 +1,304 @@
+#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"
+
+class UICaption: public UIDrawable
+{
+public:
+    sf::Text text;
+    void render(sf::Vector2f) override final;
+    PyObjectsEnum derived_type() override final; // { return PyObjectsEnum::UICaption;  };
+    virtual UIDrawable* click_at(sf::Vector2f point) override final;
+};
+
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UICaption> data;
+    PyObject* font;
+} PyUICaptionObject;
+
+namespace mcrfpydef {
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICaption_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;
+        }
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICaption_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;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICaption_get_vec_member(PyUICaptionObject* self, void* closure)
+    {
+        return PyVector(self->data->text.getPosition()).pyObject();
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICaption_set_vec_member(PyUICaptionObject* self, PyObject* value, void* closure)
+    {
+        self->data->text.setPosition(PyVector::fromPy(value));
+        return 0;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICaption_get_color_member(PyUICaptionObject* 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;
+        }
+
+        // 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();
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICaption_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*)&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: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICaption_get_text(PyUICaptionObject* self, void* closure)
+    {
+        Resources::caption_buffer = self->data->text.getString();
+        return PyUnicode_FromString(Resources::caption_buffer.c_str());
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICaption_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;
+    }
+
+    //TODO: add this static array to class scope; move implementation to .cpp file
+    static PyGetSetDef PyUICaption_getsetters[] = {
+        {"x", (getter)PyUICaption_get_float_member, (setter)PyUICaption_set_float_member, "X coordinate of top-left corner",   (void*)0},
+        {"y", (getter)PyUICaption_get_float_member, (setter)PyUICaption_set_float_member, "Y coordinate of top-left corner",   (void*)1},
+        {"pos", (getter)PyUICaption_get_vec_member, (setter)PyUICaption_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)PyUICaption_get_float_member, (setter)PyUICaption_set_float_member, "Thickness of the border",   (void*)4},
+        {"fill_color", (getter)PyUICaption_get_color_member, (setter)PyUICaption_set_color_member, "Fill color of the text", (void*)0},
+        {"outline_color", (getter)PyUICaption_get_color_member, (setter)PyUICaption_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)PyUICaption_get_text, (setter)PyUICaption_set_text, "The text displayed", NULL},
+        {"size", (getter)PyUICaption_get_float_member, (setter)PyUICaption_set_float_member, "Text size (integer) in points", (void*)5},
+        {"click", (getter)PyUIDrawable_get_click, (setter)PyUIDrawable_set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UICAPTION},
+        {NULL}
+    };
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICaption_repr(PyUICaptionObject* self)
+    {
+        std::ostringstream ss;
+        if (!self->data) ss << "<Frame (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 <<"), " <<
+                "outlinecolor=(" << (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");
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICaption_init(PyUICaptionObject* self, PyObject* args, PyObject* kwds)
+    {
+        //std::cout << "Init called\n";
+        static const char* keywords[] = { "x", "y", "text", "font", "fill_color", "outline_color", nullptr };
+        float x = 0.0f, y = 0.0f;
+        char* text;
+        PyObject* font, fill_color, outline_color;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ffzOOO", 
+            const_cast<char**>(keywords), &x, &y, &text, &font, &fill_color, &outline_color))
+        {
+            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*)&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.setFillColor(sf::Color(0,0,0,255));
+        self->data->text.setOutlineColor(sf::Color(128,128,128,255));
+
+        return 0;
+    }
+
+    static PyTypeObject PyUICaptionType = {
+        //PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name = "mcrfpy.Caption",
+        .tp_basicsize = sizeof(PyUICaptionObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)[](PyObject* self)
+        {
+            PyUICaptionObject* obj = (PyUICaptionObject*)self;
+            // release reference to font object
+            if (obj->font) Py_DECREF(obj->font);
+            obj->data.reset();
+            Py_TYPE(self)->tp_free(self);
+        },
+        .tp_repr = (reprfunc)PyUICaption_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 = PyUICaption_getsetters,
+        //.tp_base = NULL,
+        .tp_init = (initproc)PyUICaption_init,
+        .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

@@ -0,0 +1,2 @@
+#include "UICollection.h"
+

src/UICollection.h

@@ -0,0 +1,279 @@
+#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 "UICaption.h"
+#include "UIFrame.h"
+#include "UISprite.h"
+#include "UIGrid.h"
+
+namespace mcrfpydef {
+
+    typedef struct {
+        PyObject_HEAD
+        std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> data;
+        int index;
+        int start_size;
+    } PyUICollectionIterObject;
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICollectionIter_init(PyUICollectionIterObject* self, PyObject* args, PyObject* kwds)
+    {
+        PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
+        return -1;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICollectionIter_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;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+	static PyObject* PyUICollectionIter_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");
+	}
+
+    static PyTypeObject PyUICollectionIterType = {
+        //PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name = "mcrfpy.UICollectionIter",
+        .tp_basicsize = sizeof(PyUICollectionIterObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)[](PyObject* self)
+        {
+            PyUICollectionIterObject* obj = (PyUICollectionIterObject*)self;
+            obj->data.reset();
+            Py_TYPE(self)->tp_free(self);
+        },
+        .tp_repr = (reprfunc)PyUICollectionIter_repr,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+        .tp_doc = PyDoc_STR("Iterator for a collection of UI objects"),
+        .tp_iternext = (iternextfunc)PyUICollectionIter_next,
+        //.tp_getset = PyUICollection_getset,
+        .tp_init = (initproc)PyUICollectionIter_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;
+        }
+    };
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+	static Py_ssize_t PyUICollection_len(PyUICollectionObject* self) {
+		return self->data->size();
+	}
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+	static PyObject* PyUICollection_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;
+
+
+	}
+
+    //TODO: add this static array to class scope; move implementation to .cpp file
+	static PySequenceMethods PyUICollection_sqmethods = {
+		.sq_length = (lenfunc)PyUICollection_len,
+		.sq_item = (ssizeargfunc)PyUICollection_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)
+	};
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+	static PyObject* PyUICollection_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*)&PyUIFrameType) &&
+            !PyObject_IsInstance(o, (PyObject*)&PyUISpriteType) &&
+            !PyObject_IsInstance(o, (PyObject*)&PyUICaptionType) &&
+            !PyObject_IsInstance(o, (PyObject*)&PyUIGridType)
+            )
+        {
+            PyErr_SetString(PyExc_TypeError, "Only Frame, Caption, Sprite, and Grid objects can be added to UICollection");
+            return NULL;
+        }
+
+        if (PyObject_IsInstance(o, (PyObject*)&PyUIFrameType))
+        {
+            PyUIFrameObject* frame = (PyUIFrameObject*)o;
+            self->data->push_back(frame->data);
+        }
+        if (PyObject_IsInstance(o, (PyObject*)&PyUICaptionType))
+        {
+            PyUICaptionObject* caption = (PyUICaptionObject*)o;
+            self->data->push_back(caption->data);
+        }
+        if (PyObject_IsInstance(o, (PyObject*)&PyUISpriteType))
+        {
+            PyUISpriteObject* sprite = (PyUISpriteObject*)o;
+            self->data->push_back(sprite->data);
+        }
+        if (PyObject_IsInstance(o, (PyObject*)&PyUIGridType))
+        {
+            PyUIGridObject* grid = (PyUIGridObject*)o;
+            self->data->push_back(grid->data);
+        }
+
+        Py_INCREF(Py_None);
+        return Py_None;
+	}
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+	static PyObject* PyUICollection_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;
+	}
+
+    //TODO: add this static array to class scope; move implementation to .cpp file
+	static PyMethodDef PyUICollection_methods[] = {
+		{"append", (PyCFunction)PyUICollection_append, METH_O},
+        //{"extend", (PyCFunction)PyUICollection_extend, METH_O}, // TODO
+		{"remove", (PyCFunction)PyUICollection_remove, METH_O},
+		{NULL, NULL, 0, NULL}
+	};
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+	static PyObject* PyUICollection_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");
+	}
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUICollection_init(PyUICollectionObject* self, PyObject* args, PyObject* kwds)
+    {
+        PyErr_SetString(PyExc_TypeError, "UICollection cannot be instantiated: a C++ data source is required.");
+        return -1;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUICollection_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;
+    }
+
+	static PyTypeObject PyUICollectionType = {
+		//PyVarObject_/HEAD_INIT(NULL, 0)
+		.tp_name = "mcrfpy.UICollection",
+		.tp_basicsize = sizeof(PyUICollectionObject),
+		.tp_itemsize = 0,
+		.tp_dealloc = (destructor)[](PyObject* self)
+		{
+		    PyUICollectionObject* obj = (PyUICollectionObject*)self;
+		    obj->data.reset();
+		    Py_TYPE(self)->tp_free(self);
+		},
+		.tp_repr = (reprfunc)PyUICollection_repr,
+		.tp_as_sequence = &PyUICollection_sqmethods,
+		.tp_flags = Py_TPFLAGS_DEFAULT,
+		.tp_doc = PyDoc_STR("Iterable, indexable collection of UI objects"),
+        .tp_iter = (getiterfunc)PyUICollection_iter,
+		.tp_methods = PyUICollection_methods, // append, remove
+        //.tp_getset = PyUICollection_getset,
+		.tp_init = (initproc)PyUICollection_init, // just raise an exception
+		.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

@@ -0,0 +1,13 @@
+#include "UIDrawable.h"
+
+UIDrawable::UIDrawable() { click_callable = NULL;  }
+
+void UIDrawable::click_unregister()
+{
+    click_callable.reset();
+}
+
+void UIDrawable::render()
+{
+    render(sf::Vector2f());
+}

src/UIDrawable.h

@@ -0,0 +1,162 @@
+#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"
+
+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();
+};
+
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> data;
+} PyUICollectionObject;
+
+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(PyUIGridObject* 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(PyUIGridObject* 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

@@ -0,0 +1,9 @@
+#include "UIEntity.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)
+{
+}
+

src/UIEntity.h

@@ -0,0 +1,40 @@
+#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"
+
+class UIGrid;
+
+// 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&);
+    
+};
+
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UIEntity> data;
+    //PyObject* texture;
+} PyUIEntityObject;

src/UIFrame.cpp

@@ -0,0 +1,69 @@
+#include "UIFrame.h"
+#include "UICollection.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());
+    }
+}
+
+namespace mcrfpydef {
+
+    // TODO: move to class scope; but this should at least get us compiling
+    static PyObject* PyUIFrame_get_children(PyUIFrameObject* self, void* closure)
+    {
+        // create PyUICollection instance pointing to self->data->children
+        PyUICollectionObject* o = (PyUICollectionObject*)PyUICollectionType.tp_alloc(&PyUICollectionType, 0);
+        if (o)
+            o->data = self->data->children;
+        return (PyObject*)o;
+    }
+}
+

src/UIFrame.h

@@ -0,0 +1,271 @@
+#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"
+
+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;
+};
+
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UIFrame> data;
+} PyUIFrameObject;
+
+namespace mcrfpydef {
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUIFrame_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;
+        }
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUIFrame_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;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUIFrame_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;
+        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();
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUIFrame_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*)&PyColorType))
+        {
+            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;
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUIFrame_get_children(PyUIFrameObject*, void*); // forward declaration until UICollection is defined
+    // implementation after the PyUICollectionType definition
+
+    //TODO: add this static array to class scope; move implementation to .cpp file
+    static PyGetSetDef PyUIFrame_getsetters[] = {
+        {"x", (getter)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "X coordinate of top-left corner",   (void*)0},
+        {"y", (getter)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "Y coordinate of top-left corner",   (void*)1},
+        {"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)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "Thickness of the border",   (void*)4},
+        {"fill_color", (getter)PyUIFrame_get_color_member, (setter)PyUIFrame_set_color_member, "Fill color of the rectangle", (void*)0},
+        {"outline_color", (getter)PyUIFrame_get_color_member, (setter)PyUIFrame_set_color_member, "Outline color of the rectangle", (void*)1},
+        {"children", (getter)PyUIFrame_get_children, NULL, "UICollection of objects on top of this one", NULL},
+        {"click", (getter)PyUIDrawable_get_click, (setter)PyUIDrawable_set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UIFRAME},
+        {NULL}
+    };
+    
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static PyObject* PyUIFrame_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 << ", x=" << 
+                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");
+    }
+
+    //TODO: add this method to class scope; move implementation to .cpp file
+    static int PyUIFrame_init(PyUIFrameObject* self, PyObject* args, PyObject* kwds)
+    {
+        //std::cout << "Init called\n";
+        static 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 = PyUIFrame_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 = PyUIFrame_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;
+    }
+
+    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)PyUIFrame_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 = PyUIFrame_getsetters,
+        //.tp_base = NULL,
+        .tp_init = (initproc)PyUIFrame_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

@@ -0,0 +1,190 @@
+#include "UIGrid.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;
+}

src/UIGrid.h

@@ -0,0 +1,570 @@
+#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"
+
+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;