Removing std::cout debugging statements

css_colors.txt

@@ -1,157 +0,0 @@
-aqua 	#00FFFF 
-black 	#000000 
-blue 	#0000FF 
-fuchsia 	#FF00FF 
-gray 	#808080 
-green 	#008000 
-lime 	#00FF00 
-maroon 	#800000 
-navy 	#000080 
-olive 	#808000 
-purple 	#800080 
-red 	#FF0000 
-silver 	#C0C0C0 
-teal 	#008080 
-white 	#FFFFFF 
-yellow 	#FFFF00 
-aliceblue 	#F0F8FF 
-antiquewhite 	#FAEBD7 
-aqua 	#00FFFF 
-aquamarine 	#7FFFD4 
-azure 	#F0FFFF 
-beige 	#F5F5DC 
-bisque 	#FFE4C4 
-black 	#000000 
-blanchedalmond 	#FFEBCD 
-blue 	#0000FF 
-blueviolet 	#8A2BE2 
-brown 	#A52A2A 
-burlywood 	#DEB887 
-cadetblue 	#5F9EA0 
-chartreuse 	#7FFF00 
-chocolate 	#D2691E 
-coral 	#FF7F50 
-cornflowerblue 	#6495ED 
-cornsilk 	#FFF8DC 
-crimson 	#DC143C 
-cyan 	#00FFFF 
-darkblue 	#00008B 
-darkcyan 	#008B8B 
-darkgoldenrod 	#B8860B 
-darkgray 	#A9A9A9 
-darkgreen 	#006400 
-darkkhaki 	#BDB76B 
-darkmagenta 	#8B008B 
-darkolivegreen 	#556B2F 
-darkorange 	#FF8C00 
-darkorchid 	#9932CC 
-darkred 	#8B0000 
-darksalmon 	#E9967A 
-darkseagreen 	#8FBC8F 
-darkslateblue 	#483D8B 
-darkslategray 	#2F4F4F 
-darkturquoise 	#00CED1 
-darkviolet 	#9400D3 
-deeppink 	#FF1493 
-deepskyblue 	#00BFFF 
-dimgray 	#696969 
-dodgerblue 	#1E90FF 
-firebrick 	#B22222 
-floralwhite 	#FFFAF0 
-forestgreen 	#228B22 
-fuchsia 	#FF00FF 
-gainsboro 	#DCDCDC 
-ghostwhite 	#F8F8FF 
-gold 	#FFD700 
-goldenrod 	#DAA520 
-gray 	#7F7F7F 
-green 	#008000 
-greenyellow 	#ADFF2F 
-honeydew 	#F0FFF0 
-hotpink 	#FF69B4 
-indianred 	#CD5C5C 
-indigo 	#4B0082 
-ivory 	#FFFFF0 
-khaki 	#F0E68C 
-lavender 	#E6E6FA 
-lavenderblush 	#FFF0F5 
-lawngreen 	#7CFC00 
-lemonchiffon 	#FFFACD 
-lightblue 	#ADD8E6 
-lightcoral 	#F08080 
-lightcyan 	#E0FFFF 
-lightgoldenrodyellow 	#FAFAD2 
-lightgreen 	#90EE90 
-lightgrey 	#D3D3D3 
-lightpink 	#FFB6C1 
-lightsalmon 	#FFA07A 
-lightseagreen 	#20B2AA 
-lightskyblue 	#87CEFA 
-lightslategray 	#778899 
-lightsteelblue 	#B0C4DE 
-lightyellow 	#FFFFE0 
-lime 	#00FF00 
-limegreen 	#32CD32 
-linen 	#FAF0E6 
-magenta 	#FF00FF 
-maroon 	#800000 
-mediumaquamarine 	#66CDAA 
-mediumblue 	#0000CD 
-mediumorchid 	#BA55D3 
-mediumpurple 	#9370DB 
-mediumseagreen 	#3CB371 
-mediumslateblue 	#7B68EE 
-mediumspringgreen 	#00FA9A 
-mediumturquoise 	#48D1CC 
-mediumvioletred 	#C71585 
-midnightblue 	#191970 
-mintcream 	#F5FFFA 
-mistyrose 	#FFE4E1 
-moccasin 	#FFE4B5 
-navajowhite 	#FFDEAD 
-navy 	#000080 
-navyblue 	#9FAFDF 
-oldlace 	#FDF5E6 
-olive 	#808000 
-olivedrab 	#6B8E23 
-orange 	#FFA500 
-orangered 	#FF4500 
-orchid 	#DA70D6 
-palegoldenrod 	#EEE8AA 
-palegreen 	#98FB98 
-paleturquoise 	#AFEEEE 
-palevioletred 	#DB7093 
-papayawhip 	#FFEFD5 
-peachpuff 	#FFDAB9 
-peru 	#CD853F 
-pink 	#FFC0CB 
-plum 	#DDA0DD 
-powderblue 	#B0E0E6 
-purple 	#800080 
-red 	#FF0000 
-rosybrown 	#BC8F8F 
-royalblue 	#4169E1 
-saddlebrown 	#8B4513 
-salmon 	#FA8072 
-sandybrown 	#FA8072 
-seagreen 	#2E8B57 
-seashell 	#FFF5EE 
-sienna 	#A0522D 
-silver 	#C0C0C0 
-skyblue 	#87CEEB 
-slateblue 	#6A5ACD 
-slategray 	#708090 
-snow 	#FFFAFA 
-springgreen 	#00FF7F 
-steelblue 	#4682B4 
-tan 	#D2B48C 
-teal 	#008080 
-thistle 	#D8BFD8 
-tomato 	#FF6347 
-turquoise 	#40E0D0 
-violet 	#EE82EE 
-wheat 	#F5DEB3 
-white 	#FFFFFF 
-whitesmoke 	#F5F5F5 
-yellow 	#FFFF00 
-yellowgreen 	#9ACD32 

generate_color_table.py

@@ -1,111 +0,0 @@
-# data sources: CSS docs, jennyscrayoncollection 2017 article on Crayola colors, XKCD color survey
-
-# target: Single C++ header file to provide a struct of color RGB codes and names.
-# This file pre-computes the nearest neighbor of every color.
-# if an RGB code being searched for is closer than the nearest neighbor, it's the closest color name.
-
-def hex_to_rgb(txt):
-    if '#' in txt: txt = txt.replace('#', '')
-    r = txt[0:2]
-    g = txt[2:4]
-    b = txt[4:6]
-    return tuple([int(s, 16) for s in (r,g,b)])
-
-class palette:
-    def __init__(self, name, filename, priority):
-        self.name = name
-        self.priority = priority
-        with open(filename, "r") as f:
-            print(f"scanning {filename}")
-            self.colors = {}
-            for line in f.read().split('\n'):
-                if len(line.split('\t')) < 2: continue
-                name, code = line.split('\t')
-                #print(name, code)
-                self.colors[name] = hex_to_rgb(code)
-                
-    def __repr__(self):
-        return f"<Palette '{self.name}' - {len(self.colors)} colors, priority = {self.priority}>"
-    
-palettes = [
-    #palette("jenny", "jenny_colors.txt", 3), # I should probably use wikipedia as a source for copyright reasons
-    palette("crayon", "wikicrayons_colors.txt", 2),
-    palette("xkcd", "xkcd_colors.txt", 1),
-    palette("css", "css_colors.txt", 0),
-    #palette("matplotlib", "matplotlib_colors.txt", 2) # there's like 10 colors total, I think we'll survive without them
-    ]
-
-all_colors = []
-
-from math import sqrt
-def rgbdist(c1, c2):
-    return sqrt((c1.r - c2.r)**2 + (c1.g - c2.g)**2 + (c1.b - c2.b)**2)
-
-class Color:
-    def __init__(self, r, g, b, name, prefix, priority):
-        self.r = r
-        self.g = g
-        self.b = b
-        self.name = name
-        self.prefix = prefix
-        self.priority = priority
-        self.nearest_neighbor = None
-        
-    def __repr__(self):
-        return f"<Color ({self.r}, {self.g}, {self.b}) - '{self.prefix}:{self.name}', priority = {self.priority}, nearest_neighbor={self.nearest_neighbor.name if self.nearest_neighbor is not None else None}>"
-    
-    def nn(self, colors):
-        nearest = None
-        nearest_dist = 999999
-        for c in colors:
-            dist = rgbdist(self, c)
-            if dist == 0: continue
-            if dist < nearest_dist:
-                nearest = c
-                nearest_dist = dist
-        self.nearest_neighbor = nearest
-        
-for p in palettes:
-    prefix = p.name
-    priority = p.priority
-    for name, rgb in p.colors.items():
-        all_colors.append(Color(*rgb, name, prefix, priority))
-    print(f"{prefix}->{len(all_colors)}")
-        
-for c in all_colors:
-    c.nn(all_colors)
-
-smallest_dist = 9999999999999
-largest_dist = 0
-for c in all_colors:
-    dist = rgbdist(c, c.nearest_neighbor)
-    if dist > largest_dist: largest_dist = dist
-    if dist < smallest_dist: smallest_dist = dist
-    #print(f"{c.prefix}:{c.name} -> {c.nearest_neighbor.prefix}:{c.nearest_neighbor.name}\t{rgbdist(c, c.nearest_neighbor):.2f}")
-# questions -
-
-# are there any colors where their nearest neighbor's nearest neighbor isn't them? (There should be)
-nonnear_pairs = 0
-for c in all_colors:
-    neighbor = c.nearest_neighbor
-    their_neighbor = neighbor.nearest_neighbor
-    if c is not their_neighbor:
-        #print(f"{c.prefix}:{c.name} -> {neighbor.prefix}:{neighbor.name} -> {their_neighbor.prefix}:{their_neighbor.name}")
-        nonnear_pairs += 1
-print("Non-near pairs:", nonnear_pairs)
-    #print(f"{c.prefix}:{c.name} -> {c.nearest_neighbor.prefix}:{c.nearest_neighbor.name}\t{rgbdist(c, c.nearest_neighbor):.2f}")
-
-# Are there duplicates? They should be removed from the palette that won't be used
-dupes = 0
-for c in all_colors:
-    for c2 in all_colors:
-        if c is c2: continue
-        if c.r == c2.r and c.g == c2.g and c.b == c2.b:
-            dupes += 1
-print("dupes:", dupes, "this many will need to be removed:", dupes / 2)
-
-# What order to put them in? Do we want large radiuses first, or some sort of "common color" table?
-
-# does manhattan distance change any answers over the 16.7M RGB values?
-
-# What's the worst case lookup? (Checking all 1200 colors to find the name?)

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
@@ -65,38 +53,34 @@ PyObject* PyInit_mcrfpy()
         return NULL;
     }
     
-    using namespace mcrfpydef;
+    // This code runs, but Python segfaults when accessing the UIFrame type.
-    PyTypeObject* pytypes[] = {
+    //std::cout << "Adding UIFrame object to module\n";
-        /*SFML exposed types*/
+    PyModule_AddType(m, &mcrfpydef::PyColorType);
-        &PyColorType, /*&PyLinkedColorType,*/ &PyFontType, &PyTextureType, &PyVectorType,
+    PyModule_AddType(m, &mcrfpydef::PyFontType);
+    PyModule_AddType(m, &mcrfpydef::PyUICaptionType);
+    PyModule_AddType(m, &mcrfpydef::PyTextureType);
+    PyModule_AddType(m, &mcrfpydef::PyUISpriteType);
      
-        /*UI widgets*/
+    if (PyModule_AddType(m, &mcrfpydef::PyUIFrameType) < 0)
-        &PyUICaptionType, &PyUISpriteType, &PyUIFrameType, &PyUIEntityType, &PyUIGridType,
-
-        /*game map & perspective data*/
-        &PyUIGridPointType, &PyUIGridPointStateType,
-
-        /*collections & iterators*/
-        &PyUICollectionType, &PyUICollectionIterType,
-        &PyUIEntityCollectionType, &PyUIEntityCollectionIterType,
-        nullptr};
-    int i = 0;
-    auto t = pytypes[i];
-    while (t != nullptr)
     {
-        /*std::cout << */ PyType_Ready(t); /*<< std::endl; */
+        std::cout << "Error adding UIFrame type to module; aborting" << std::endl;
-        PyModule_AddType(m, t);
+        Py_DECREF(&mcrfpydef::PyUIFrameType);
-        t = pytypes[i++];
+        return NULL;
     }
+    PyModule_AddType(m, &mcrfpydef::PyUICollectionType);
+    PyModule_AddType(m, &mcrfpydef::PyUICollectionIterType);
+
+    PyModule_AddType(m, &mcrfpydef::PyUIGridPointType);
+    PyModule_AddType(m, &mcrfpydef::PyUIGridPointStateType);
+    PyModule_AddType(m, &mcrfpydef::PyUIEntityType);
+
+    PyModule_AddType(m, &mcrfpydef::PyUIEntityCollectionIterType);
+    PyModule_AddType(m, &mcrfpydef::PyUIEntityCollectionType);
+
+    PyModule_AddType(m, &mcrfpydef::PyUIGridType);
+
+    
 
-    // 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 +132,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 +143,6 @@ void McRFPy_API::setSpriteTexture(int ti)
                 ty * texture_size,
                 texture_size, texture_size));
 }
-*/
 
 // functionality
 //void McRFPy_API::
@@ -180,15 +159,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,150 +0,0 @@
-#include "PyColor.h"
-#include "McRFPy_API.h"
-
-PyGetSetDef PyColor::getsetters[] = {
-    {"r", (getter)PyColor::get_member, (setter)PyColor::set_member, "Red component",   (void*)0},
-    {"g", (getter)PyColor::get_member, (setter)PyColor::set_member, "Green component", (void*)1},
-    {"b", (getter)PyColor::get_member, (setter)PyColor::set_member, "Blue component",  (void*)2},
-    {"a", (getter)PyColor::get_member, (setter)PyColor::set_member, "Alpha component", (void*)3},
-    {NULL}
-};
-
-PyColor::PyColor(sf::Color target)
-:data(target) {}
-
-PyObject* PyColor::pyObject()
-{
-    PyObject* obj = PyType_GenericAlloc(&mcrfpydef::PyColorType, 0);
-    Py_INCREF(obj);
-    PyColorObject* self = (PyColorObject*)obj;
-    self->data = data;
-    return obj;
-}
-
-sf::Color PyColor::fromPy(PyObject* obj)
-{
-    PyColorObject* self = (PyColorObject*)obj;
-    return self->data;
-}
-
-sf::Color PyColor::fromPy(PyColorObject* self)
-{
-    return self->data;
-}
-
-void PyColor::set(sf::Color color)
-{
-    data = color;
-}
-
-sf::Color PyColor::get()
-{
-    return data;
-}
-
-Py_hash_t PyColor::hash(PyObject* obj)
-{
-    auto self = (PyColorObject*)obj;
-    Py_hash_t value = 0;
-    value += self->data.r;
-    value << 8; value += self->data.g; 
-    value << 8; value += self->data.b; 
-    value << 8; value += self->data.a;
-
-    return value;
-}
-
-PyObject* PyColor::repr(PyObject* obj)
-{
-    PyColorObject* self = (PyColorObject*)obj;
-    std::ostringstream ss;
-    sf::Color c = self->data;
-    ss << "<Color (" << int(c.r) << ", " << int(c.g) << ", " << int(c.b) << ", " << int(c.a) << ")>";
-
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-
-int PyColor::init(PyColorObject* self, PyObject* args, PyObject* kwds) {
-    //using namespace mcrfpydef;
-    static const char* keywords[] = { "r", "g", "b", "a", nullptr };
-    PyObject* leader;
-    int r = -1, g = -1, b = -1, a = 255;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|iii", const_cast<char**>(keywords), &leader, &g, &b, &a)) {
-        PyErr_SetString(PyExc_TypeError, "mcrfpy.Color requires a 3-tuple, 4-tuple, color name, or integer values within 0-255 (r, g, b, optionally a)");
-        return -1;
-    }
-
-    //std::cout << "Arg parsing succeeded. Values: " << r << " " << g << " " << b << " " << a <<std::endl;
-    //std::cout << PyUnicode_AsUTF8(PyObject_Repr(leader)) << std::endl;
-    // Tuple cases
-    if (PyTuple_Check(leader)) {
-        Py_ssize_t tupleSize = PyTuple_Size(leader);
-        if (tupleSize < 3 || tupleSize > 4) {
-            PyErr_SetString(PyExc_TypeError, "Invalid tuple length: mcrfpy.Color requires a 3-tuple, 4-tuple, color name, or integer values within 0-255 (r, g, b, optionally a)");
-            return -1;
-        }
-        r = PyLong_AsLong(PyTuple_GetItem(leader, 0));
-        g = PyLong_AsLong(PyTuple_GetItem(leader, 1));
-        b = PyLong_AsLong(PyTuple_GetItem(leader, 2));
-        if (tupleSize == 4) {
-            a = PyLong_AsLong(PyTuple_GetItem(leader, 3));
-        }
-    }
-    // Color name (not implemented yet)
-    else if (PyUnicode_Check(leader)) {
-        PyErr_SetString(PyExc_NotImplementedError, "Color names aren't ready yet");
-        return -1;
-    }
-    // Check if the leader is actually an integer for the r value
-    else if (PyLong_Check(leader)) {
-        r = PyLong_AsLong(leader);
-        // Additional validation not shown; g, b are required to be parsed
-    } else {
-        PyErr_SetString(PyExc_TypeError, "mcrfpy.Color requires a 3-tuple, 4-tuple, color name, or integer values within 0-255 (r, g, b, optionally a)");
-        return -1;
-    }
-
-    // Validate color values
-    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;
-    }
-
-    self->data = sf::Color(r, g, b, a);
-    return 0;
-}
-
-PyObject* PyColor::pynew(PyTypeObject* type, PyObject* args, PyObject* kwds)
-{
-    auto obj = (PyObject*)type->tp_alloc(type, 0);
-    //Py_INCREF(obj);
-    return obj;
-}
-
-PyObject* PyColor::get_member(PyObject* obj, void* closure)
-{
-    // TODO
-    return Py_None;
-}
-
-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

@@ -1,48 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-
-class PyColor;
-class UIDrawable; // forward declare for pointer
-
-typedef struct {
-    PyObject_HEAD
-    sf::Color data;
-} PyColorObject;
-
-class PyColor
-{
-private:
-public:
-    sf::Color data;
-    PyColor(sf::Color);
-    void set(sf::Color);
-    sf::Color get();
-    PyObject* pyObject();
-    static sf::Color fromPy(PyObject*);
-    static sf::Color fromPy(PyColorObject*);
-    static PyObject* repr(PyObject*);
-    static Py_hash_t hash(PyObject*);
-    static int init(PyColorObject*, PyObject*, PyObject*);
-    static PyObject* pynew(PyTypeObject* type, PyObject* args=NULL, PyObject* kwds=NULL);
-    static PyObject* get_member(PyObject*, void*);
-    static int set_member(PyObject*, PyObject*, void*);
-    
-    static PyGetSetDef getsetters[];
-    static PyColorObject* from_arg(PyObject*);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyColorType = {
-        .tp_name = "mcrfpy.Color",
-        .tp_basicsize = sizeof(PyColorObject),
-        .tp_itemsize = 0,
-        .tp_repr = PyColor::repr,
-        .tp_hash = PyColor::hash,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("SFML Color Object"),
-        .tp_getset = PyColor::getsetters,
-        .tp_init = (initproc)PyColor::init,
-        .tp_new = PyColor::pynew,
-    };
-}

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,82 +0,0 @@
-#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)
-{
-    texture = sf::Texture();
-    texture.loadFromFile(source);
-    auto size = texture.getSize();
-    sheet_width = (size.x / sprite_width);
-    sheet_height = (size.y / sprite_height);
-    if (size.x % sprite_width != 0 || size.y % sprite_height != 0)
-    {
-        std::cout << "Warning: Texture `" << source << "` is not an even number of sprite widths or heights across." << std::endl 
-            << "Sprite size given was " << sprite_w << "x" << sprite_h << "px but the file has a resolution of " << sheet_width << "x" << sheet_height << "px." << std::endl;
-    }
-}
-
-sf::Sprite PyTexture::sprite(int index, sf::Vector2f pos,  sf::Vector2f s)
-{
-    int tx = index % sheet_width, ty = index / sheet_width;
-    auto ir = sf::IntRect(tx * sprite_width, ty * sprite_height, sprite_width, sprite_height);
-    auto sprite = sf::Sprite(texture, ir);
-    sprite.setPosition(pos);
-    sprite.setScale(s);
-    return sprite;
-}
-
-PyObject* PyTexture::pyObject()
-{
-    std::cout << "Find type" << std::endl;
-    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();
-    }
-    catch (std::bad_weak_ptr& e)
-    {
-        std::cout << "Bad weak ptr: shared_from_this() failed in PyTexture::pyObject(); did you create a PyTexture 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* 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;
-    return reinterpret_cast<Py_hash_t>(self->data.get());
-}
-
-int PyTexture::init(PyTextureObject* self, PyObject* args, PyObject* kwds)
-{
-    static const char* keywords[] = { "filename", "sprite_width", "sprite_height", nullptr };
-    char* filename;
-    int sprite_width, sprite_height;
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "sii", const_cast<char**>(keywords), &filename, &sprite_width, &sprite_height))
-        return -1;
-    self->data = std::make_shared<PyTexture>(filename, sprite_width, sprite_height);
-    return 0;
-}
-
-PyObject* PyTexture::pynew(PyTypeObject* type, PyObject* args, PyObject* kwds)
-{
-    return (PyObject*)type->tp_alloc(type, 0);
-}

src/PyTexture.h

@@ -1,43 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-
-class PyTexture;
-
-typedef struct {
-    PyObject_HEAD
-        std::shared_ptr<PyTexture> data;
-} PyTextureObject;
-
-class PyTexture : public std::enable_shared_from_this<PyTexture>
-{
-private:
-    sf::Texture texture;
-    std::string source;
-    int sheet_width, sheet_height;
-public:
-    int sprite_width, sprite_height; // just use them read only, OK?
-    PyTexture(std::string filename, int sprite_w, int sprite_h);
-    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);
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyTextureType = {
-        .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,
-    };
-}

src/PyVector.cpp

@@ -1,111 +0,0 @@
-#include "PyVector.h"
-
-PyGetSetDef PyVector::getsetters[] = {
-    {"x", (getter)PyVector::get_member, (setter)PyVector::set_member, "X/horizontal component",   (void*)0},
-    {"y", (getter)PyVector::get_member, (setter)PyVector::set_member, "Y/vertical component",     (void*)1},
-    {NULL}
-};
-
-PyVector::PyVector(sf::Vector2f target)
-:data(target) {}
-
-PyObject* PyVector::pyObject()
-{
-    PyObject* obj = PyType_GenericAlloc(&mcrfpydef::PyVectorType, 0);
-    Py_INCREF(obj);
-    PyVectorObject* self = (PyVectorObject*)obj;
-    self->data = data;
-    return obj;
-}
-
-sf::Vector2f PyVector::fromPy(PyObject* obj)
-{
-    PyVectorObject* self = (PyVectorObject*)obj;
-    return self->data;
-}
-
-sf::Vector2f PyVector::fromPy(PyVectorObject* self)
-{
-    return self->data;
-}
-
-Py_hash_t PyVector::hash(PyObject* obj)
-{
-    auto self = (PyVectorObject*)obj;
-    Py_hash_t value = 0;
-    value += self->data.x;
-    value << 8; value += self->data.y; 
-
-    return value;
-}
-
-PyObject* PyVector::repr(PyObject* obj)
-{
-    PyVectorObject* self = (PyVectorObject*)obj;
-    std::ostringstream ss;
-    sf::Vector2f v = self->data;
-    ss << "<Vector (" << v.x << ", " << v.y << ")>";
-
-    std::string repr_str = ss.str();
-    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
-}
-
-
-int PyVector::init(PyVectorObject* self, PyObject* args, PyObject* kwds)
-{
-    using namespace mcrfpydef;
-    static const char* keywords[] = { "x", "y", nullptr };
-    PyObject* leader = NULL;
-    float x=0, y=0;
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Of", const_cast<char**>(keywords), &leader, &y))
-    {
-        //PyErr_SetString(PyExc_TypeError, "mcrfpy.Vector requires a 2-tuple or two numeric values");
-        return -1;
-    }
-    if (leader == NULL || leader == Py_None)
-    {
-        self->data = sf::Vector2f();
-        return 0;
-    } 
-
-    if (PyTuple_Check(leader))
-    {
-        if (PyTuple_Size(leader) != 2)
-        {
-            PyErr_SetString(PyExc_TypeError, "Invalid tuple length: mcrfpy.Vector requires a 2-tuple");
-            return -1;
-        }
-        x = PyFloat_AsDouble(PyTuple_GetItem(leader, 0));
-        y = PyFloat_AsDouble(PyTuple_GetItem(leader, 1));
-
-        self->data = sf::Vector2f(x, y);
-        return 0;
-    }
-    // else - 
-    else if (!PyFloat_Check(leader) && !(PyLong_Check(leader)))
-    {
-        PyErr_SetString(PyExc_TypeError, "mcrfpy.Vector requires a 2-tuple or two numeric values");
-        return -1;
-    }
-    if (PyFloat_Check(leader)) x = PyFloat_AsDouble(leader);
-    else x = PyLong_AsDouble(leader);
-    self->data = sf::Vector2f(x, y);
-    return 0;
-}
-
-PyObject* PyVector::pynew(PyTypeObject* type, PyObject* args, PyObject* kwds)
-{
-    return (PyObject*)type->tp_alloc(type, 0);
-}
-
-PyObject* PyVector::get_member(PyObject* obj, void* closure)
-{
-    // TODO
-    return Py_None;
-}
-
-int PyVector::set_member(PyObject* obj, PyObject* value, void* closure)
-{
-    // TODO
-    return 0;
-}

src/PyVector.h

@@ -1,42 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "Python.h"
-
-typedef struct {
-    PyObject_HEAD
-    sf::Vector2f data;
-} PyVectorObject;
-
-class PyVector
-{
-public:
-    sf::Vector2f data;
-    PyVector(sf::Vector2f);
-    PyVector();
-    PyObject* pyObject();
-    static sf::Vector2f fromPy(PyObject*);
-    static sf::Vector2f fromPy(PyVectorObject*);
-    static PyObject* repr(PyObject*);
-    static Py_hash_t hash(PyObject*);
-    static int init(PyVectorObject*, PyObject*, PyObject*);
-    static PyObject* pynew(PyTypeObject* type, PyObject* args=NULL, PyObject* kwds=NULL);
-    static PyObject* get_member(PyObject*, void*);
-    static int set_member(PyObject*, PyObject*, void*);
-    
-    static PyGetSetDef getsetters[];
-};
-
-namespace mcrfpydef {
-    static PyTypeObject PyVectorType = {
-        .tp_name = "mcrfpy.Vector",
-        .tp_basicsize = sizeof(PyVectorObject),
-        .tp_itemsize = 0,
-        .tp_repr = PyVector::repr,
-        .tp_hash = PyVector::hash,
-        .tp_flags = Py_TPFLAGS_DEFAULT,
-        .tp_doc = PyDoc_STR("SFML Vector Object"),
-        .tp_getset = PyVector::getsetters,
-        .tp_init = (initproc)PyVector::init,
-        .tp_new = PyVector::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,471 @@
+#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() {}
+
+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));
+}
+
+//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(float s)
+{
+    sprite.setScale(sf::Vector2f(s, s));
+}
+
+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, IndexTexture* _itex, float _x, float _y, float _w, float _h)
+: grid_x(gx), grid_y(gy),
+  zoom(1.0f), center_x((gx/2) * _itex->grid_size), center_y((gy/2) * _itex->grid_size),
+  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, IndexTexture* _itex, sf::Vector2f _xy, sf::Vector2f _wh)
+: grid_x(gx), grid_y(gy),
+  zoom(1.0f), center_x((gx/2) * _itex->grid_size), center_y((gy/2) * _itex->grid_size),
+  itex(_itex), 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);
+    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));
+}
+
+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 / itex->grid_size;
+    float center_y_sq = center_y / itex->grid_size;
+
+    float width_sq = box.getSize().x / (itex->grid_size * zoom);
+    float height_sq = box.getSize().y / (itex->grid_size * 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(itex->grid_size * zoom, itex->grid_size * 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*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);
+            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) {
+                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(zoom);
+        auto pixel_pos = sf::Vector2f(
+            (e->position.x*itex->grid_size - left_spritepixels) * zoom,
+            (e->position.y*itex->grid_size - 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;
+}

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

@@ -61,15 +61,15 @@ UITestScene::UITestScene(GameEngine* g) : Scene(g)
     //ui_elements.push_back(&e1);
     //ui_elements.push_back(&e2);
 
-    //t.loadFromFile("./assets/kenney_tinydungeon.png");
+    t.loadFromFile("./assets/kenney_tinydungeon.png");
-    //t.setSmooth(false);
+    t.setSmooth(false);
-    //auto* indextex = new IndexTexture(t, 16, 12, 11);
+    auto* indextex = new IndexTexture(t, 16, 12, 11);
-    //Resources::game->textures.push_back(*indextex);
+    Resources::game->textures.push_back(*indextex);
+
 
-    auto ptex = std::make_shared<PyTexture>("./assets/kenney_tinydungeon.png", 16, 16);
 
     //std::cout << Resources::game->textures.size() << " textures loaded.\n";
-    auto e3 = std::make_shared<UISprite>(ptex, 84, sf::Vector2f(10, 10), 4.0);
+    auto e3 = std::make_shared<UISprite>();
 
     // Make UISprite more like IndexSprite: this is bad
     //e3->x = 10; e3->y = 10;
@@ -79,19 +79,19 @@ UITestScene::UITestScene(GameEngine* g) : Scene(g)
     //e3->update();
 
     // This goes to show how inconvenient the default constructor is. It should be removed
-    //e3->itex = &Resources::game->textures[0];
+    e3->itex = &Resources::game->textures[0];
-    //e3->sprite.setTexture(e3->itex->texture);
+    e3->sprite.setTexture(e3->itex->texture);
-    //e3->sprite_index = 84;
+    e3->sprite_index = 84;
-    //e3->sprite.setTextureRect(e3->itex->spriteCoordinates(e3->sprite_index));
+    e3->sprite.setTextureRect(e3->itex->spriteCoordinates(e3->sprite_index));
-    //e3->setPosition(10, 10);
+    e3->setPosition(10, 10);
-    //e3->setScale(4.0f);
+    e3->setScale(4.0f);
 
     e1aa->children->push_back(e3);
 
 
 
     auto e4 = std::make_shared<UISprite>(
-            ptex, //indextex, //&Resources::game->textures[0],
+            indextex, //&Resources::game->textures[0],
             85, sf::Vector2f(90, 10), 4.0);
     e1aa->children->push_back(e4);
     //std::cout << "UISprite built: " << e4->sprite.getPosition().x << " " << e4->sprite.getPosition().y << " " << e4->sprite.getScale().x << " " <<
@@ -106,7 +106,7 @@ UITestScene::UITestScene(GameEngine* g) : Scene(g)
 
     // UIGrid test:               (in grid cells)      (in screen pixels)
     //              constructor args:  w  h  texture    x    y    w    h   
-    auto e5 = std::make_shared<UIGrid>(4, 4, ptex, sf::Vector2f(550, 150), sf::Vector2f(200, 200));
+    auto e5 = std::make_shared<UIGrid>(4, 4, indextex, 550, 150, 200, 200);
     e5->zoom=2.0;
     e5->points[0].color =  sf::Color(255, 0, 0);
     e5->points[1].tilesprite = 1;
@@ -125,7 +125,7 @@ UITestScene::UITestScene(GameEngine* g) : Scene(g)
     e5a->grid = e5;
     //auto e5as = UISprite(indextex, 85, sf::Vector2f(0, 0), 1.0);
     //e5a->sprite = e5as; // will copy constructor even exist for UISprite...?
-    e5a->sprite = UISprite(ptex, 85, sf::Vector2f(0, 0), 1.0);
+    e5a->sprite = UISprite(indextex, 85, sf::Vector2f(0, 0), 1.0);
     e5a->position = sf::Vector2f(1, 0);
 
     e5->entities->push_back(e5a);
@@ -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/cos_play.py

@@ -1,7 +1,7 @@
 import mcrfpy
 mcrfpy.createScene("play")
 ui = mcrfpy.sceneUI("play")
-t = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 16) # 12, 11)
+t = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 12, 11)
 font = mcrfpy.Font("assets/JetbrainsMono.ttf")
 
 frame_color = (64, 64, 128)

src/scripts/game.py

@@ -1,60 +1,221 @@
+#print("Hello mcrogueface")
 import mcrfpy
+import cos_play
+# Universal stuff
 font = mcrfpy.Font("assets/JetbrainsMono.ttf")
-texture = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 16)
+texture = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 12, 11)
+texture_cold = mcrfpy.Texture("assets/kenney_ice.png", 16, 12, 11)
+texture_hot = mcrfpy.Texture("assets/kenney_lava.png", 16, 12, 11)
 
-print("[game.py] Default texture:")
+# Test stuff
-print(mcrfpy.default_texture)
+mcrfpy.createScene("boom")
-print(type(mcrfpy.default_texture))
+mcrfpy.setScene("boom")
+ui = mcrfpy.sceneUI("boom")
+box = mcrfpy.Frame(40, 60, 200, 300, fill_color=(255,128,0), outline=4.0, outline_color=(64,64,255,96))
+ui.append(box)
 
-# build test widgets
+#caption = mcrfpy.Caption(10, 10, "Clicky", font, (255, 255, 255, 255), (0, 0, 0, 255))
+#box.click = lambda x, y, btn, type: print("Hello callback: ", x, y, btn, type)
+#box.children.append(caption)
 
-mcrfpy.createScene("pytest")
+test_sprite_number = 86 
-mcrfpy.setScene("pytest")
+sprite = mcrfpy.Sprite(20, 60, texture, test_sprite_number, 4.0)
-ui = mcrfpy.sceneUI("pytest")
+spritecap = mcrfpy.Caption(5, 5, "60", font)
+def click_sprite(x, y, btn, action):
+    global test_sprite_number
+    if action != "start": return
+    if btn in ("left", "wheel_up"):
+        test_sprite_number -= 1
+    elif btn in ("right", "wheel_down"):
+        test_sprite_number += 1
+    sprite.sprite_number = test_sprite_number # TODO - inconsistent naming for __init__, __repr__ and getsetter: sprite_number vs sprite_index
+    spritecap.text = test_sprite_number
 
-# Frame
+sprite.click = click_sprite # TODO - sprites don't seem to correct for screen position or scale when clicking
-f = mcrfpy.Frame(25, 19, 462, 346, fill_color=(255, 92, 92))
+box.children.append(sprite)
-print("Frame alive")
+box.children.append(spritecap)
-# fill (LinkedColor / Color):    f.fill_color
+box.click = click_sprite
-# outline (LinkedColor / Color): f.outline_color
-# pos (LinkedVector / Vector):   f.pos
-# size (LinkedVector / Vector):  f.size
 
-# Caption
+f_a = mcrfpy.Frame(250, 60, 80, 80, fill_color=(255, 92, 92))
-print("Caption attempt w/ fill_color:")
+f_a_txt = mcrfpy.Caption(5, 5, "0", 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")
-#c.fill_color = (255, 255, 255)
-print("Lol, did it segfault?")
-# outline (LinkedColor / Color): c.outline_color
-# font (Font):                   c.font
-# pos (LinkedVector / Vector):   c.pos
 
-# Sprite
+f_b = mcrfpy.Frame(340, 60, 80, 80, fill_color=(92, 255, 92))
-s = mcrfpy.Sprite(25, 384+19, texture, 86, 9.0)
+f_b_txt = mcrfpy.Caption(5, 5, "0", font)
-# pos (LinkedVector / Vector):   s.pos
-# texture (Texture):             s.texture
 
-# Grid
+f_c = mcrfpy.Frame(430, 60, 80, 80, fill_color=(92, 92, 255))
-g = mcrfpy.Grid(10, 10, texture, 512+25, 384+19, 462, 346)
+f_c_txt = mcrfpy.Caption(5, 5, "0", font)
-# texture (Texture):             g.texture
-# pos (LinkedVector / Vector):   g.pos
-# size (LinkedVector / Vector):  g.size
 
-for _x in range(10):
-    for _y in range(10):
-        g.at((_x, _y)).color = (255 - _x*25, 255 - _y*25, 255)
-g.zoom = 2.0
 
-[ui.append(d) for d in (f, c, s, g)]
+ui.append(f_a)
+f_a.children.append(f_a_txt)
+ui.append(f_b)
+f_b.children.append(f_b_txt)
+ui.append(f_c)
+f_c.children.append(f_c_txt)
 
-print("built!")
+import sys
+def ding(*args):
+    f_a_txt.text = str(sys.getrefcount(ding)) + " refs"
+    f_b_txt.text = sys.getrefcount(dong)
+    f_c_txt.text = sys.getrefcount(stress_test)
 
-# tests
+def dong(*args):
+    f_a_txt.text = str(sys.getrefcount(ding)) + " refs"
+    f_b_txt.text = sys.getrefcount(dong)
+    f_c_txt.text = sys.getrefcount(stress_test)
 
+running = False
+timers = []
+
+def add_ding():
+    global timers
+    n = len(timers)
+    mcrfpy.setTimer(f"timer{n}", ding, 100)
+    print("+1 ding:", timers)
+
+def add_dong():
+    global timers
+    n = len(timers)
+    mcrfpy.setTimer(f"timer{n}", dong, 100)
+    print("+1 dong:", timers)
+
+def remove_random():
+    global timers
+    target = random.choice(timers)
+    print("-1 timer:", target)
+    print("remove from list")
+    timers.remove(target)
+    print("delTimer")
+    mcrfpy.delTimer(target)
+    print("done")
+
+import random
+import time
+def stress_test(*args):
+    global running
+    global timers
+    if not running:
+        print("stress test initial")
+        running = True
+        timers.append("recurse")
+        add_ding()
+        add_dong()
+        mcrfpy.setTimer("recurse", stress_test, 1000)
+        mcrfpy.setTimer("terminate", lambda *args: mcrfpy.delTimer("recurse"), 30000)
+        ding(); dong()
+    else:
+        #print("stress test random activity")
+        #random.choice([
+        #    add_ding,
+        #    add_dong,
+        #    remove_random
+        #    ])()
+        #print(timers)
+        print("Segfaultin' time")
+        mcrfpy.delTimer("recurse")
+        print("Does this still work?")
+        time.sleep(0.5)
+        print("How about now?")
+
+
+stress_test()
+
+
+# Loading Screen
+mcrfpy.createScene("loading")
+ui = mcrfpy.sceneUI("loading")
+#mcrfpy.setScene("loading")
+logo_texture = mcrfpy.Texture("assets/temp_logo.png", 1024, 1, 1)
+logo_sprite = mcrfpy.Sprite(50, 50, logo_texture, 0, 0.5)
+ui.append(logo_sprite)
+logo_sprite.click = lambda *args: mcrfpy.setScene("menu")
+logo_caption = mcrfpy.Caption(70, 600, "Click to Proceed", font, (255, 0, 0, 255), (0, 0, 0, 255))
+logo_caption.fill_color =(255, 0, 0, 255)
+ui.append(logo_caption)
+
+
+# menu screen
+mcrfpy.createScene("menu")
+
+for e in [
+    mcrfpy.Caption(10, 10, "Crypt of Sokoban", font, (255, 255, 255), (0, 0, 0)),
+    mcrfpy.Caption(20, 55, "a McRogueFace demo project", font, (192, 192, 192), (0, 0, 0)),
+    mcrfpy.Frame(15, 70, 150, 60, fill_color=(64, 64, 128)),
+    mcrfpy.Frame(15, 145, 150, 60, fill_color=(64, 64, 128)),
+    mcrfpy.Frame(15, 220, 150, 60, fill_color=(64, 64, 128)),
+    mcrfpy.Frame(15, 295, 150, 60, fill_color=(64, 64, 128)),
+    #mcrfpy.Frame(900, 10, 100, 100, fill_color=(255, 0, 0)),
+    ]:
+    mcrfpy.sceneUI("menu").append(e)
+
+def click_once(fn):
+    def wraps(*args, **kwargs):
+        #print(args)
+        action = args[3]
+        if action != "start": return
+        return fn(*args, **kwargs)
+    return wraps
+
+@click_once
+def asdf(x, y, btn, action):
+    print(f"clicky @({x},{y}) {action}->{btn}")
+
+@click_once
+def clicked_exit(*args):
+    mcrfpy.exit()
+
+menu_btns = [
+    ("Boom", lambda *args: 1 / 0),
+    ("Exit", clicked_exit), 
+    ("About", lambda *args: mcrfpy.setScene("about")), 
+    ("Settings", lambda *args: mcrfpy.setScene("settings")), 
+    ("Start", lambda *args: mcrfpy.setScene("play"))
+    ]
+for i in range(len(mcrfpy.sceneUI("menu"))):
+    e = mcrfpy.sceneUI("menu")[i] # TODO - fix iterator
+    #print(e, type(e))
+    if type(e) is not mcrfpy.Frame: continue
+    label, fn = menu_btns.pop()
+    #print(label)
+    e.children.append(mcrfpy.Caption(5, 5, label, font, (192, 192, 255), (0,0,0)))
+    e.click = fn
+
+
+# settings screen
+mcrfpy.createScene("settings")
+window_scaling = 1.0
+
+scale_caption = mcrfpy.Caption(180, 70, "1.0x", font, (255, 255, 255), (0, 0, 0))
+scale_caption.fill_color = (255, 255, 255) # TODO - mcrfpy.Caption.__init__ is not setting colors
+for e in [
+    mcrfpy.Caption(10, 10, "Settings", font, (255, 255, 255), (0, 0, 0)),
+    mcrfpy.Frame(15, 70, 150, 60, fill_color=(64, 64, 128)), # +
+    mcrfpy.Frame(300, 70, 150, 60, fill_color=(64, 64, 128)), # -
+    mcrfpy.Frame(15, 295, 150, 60, fill_color=(64, 64, 128)),
+    scale_caption,
+    ]:
+    mcrfpy.sceneUI("settings").append(e)
+
+@click_once
+def game_scale(x, y, btn, action, delta):
+    global window_scaling
+    print(f"WIP - scale the window from {window_scaling:.1f} to {window_scaling+delta:.1f}")
+    window_scaling += delta
+    scale_caption.text = f"{window_scaling:.1f}x"
+    mcrfpy.setScale(window_scaling)
+    #mcrfpy.setScale(2)
+
+settings_btns = [
+    ("back", lambda *args: mcrfpy.setScene("menu")),
+    ("-", lambda x, y, btn, action: game_scale(x, y, btn, action, -0.1)),
+    ("+", lambda x, y, btn, action: game_scale(x, y, btn, action, +0.1))
+    ]
+
+for i in range(len(mcrfpy.sceneUI("settings"))):
+    e = mcrfpy.sceneUI("settings")[i] # TODO - fix iterator
+    #print(e, type(e))
+    if type(e) is not mcrfpy.Frame: continue
+    label, fn = settings_btns.pop()
+    #print(label, fn)
+    e.children.append(mcrfpy.Caption(5, 5, label, font, (192, 192, 255), (0,0,0)))
+    e.click = fn

src/scripts/game_old.py

@@ -1,221 +0,0 @@
-#print("Hello mcrogueface")
-import mcrfpy
-import cos_play
-# Universal stuff
-font = mcrfpy.Font("assets/JetbrainsMono.ttf")
-texture = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 16) #12, 11)
-texture_cold = mcrfpy.Texture("assets/kenney_ice.png", 16, 16) #12, 11)
-texture_hot = mcrfpy.Texture("assets/kenney_lava.png", 16, 16) #12, 11)
-
-# Test stuff
-mcrfpy.createScene("boom")
-mcrfpy.setScene("boom")
-ui = mcrfpy.sceneUI("boom")
-box = mcrfpy.Frame(40, 60, 200, 300, fill_color=(255,128,0), outline=4.0, outline_color=(64,64,255,96))
-ui.append(box)
-
-#caption = mcrfpy.Caption(10, 10, "Clicky", font, (255, 255, 255, 255), (0, 0, 0, 255))
-#box.click = lambda x, y, btn, type: print("Hello callback: ", x, y, btn, type)
-#box.children.append(caption)
-
-test_sprite_number = 86 
-sprite = mcrfpy.Sprite(20, 60, texture, test_sprite_number, 4.0)
-spritecap = mcrfpy.Caption(5, 5, "60", font)
-def click_sprite(x, y, btn, action):
-    global test_sprite_number
-    if action != "start": return
-    if btn in ("left", "wheel_up"):
-        test_sprite_number -= 1
-    elif btn in ("right", "wheel_down"):
-        test_sprite_number += 1
-    sprite.sprite_number = test_sprite_number # TODO - inconsistent naming for __init__, __repr__ and getsetter: sprite_number vs sprite_index
-    spritecap.text = test_sprite_number
-
-sprite.click = click_sprite # TODO - sprites don't seem to correct for screen position or scale when clicking
-box.children.append(sprite)
-box.children.append(spritecap)
-box.click = click_sprite
-
-f_a = mcrfpy.Frame(250, 60, 80, 80, fill_color=(255, 92, 92))
-f_a_txt = mcrfpy.Caption(5, 5, "0", font)
-
-f_b = mcrfpy.Frame(340, 60, 80, 80, fill_color=(92, 255, 92))
-f_b_txt = mcrfpy.Caption(5, 5, "0", font)
-
-f_c = mcrfpy.Frame(430, 60, 80, 80, fill_color=(92, 92, 255))
-f_c_txt = mcrfpy.Caption(5, 5, "0", font)
-
-
-ui.append(f_a)
-f_a.children.append(f_a_txt)
-ui.append(f_b)
-f_b.children.append(f_b_txt)
-ui.append(f_c)
-f_c.children.append(f_c_txt)
-
-import sys
-def ding(*args):
-    f_a_txt.text = str(sys.getrefcount(ding)) + " refs"
-    f_b_txt.text = sys.getrefcount(dong)
-    f_c_txt.text = sys.getrefcount(stress_test)
-
-def dong(*args):
-    f_a_txt.text = str(sys.getrefcount(ding)) + " refs"
-    f_b_txt.text = sys.getrefcount(dong)
-    f_c_txt.text = sys.getrefcount(stress_test)
-
-running = False
-timers = []
-
-def add_ding():
-    global timers
-    n = len(timers)
-    mcrfpy.setTimer(f"timer{n}", ding, 100)
-    print("+1 ding:", timers)
-
-def add_dong():
-    global timers
-    n = len(timers)
-    mcrfpy.setTimer(f"timer{n}", dong, 100)
-    print("+1 dong:", timers)
-
-def remove_random():
-    global timers
-    target = random.choice(timers)
-    print("-1 timer:", target)
-    print("remove from list")
-    timers.remove(target)
-    print("delTimer")
-    mcrfpy.delTimer(target)
-    print("done")
-
-import random
-import time
-def stress_test(*args):
-    global running
-    global timers
-    if not running:
-        print("stress test initial")
-        running = True
-        timers.append("recurse")
-        add_ding()
-        add_dong()
-        mcrfpy.setTimer("recurse", stress_test, 1000)
-        mcrfpy.setTimer("terminate", lambda *args: mcrfpy.delTimer("recurse"), 30000)
-        ding(); dong()
-    else:
-        #print("stress test random activity")
-        #random.choice([
-        #    add_ding,
-        #    add_dong,
-        #    remove_random
-        #    ])()
-        #print(timers)
-        print("Segfaultin' time")
-        mcrfpy.delTimer("recurse")
-        print("Does this still work?")
-        time.sleep(0.5)
-        print("How about now?")
-
-
-stress_test()
-
-
-# Loading Screen
-mcrfpy.createScene("loading")
-ui = mcrfpy.sceneUI("loading")
-#mcrfpy.setScene("loading")
-logo_texture = mcrfpy.Texture("assets/temp_logo.png", 1024, 1024)#1, 1)
-logo_sprite = mcrfpy.Sprite(50, 50, logo_texture, 0, 0.5)
-ui.append(logo_sprite)
-logo_sprite.click = lambda *args: mcrfpy.setScene("menu")
-logo_caption = mcrfpy.Caption(70, 600, "Click to Proceed", font, (255, 0, 0, 255), (0, 0, 0, 255))
-#logo_caption.fill_color =(255, 0, 0, 255)
-ui.append(logo_caption)
-
-
-# menu screen
-mcrfpy.createScene("menu")
-
-for e in [
-    mcrfpy.Caption(10, 10, "Crypt of Sokoban", font, (255, 255, 255), (0, 0, 0)),
-    mcrfpy.Caption(20, 55, "a McRogueFace demo project", font, (192, 192, 192), (0, 0, 0)),
-    mcrfpy.Frame(15, 70, 150, 60, fill_color=(64, 64, 128)),
-    mcrfpy.Frame(15, 145, 150, 60, fill_color=(64, 64, 128)),
-    mcrfpy.Frame(15, 220, 150, 60, fill_color=(64, 64, 128)),
-    mcrfpy.Frame(15, 295, 150, 60, fill_color=(64, 64, 128)),
-    #mcrfpy.Frame(900, 10, 100, 100, fill_color=(255, 0, 0)),
-    ]:
-    mcrfpy.sceneUI("menu").append(e)
-
-def click_once(fn):
-    def wraps(*args, **kwargs):
-        #print(args)
-        action = args[3]
-        if action != "start": return
-        return fn(*args, **kwargs)
-    return wraps
-
-@click_once
-def asdf(x, y, btn, action):
-    print(f"clicky @({x},{y}) {action}->{btn}")
-
-@click_once
-def clicked_exit(*args):
-    mcrfpy.exit()
-
-menu_btns = [
-    ("Boom", lambda *args: 1 / 0),
-    ("Exit", clicked_exit), 
-    ("About", lambda *args: mcrfpy.setScene("about")), 
-    ("Settings", lambda *args: mcrfpy.setScene("settings")), 
-    ("Start", lambda *args: mcrfpy.setScene("play"))
-    ]
-for i in range(len(mcrfpy.sceneUI("menu"))):
-    e = mcrfpy.sceneUI("menu")[i] # TODO - fix iterator
-    #print(e, type(e))
-    if type(e) is not mcrfpy.Frame: continue
-    label, fn = menu_btns.pop()
-    #print(label)
-    e.children.append(mcrfpy.Caption(5, 5, label, font, (192, 192, 255), (0,0,0)))
-    e.click = fn
-
-
-# settings screen
-mcrfpy.createScene("settings")
-window_scaling = 1.0
-
-scale_caption = mcrfpy.Caption(180, 70, "1.0x", font, (255, 255, 255), (0, 0, 0))
-#scale_caption.fill_color = (255, 255, 255) # TODO - mcrfpy.Caption.__init__ is not setting colors
-for e in [
-    mcrfpy.Caption(10, 10, "Settings", font, (255, 255, 255), (0, 0, 0)),
-    mcrfpy.Frame(15, 70, 150, 60, fill_color=(64, 64, 128)), # +
-    mcrfpy.Frame(300, 70, 150, 60, fill_color=(64, 64, 128)), # -
-    mcrfpy.Frame(15, 295, 150, 60, fill_color=(64, 64, 128)),
-    scale_caption,
-    ]:
-    mcrfpy.sceneUI("settings").append(e)
-
-@click_once
-def game_scale(x, y, btn, action, delta):
-    global window_scaling
-    print(f"WIP - scale the window from {window_scaling:.1f} to {window_scaling+delta:.1f}")
-    window_scaling += delta
-    scale_caption.text = f"{window_scaling:.1f}x"
-    mcrfpy.setScale(window_scaling)
-    #mcrfpy.setScale(2)
-
-settings_btns = [
-    ("back", lambda *args: mcrfpy.setScene("menu")),
-    ("-", lambda x, y, btn, action: game_scale(x, y, btn, action, -0.1)),
-    ("+", lambda x, y, btn, action: game_scale(x, y, btn, action, +0.1))
-    ]
-
-for i in range(len(mcrfpy.sceneUI("settings"))):
-    e = mcrfpy.sceneUI("settings")[i] # TODO - fix iterator
-    #print(e, type(e))
-    if type(e) is not mcrfpy.Frame: continue
-    label, fn = settings_btns.pop()
-    #print(label, fn)
-    e.children.append(mcrfpy.Caption(5, 5, label, font, (192, 192, 255), (0,0,0)))
-    e.click = fn

wikicrayons_colors.txt

@@ -1,168 +0,0 @@
-Red	#ED0A3F
-Maroon	#C32148
-Scarlet	#FD0E35
-Brick Red	#C62D42
-English Vermilion	#CC474B
-Madder Lake	#CC3336
-Permanent Geranium Lake	#E12C2C
-Maximum Red	#D92121
-Chestnut	#B94E48
-Orange-Red	#FF5349
-Sunset Orange	#FE4C40
-Bittersweet	#FE6F5E
-Dark Venetian Red	#B33B24
-Venetian Red	#CC553D
-Light Venetian Red	#E6735C
-Vivid Tangerine	#FF9980
-Middle Red	#E58E73
-Burnt Orange	#FF7034
-Red-Orange	#FF3F34
-Orange	#FF8833
-Macaroni and Cheese	#FFB97B
-Middle Yellow Red	#ECAC76
-Mango Tango	#E77200
-Yellow-Orange	#FFAE42
-Maximum Yellow Red	#F2BA49
-Banana Mania	#FBE7B2
-Maize	#F2C649
-Orange-Yellow	#F8D568
-Goldenrod	#FCD667
-Dandelion	#FED85D
-Yellow	#FBE870
-Green-Yellow	#F1E788
-Middle Yellow	#FFEB00
-Olive Green	#B5B35C
-Spring Green	#ECEBBD
-Maximum Yellow	#FAFA37
-Canary	#FFFF99
-Lemon Yellow	#FFFF9F
-Maximum Green Yellow	#D9E650
-Middle Green Yellow	#ACBF60
-Inchworm	#B0E313
-Light Chrome Green	#BEE64B
-Yellow-Green	#C5E17A
-Maximum Green	#5E8C31
-Asparagus	#7BA05B
-Granny Smith Apple	#9DE093
-Fern	#63B76C
-Middle Green	#4D8C57
-Green	#01A638
-Medium Chrome Green	#6CA67C
-Forest Green	#5FA777
-Sea Green	#93DFB8
-Shamrock	#33CC99
-Mountain Meadow	#1AB385
-Jungle Green	#29AB87
-Caribbean Green	#00CC99
-Tropical Rain Forest	#00755E
-Middle Blue Green	#8DD9CC
-Pine Green	#01796F
-Maximum Blue Green	#30BFBF
-Robin's Egg Blue	#00CCCC
-Teal Blue	#008080
-Light Blue	#8FD8D8
-Aquamarine	#458B74
-Turquoise Blue	#6CDAE7
-Outer Space	#2D383A
-Sky Blue	#76D7EA
-Middle Blue	#7ED4E6
-Blue-Green	#0095B7
-Pacific Blue	#009DC4
-Cerulean	#02A4D3
-Maximum Blue	#47ABCC
-Blue (I)	#2EB4E6
-Cerulean Blue	#339ACC
-Cornflower	#93CCEA
-Green-Blue	#2887C8
-Midnight Blue	#003366
-Navy Blue	#0066CC
-Denim	#1560BD
-Blue (III)	#0066FF
-Cadet Blue	#A9B2C3
-Periwinkle	#C3CDE6
-Blue (II)	#4570E6
-Bluetiful	#3C69E7
-Wild Blue Yonder	#7A89B8
-Indigo	#4F69C6
-Manatee	#8D90A1
-Cobalt Blue	#8C90C8
-Celestial Blue	#7070CC
-Blue Bell	#9999CC
-Maximum Blue Purple	#ACACE6
-Violet-Blue	#766EC8
-Blue-Violet	#6456B7
-Ultramarine Blue	#3F26BF
-Middle Blue Purple	#8B72BE
-Purple Heart	#652DC1
-Royal Purple	#6B3FA0
-Violet (II)	#8359A3
-Medium Violet	#8F47B3
-Wisteria	#C9A0DC
-Lavender (I)	#BF8FCC
-Vivid Violet	#803790
-Maximum Purple	#733380
-Purple Mountains' Majesty	#D6AEDD
-Fuchsia	#C154C1
-Pink Flamingo	#F2583E
-Violet (I)	#732E6C
-Brilliant Rose	#E667CE
-Orchid	#E29CD2
-Plum	#843179
-Medium Rose	#D96CBE
-Thistle	#D8BFD8
-Mulberry	#C8509B
-Red-Violet	#BB3385
-Middle Purple	#D982B5
-Maximum Red Purple	#A63A79
-Jazzberry Jam	#A50B5E
-Eggplant	#614051
-Magenta	#F653A6
-Cerise	#DA3287
-Wild Strawberry	#FF3399
-Lavender (II)	#FBAED2
-Cotton Candy	#FFB7D5
-Carnation Pink	#FFA6C9
-Violet-Red	#F7468A
-Razzmatazz	#E30B5C
-Piggy Pink	#FDD7E4
-Carmine	#E62E6B
-Blush	#DB5079
-Tickle Me Pink	#FC80A5
-Mauvelous	#F091A9
-Salmon	#FF91A4
-Middle Red Purple	#A55353
-Mahogany	#CA3435
-Melon	#FEBAAD
-Pink Sherbert	#F7A38E
-Burnt Sienna	#E97451
-Brown	#AF593E
-Sepia	#9E5B40
-Fuzzy Wuzzy	#87421F
-Beaver	#926F5B
-Tumbleweed	#DEA681
-Raw Sienna	#D27D46
-Van Dyke Brown	#664228
-Tan	#FA9D5A
-Desert Sand	#EDC9AF
-Peach	#FFCBA4
-Burnt Umber	#805533
-Apricot	#FDD5B1
-Almond	#EED9C4
-Raw Umber	#665233
-Shadow	#837050
-Raw Sienna (I)	#E6BC5C
-Gold (I)	#92926E
-Gold (II)	#E6BE8A
-Silver	#C9C0BB
-Copper	#DA8A67
-Antique Brass	#C88A65
-Black	#000000
-Charcoal Gray	#736A62
-Gray	#8B8680
-Blue-Gray	#C8C8CD
-Timberwolf	#D9D6CF
-White	#FFFFFF
-Crayellow	#F1D651[6]
-Cool Mint	#DDEBEC[6]
-Oatmeal	#D9DAD2[6]
-Powder Blue	#C0D5F0[6]

xkcd_colors.txt

@@ -1,949 +0,0 @@
-cloudy blue	#acc2d9
-dark pastel green	#56ae57
-dust	#b2996e
-electric lime	#a8ff04
-fresh green	#69d84f
-light eggplant	#894585
-nasty green	#70b23f
-really light blue	#d4ffff
-tea	#65ab7c
-warm purple	#952e8f
-yellowish tan	#fcfc81
-cement	#a5a391
-dark grass green	#388004
-dusty teal	#4c9085
-grey teal	#5e9b8a
-macaroni and cheese	#efb435
-pinkish tan	#d99b82
-spruce	#0a5f38
-strong blue	#0c06f7
-toxic green	#61de2a
-windows blue	#3778bf
-blue blue	#2242c7
-blue with a hint of purple	#533cc6
-booger	#9bb53c
-bright sea green	#05ffa6
-dark green blue	#1f6357
-deep turquoise	#017374
-green teal	#0cb577
-strong pink	#ff0789
-bland	#afa88b
-deep aqua	#08787f
-lavender pink	#dd85d7
-light moss green	#a6c875
-light seafoam green	#a7ffb5
-olive yellow	#c2b709
-pig pink	#e78ea5
-deep lilac	#966ebd
-desert	#ccad60
-dusty lavender	#ac86a8
-purpley grey	#947e94
-purply	#983fb2
-candy pink	#ff63e9
-light pastel green	#b2fba5
-boring green	#63b365
-kiwi green	#8ee53f
-light grey green	#b7e1a1
-orange pink	#ff6f52
-tea green	#bdf8a3
-very light brown	#d3b683
-egg shell	#fffcc4
-eggplant purple	#430541
-powder pink	#ffb2d0
-reddish grey	#997570
-baby shit brown	#ad900d
-liliac	#c48efd
-stormy blue	#507b9c
-ugly brown	#7d7103
-custard	#fffd78
-darkish pink	#da467d
-deep brown	#410200
-greenish beige	#c9d179
-manilla	#fffa86
-off blue	#5684ae
-battleship grey	#6b7c85
-browny green	#6f6c0a
-bruise	#7e4071
-kelley green	#009337
-sickly yellow	#d0e429
-sunny yellow	#fff917
-azul	#1d5dec
-darkgreen	#054907
-green/yellow	#b5ce08
-lichen	#8fb67b
-light light green	#c8ffb0
-pale gold	#fdde6c
-sun yellow	#ffdf22
-tan green	#a9be70
-burple	#6832e3
-butterscotch	#fdb147
-toupe	#c7ac7d
-dark cream	#fff39a
-indian red	#850e04
-light lavendar	#efc0fe
-poison green	#40fd14
-baby puke green	#b6c406
-bright yellow green	#9dff00
-charcoal grey	#3c4142
-squash	#f2ab15
-cinnamon	#ac4f06
-light pea green	#c4fe82
-radioactive green	#2cfa1f
-raw sienna	#9a6200
-baby purple	#ca9bf7
-cocoa	#875f42
-light royal blue	#3a2efe
-orangeish	#fd8d49
-rust brown	#8b3103
-sand brown	#cba560
-swamp	#698339
-tealish green	#0cdc73
-burnt siena	#b75203
-camo	#7f8f4e
-dusk blue	#26538d
-fern	#63a950
-old rose	#c87f89
-pale light green	#b1fc99
-peachy pink	#ff9a8a
-rosy pink	#f6688e
-light bluish green	#76fda8
-light bright green	#53fe5c
-light neon green	#4efd54
-light seafoam	#a0febf
-tiffany blue	#7bf2da
-washed out green	#bcf5a6
-browny orange	#ca6b02
-nice blue	#107ab0
-sapphire	#2138ab
-greyish teal	#719f91
-orangey yellow	#fdb915
-parchment	#fefcaf
-straw	#fcf679
-very dark brown	#1d0200
-terracota	#cb6843
-ugly blue	#31668a
-clear blue	#247afd
-creme	#ffffb6
-foam green	#90fda9
-grey/green	#86a17d
-light gold	#fddc5c
-seafoam blue	#78d1b6
-topaz	#13bbaf
-violet pink	#fb5ffc
-wintergreen	#20f986
-yellow tan	#ffe36e
-dark fuchsia	#9d0759
-indigo blue	#3a18b1
-light yellowish green	#c2ff89
-pale magenta	#d767ad
-rich purple	#720058
-sunflower yellow	#ffda03
-green/blue	#01c08d
-leather	#ac7434
-racing green	#014600
-vivid purple	#9900fa
-dark royal blue	#02066f
-hazel	#8e7618
-muted pink	#d1768f
-booger green	#96b403
-canary	#fdff63
-cool grey	#95a3a6
-dark taupe	#7f684e
-darkish purple	#751973
-true green	#089404
-coral pink	#ff6163
-dark sage	#598556
-dark slate blue	#214761
-flat blue	#3c73a8
-mushroom	#ba9e88
-rich blue	#021bf9
-dirty purple	#734a65
-greenblue	#23c48b
-icky green	#8fae22
-light khaki	#e6f2a2
-warm blue	#4b57db
-dark hot pink	#d90166
-deep sea blue	#015482
-carmine	#9d0216
-dark yellow green	#728f02
-pale peach	#ffe5ad
-plum purple	#4e0550
-golden rod	#f9bc08
-neon red	#ff073a
-old pink	#c77986
-very pale blue	#d6fffe
-blood orange	#fe4b03
-grapefruit	#fd5956
-sand yellow	#fce166
-clay brown	#b2713d
-dark blue grey	#1f3b4d
-flat green	#699d4c
-light green blue	#56fca2
-warm pink	#fb5581
-dodger blue	#3e82fc
-gross green	#a0bf16
-ice	#d6fffa
-metallic blue	#4f738e
-pale salmon	#ffb19a
-sap green	#5c8b15
-algae	#54ac68
-bluey grey	#89a0b0
-greeny grey	#7ea07a
-highlighter green	#1bfc06
-light light blue	#cafffb
-light mint	#b6ffbb
-raw umber	#a75e09
-vivid blue	#152eff
-deep lavender	#8d5eb7
-dull teal	#5f9e8f
-light greenish blue	#63f7b4
-mud green	#606602
-pinky	#fc86aa
-red wine	#8c0034
-shit green	#758000
-tan brown	#ab7e4c
-darkblue	#030764
-rosa	#fe86a4
-lipstick	#d5174e
-pale mauve	#fed0fc
-claret	#680018
-dandelion	#fedf08
-orangered	#fe420f
-poop green	#6f7c00
-ruby	#ca0147
-dark	#1b2431
-greenish turquoise	#00fbb0
-pastel red	#db5856
-piss yellow	#ddd618
-bright cyan	#41fdfe
-dark coral	#cf524e
-algae green	#21c36f
-darkish red	#a90308
-reddy brown	#6e1005
-blush pink	#fe828c
-camouflage green	#4b6113
-lawn green	#4da409
-putty	#beae8a
-vibrant blue	#0339f8
-dark sand	#a88f59
-purple/blue	#5d21d0
-saffron	#feb209
-twilight	#4e518b
-warm brown	#964e02
-bluegrey	#85a3b2
-bubble gum pink	#ff69af
-duck egg blue	#c3fbf4
-greenish cyan	#2afeb7
-petrol	#005f6a
-royal	#0c1793
-butter	#ffff81
-dusty orange	#f0833a
-off yellow	#f1f33f
-pale olive green	#b1d27b
-orangish	#fc824a
-leaf	#71aa34
-light blue grey	#b7c9e2
-dried blood	#4b0101
-lightish purple	#a552e6
-rusty red	#af2f0d
-lavender blue	#8b88f8
-light grass green	#9af764
-light mint green	#a6fbb2
-sunflower	#ffc512
-velvet	#750851
-brick orange	#c14a09
-lightish red	#fe2f4a
-pure blue	#0203e2
-twilight blue	#0a437a
-violet red	#a50055
-yellowy brown	#ae8b0c
-carnation	#fd798f
-muddy yellow	#bfac05
-dark seafoam green	#3eaf76
-deep rose	#c74767
-dusty red	#b9484e
-grey/blue	#647d8e
-lemon lime	#bffe28
-purple/pink	#d725de
-brown yellow	#b29705
-purple brown	#673a3f
-wisteria	#a87dc2
-banana yellow	#fafe4b
-lipstick red	#c0022f
-water blue	#0e87cc
-brown grey	#8d8468
-vibrant purple	#ad03de
-baby green	#8cff9e
-barf green	#94ac02
-eggshell blue	#c4fff7
-sandy yellow	#fdee73
-cool green	#33b864
-pale	#fff9d0
-blue/grey	#758da3
-hot magenta	#f504c9
-greyblue	#77a1b5
-purpley	#8756e4
-baby shit green	#889717
-brownish pink	#c27e79
-dark aquamarine	#017371
-diarrhea	#9f8303
-light mustard	#f7d560
-pale sky blue	#bdf6fe
-turtle green	#75b84f
-bright olive	#9cbb04
-dark grey blue	#29465b
-greeny brown	#696006
-lemon green	#adf802
-light periwinkle	#c1c6fc
-seaweed green	#35ad6b
-sunshine yellow	#fffd37
-ugly purple	#a442a0
-medium pink	#f36196
-puke brown	#947706
-very light pink	#fff4f2
-viridian	#1e9167
-bile	#b5c306
-faded yellow	#feff7f
-very pale green	#cffdbc
-vibrant green	#0add08
-bright lime	#87fd05
-spearmint	#1ef876
-light aquamarine	#7bfdc7
-light sage	#bcecac
-yellowgreen	#bbf90f
-baby poo	#ab9004
-dark seafoam	#1fb57a
-deep teal	#00555a
-heather	#a484ac
-rust orange	#c45508
-dirty blue	#3f829d
-fern green	#548d44
-bright lilac	#c95efb
-weird green	#3ae57f
-peacock blue	#016795
-avocado green	#87a922
-faded orange	#f0944d
-grape purple	#5d1451
-hot green	#25ff29
-lime yellow	#d0fe1d
-mango	#ffa62b
-shamrock	#01b44c
-bubblegum	#ff6cb5
-purplish brown	#6b4247
-vomit yellow	#c7c10c
-pale cyan	#b7fffa
-key lime	#aeff6e
-tomato red	#ec2d01
-lightgreen	#76ff7b
-merlot	#730039
-night blue	#040348
-purpleish pink	#df4ec8
-apple	#6ecb3c
-baby poop green	#8f9805
-green apple	#5edc1f
-heliotrope	#d94ff5
-yellow/green	#c8fd3d
-almost black	#070d0d
-cool blue	#4984b8
-leafy green	#51b73b
-mustard brown	#ac7e04
-dusk	#4e5481
-dull brown	#876e4b
-frog green	#58bc08
-vivid green	#2fef10
-bright light green	#2dfe54
-fluro green	#0aff02
-kiwi	#9cef43
-seaweed	#18d17b
-navy green	#35530a
-ultramarine blue	#1805db
-iris	#6258c4
-pastel orange	#ff964f
-yellowish orange	#ffab0f
-perrywinkle	#8f8ce7
-tealish	#24bca8
-dark plum	#3f012c
-pear	#cbf85f
-pinkish orange	#ff724c
-midnight purple	#280137
-light urple	#b36ff6
-dark mint	#48c072
-greenish tan	#bccb7a
-light burgundy	#a8415b
-turquoise blue	#06b1c4
-ugly pink	#cd7584
-sandy	#f1da7a
-electric pink	#ff0490
-muted purple	#805b87
-mid green	#50a747
-greyish	#a8a495
-neon yellow	#cfff04
-banana	#ffff7e
-carnation pink	#ff7fa7
-tomato	#ef4026
-sea	#3c9992
-muddy brown	#886806
-turquoise green	#04f489
-buff	#fef69e
-fawn	#cfaf7b
-muted blue	#3b719f
-pale rose	#fdc1c5
-dark mint green	#20c073
-amethyst	#9b5fc0
-blue/green	#0f9b8e
-chestnut	#742802
-sick green	#9db92c
-pea	#a4bf20
-rusty orange	#cd5909
-stone	#ada587
-rose red	#be013c
-pale aqua	#b8ffeb
-deep orange	#dc4d01
-earth	#a2653e
-mossy green	#638b27
-grassy green	#419c03
-pale lime green	#b1ff65
-light grey blue	#9dbcd4
-pale grey	#fdfdfe
-asparagus	#77ab56
-blueberry	#464196
-purple red	#990147
-pale lime	#befd73
-greenish teal	#32bf84
-caramel	#af6f09
-deep magenta	#a0025c
-light peach	#ffd8b1
-milk chocolate	#7f4e1e
-ocher	#bf9b0c
-off green	#6ba353
-purply pink	#f075e6
-lightblue	#7bc8f6
-dusky blue	#475f94
-golden	#f5bf03
-light beige	#fffeb6
-butter yellow	#fffd74
-dusky purple	#895b7b
-french blue	#436bad
-ugly yellow	#d0c101
-greeny yellow	#c6f808
-orangish red	#f43605
-shamrock green	#02c14d
-orangish brown	#b25f03
-tree green	#2a7e19
-deep violet	#490648
-gunmetal	#536267
-blue/purple	#5a06ef
-cherry	#cf0234
-sandy brown	#c4a661
-warm grey	#978a84
-dark indigo	#1f0954
-midnight	#03012d
-bluey green	#2bb179
-grey pink	#c3909b
-soft purple	#a66fb5
-blood	#770001
-brown red	#922b05
-medium grey	#7d7f7c
-berry	#990f4b
-poo	#8f7303
-purpley pink	#c83cb9
-light salmon	#fea993
-snot	#acbb0d
-easter purple	#c071fe
-light yellow green	#ccfd7f
-dark navy blue	#00022e
-drab	#828344
-light rose	#ffc5cb
-rouge	#ab1239
-purplish red	#b0054b
-slime green	#99cc04
-baby poop	#937c00
-irish green	#019529
-pink/purple	#ef1de7
-dark navy	#000435
-greeny blue	#42b395
-light plum	#9d5783
-pinkish grey	#c8aca9
-dirty orange	#c87606
-rust red	#aa2704
-pale lilac	#e4cbff
-orangey red	#fa4224
-primary blue	#0804f9
-kermit green	#5cb200
-brownish purple	#76424e
-murky green	#6c7a0e
-wheat	#fbdd7e
-very dark purple	#2a0134
-bottle green	#044a05
-watermelon	#fd4659
-deep sky blue	#0d75f8
-fire engine red	#fe0002
-yellow ochre	#cb9d06
-pumpkin orange	#fb7d07
-pale olive	#b9cc81
-light lilac	#edc8ff
-lightish green	#61e160
-carolina blue	#8ab8fe
-mulberry	#920a4e
-shocking pink	#fe02a2
-auburn	#9a3001
-bright lime green	#65fe08
-celadon	#befdb7
-pinkish brown	#b17261
-poo brown	#885f01
-bright sky blue	#02ccfe
-celery	#c1fd95
-dirt brown	#836539
-strawberry	#fb2943
-dark lime	#84b701
-copper	#b66325
-medium brown	#7f5112
-muted green	#5fa052
-robin's egg	#6dedfd
-bright aqua	#0bf9ea
-bright lavender	#c760ff
-ivory	#ffffcb
-very light purple	#f6cefc
-light navy	#155084
-pink red	#f5054f
-olive brown	#645403
-poop brown	#7a5901
-mustard green	#a8b504
-ocean green	#3d9973
-very dark blue	#000133
-dusty green	#76a973
-light navy blue	#2e5a88
-minty green	#0bf77d
-adobe	#bd6c48
-barney	#ac1db8
-jade green	#2baf6a
-bright light blue	#26f7fd
-light lime	#aefd6c
-dark khaki	#9b8f55
-orange yellow	#ffad01
-ocre	#c69c04
-maize	#f4d054
-faded pink	#de9dac
-british racing green	#05480d
-sandstone	#c9ae74
-mud brown	#60460f
-light sea green	#98f6b0
-robin egg blue	#8af1fe
-aqua marine	#2ee8bb
-dark sea green	#11875d
-soft pink	#fdb0c0
-orangey brown	#b16002
-cherry red	#f7022a
-burnt yellow	#d5ab09
-brownish grey	#86775f
-camel	#c69f59
-purplish grey	#7a687f
-marine	#042e60
-greyish pink	#c88d94
-pale turquoise	#a5fbd5
-pastel yellow	#fffe71
-bluey purple	#6241c7
-canary yellow	#fffe40
-faded red	#d3494e
-sepia	#985e2b
-coffee	#a6814c
-bright magenta	#ff08e8
-mocha	#9d7651
-ecru	#feffca
-purpleish	#98568d
-cranberry	#9e003a
-darkish green	#287c37
-brown orange	#b96902
-dusky rose	#ba6873
-melon	#ff7855
-sickly green	#94b21c
-silver	#c5c9c7
-purply blue	#661aee
-purpleish blue	#6140ef
-hospital green	#9be5aa
-shit brown	#7b5804
-mid blue	#276ab3
-amber	#feb308
-easter green	#8cfd7e
-soft blue	#6488ea
-cerulean blue	#056eee
-golden brown	#b27a01
-bright turquoise	#0ffef9
-red pink	#fa2a55
-red purple	#820747
-greyish brown	#7a6a4f
-vermillion	#f4320c
-russet	#a13905
-steel grey	#6f828a
-lighter purple	#a55af4
-bright violet	#ad0afd
-prussian blue	#004577
-slate green	#658d6d
-dirty pink	#ca7b80
-dark blue green	#005249
-pine	#2b5d34
-yellowy green	#bff128
-dark gold	#b59410
-bluish	#2976bb
-darkish blue	#014182
-dull red	#bb3f3f
-pinky red	#fc2647
-bronze	#a87900
-pale teal	#82cbb2
-military green	#667c3e
-barbie pink	#fe46a5
-bubblegum pink	#fe83cc
-pea soup green	#94a617
-dark mustard	#a88905
-shit	#7f5f00
-medium purple	#9e43a2
-very dark green	#062e03
-dirt	#8a6e45
-dusky pink	#cc7a8b
-red violet	#9e0168
-lemon yellow	#fdff38
-pistachio	#c0fa8b
-dull yellow	#eedc5b
-dark lime green	#7ebd01
-denim blue	#3b5b92
-teal blue	#01889f
-lightish blue	#3d7afd
-purpley blue	#5f34e7
-light indigo	#6d5acf
-swamp green	#748500
-brown green	#706c11
-dark maroon	#3c0008
-hot purple	#cb00f5
-dark forest green	#002d04
-faded blue	#658cbb
-drab green	#749551
-light lime green	#b9ff66
-snot green	#9dc100
-yellowish	#faee66
-light blue green	#7efbb3
-bordeaux	#7b002c
-light mauve	#c292a1
-ocean	#017b92
-marigold	#fcc006
-muddy green	#657432
-dull orange	#d8863b
-steel	#738595
-electric purple	#aa23ff
-fluorescent green	#08ff08
-yellowish brown	#9b7a01
-blush	#f29e8e
-soft green	#6fc276
-bright orange	#ff5b00
-lemon	#fdff52
-purple grey	#866f85
-acid green	#8ffe09
-pale lavender	#eecffe
-violet blue	#510ac9
-light forest green	#4f9153
-burnt red	#9f2305
-khaki green	#728639
-cerise	#de0c62
-faded purple	#916e99
-apricot	#ffb16d
-dark olive green	#3c4d03
-grey brown	#7f7053
-green grey	#77926f
-true blue	#010fcc
-pale violet	#ceaefa
-periwinkle blue	#8f99fb
-light sky blue	#c6fcff
-blurple	#5539cc
-green brown	#544e03
-bluegreen	#017a79
-bright teal	#01f9c6
-brownish yellow	#c9b003
-pea soup	#929901
-forest	#0b5509
-barney purple	#a00498
-ultramarine	#2000b1
-purplish	#94568c
-puke yellow	#c2be0e
-bluish grey	#748b97
-dark periwinkle	#665fd1
-dark lilac	#9c6da5
-reddish	#c44240
-light maroon	#a24857
-dusty purple	#825f87
-terra cotta	#c9643b
-avocado	#90b134
-marine blue	#01386a
-teal green	#25a36f
-slate grey	#59656d
-lighter green	#75fd63
-electric green	#21fc0d
-dusty blue	#5a86ad
-golden yellow	#fec615
-bright yellow	#fffd01
-light lavender	#dfc5fe
-umber	#b26400
-poop	#7f5e00
-dark peach	#de7e5d
-jungle green	#048243
-eggshell	#ffffd4
-denim	#3b638c
-yellow brown	#b79400
-dull purple	#84597e
-chocolate brown	#411900
-wine red	#7b0323
-neon blue	#04d9ff
-dirty green	#667e2c
-light tan	#fbeeac
-ice blue	#d7fffe
-cadet blue	#4e7496
-dark mauve	#874c62
-very light blue	#d5ffff
-grey purple	#826d8c
-pastel pink	#ffbacd
-very light green	#d1ffbd
-dark sky blue	#448ee4
-evergreen	#05472a
-dull pink	#d5869d
-aubergine	#3d0734
-mahogany	#4a0100
-reddish orange	#f8481c
-deep green	#02590f
-vomit green	#89a203
-purple pink	#e03fd8
-dusty pink	#d58a94
-faded green	#7bb274
-camo green	#526525
-pinky purple	#c94cbe
-pink purple	#db4bda
-brownish red	#9e3623
-dark rose	#b5485d
-mud	#735c12
-brownish	#9c6d57
-emerald green	#028f1e
-pale brown	#b1916e
-dull blue	#49759c
-burnt umber	#a0450e
-medium green	#39ad48
-clay	#b66a50
-light aqua	#8cffdb
-light olive green	#a4be5c
-brownish orange	#cb7723
-dark aqua	#05696b
-purplish pink	#ce5dae
-dark salmon	#c85a53
-greenish grey	#96ae8d
-jade	#1fa774
-ugly green	#7a9703
-dark beige	#ac9362
-emerald	#01a049
-pale red	#d9544d
-light magenta	#fa5ff7
-sky	#82cafc
-light cyan	#acfffc
-yellow orange	#fcb001
-reddish purple	#910951
-reddish pink	#fe2c54
-orchid	#c875c4
-dirty yellow	#cdc50a
-orange red	#fd411e
-deep red	#9a0200
-orange brown	#be6400
-cobalt blue	#030aa7
-neon pink	#fe019a
-rose pink	#f7879a
-greyish purple	#887191
-raspberry	#b00149
-aqua green	#12e193
-salmon pink	#fe7b7c
-tangerine	#ff9408
-brownish green	#6a6e09
-red brown	#8b2e16
-greenish brown	#696112
-pumpkin	#e17701
-pine green	#0a481e
-charcoal	#343837
-baby pink	#ffb7ce
-cornflower	#6a79f7
-blue violet	#5d06e9
-chocolate	#3d1c02
-greyish green	#82a67d
-scarlet	#be0119
-green yellow	#c9ff27
-dark olive	#373e02
-sienna	#a9561e
-pastel purple	#caa0ff
-terracotta	#ca6641
-aqua blue	#02d8e9
-sage green	#88b378
-blood red	#980002
-deep pink	#cb0162
-grass	#5cac2d
-moss	#769958
-pastel blue	#a2bffe
-bluish green	#10a674
-green blue	#06b48b
-dark tan	#af884a
-greenish blue	#0b8b87
-pale orange	#ffa756
-vomit	#a2a415
-forrest green	#154406
-dark lavender	#856798
-dark violet	#34013f
-purple blue	#632de9
-dark cyan	#0a888a
-olive drab	#6f7632
-pinkish	#d46a7e
-cobalt	#1e488f
-neon purple	#bc13fe
-light turquoise	#7ef4cc
-apple green	#76cd26
-dull green	#74a662
-wine	#80013f
-powder blue	#b1d1fc
-off white	#ffffe4
-electric blue	#0652ff
-dark turquoise	#045c5a
-blue purple	#5729ce
-azure	#069af3
-bright red	#ff000d
-pinkish red	#f10c45
-cornflower blue	#5170d7
-light olive	#acbf69
-grape	#6c3461
-greyish blue	#5e819d
-purplish blue	#601ef9
-yellowish green	#b0dd16
-greenish yellow	#cdfd02
-medium blue	#2c6fbb
-dusty rose	#c0737a
-light violet	#d6b4fc
-midnight blue	#020035
-bluish purple	#703be7
-red orange	#fd3c06
-dark magenta	#960056
-greenish	#40a368
-ocean blue	#03719c
-coral	#fc5a50
-cream	#ffffc2
-reddish brown	#7f2b0a
-burnt sienna	#b04e0f
-brick	#a03623
-sage	#87ae73
-grey green	#789b73
-white	#ffffff
-robin's egg blue	#98eff9
-moss green	#658b38
-steel blue	#5a7d9a
-eggplant	#380835
-light yellow	#fffe7a
-leaf green	#5ca904
-light grey	#d8dcd6
-puke	#a5a502
-pinkish purple	#d648d7
-sea blue	#047495
-pale purple	#b790d4
-slate blue	#5b7c99
-blue grey	#607c8e
-hunter green	#0b4008
-fuchsia	#ed0dd9
-crimson	#8c000f
-pale yellow	#ffff84
-ochre	#bf9005
-mustard yellow	#d2bd0a
-light red	#ff474c
-cerulean	#0485d1
-pale pink	#ffcfdc
-deep blue	#040273
-rust	#a83c09
-light teal	#90e4c1
-slate	#516572
-goldenrod	#fac205
-dark yellow	#d5b60a
-dark grey	#363737
-army green	#4b5d16
-grey blue	#6b8ba4
-seafoam	#80f9ad
-puce	#a57e52
-spring green	#a9f971
-dark orange	#c65102
-sand	#e2ca76
-pastel green	#b0ff9d
-mint	#9ffeb0
-light orange	#fdaa48
-bright pink	#fe01b1
-chartreuse	#c1f80a
-deep purple	#36013f
-dark brown	#341c02
-taupe	#b9a281
-pea green	#8eab12
-puke green	#9aae07
-kelly green	#02ab2e
-seafoam green	#7af9ab
-blue green	#137e6d
-khaki	#aaa662
-burgundy	#610023
-dark teal	#014d4e
-brick red	#8f1402
-royal purple	#4b006e
-plum	#580f41
-mint green	#8fff9f
-gold	#dbb40c
-baby blue	#a2cffe
-yellow green	#c0fb2d
-bright purple	#be03fd
-dark red	#840000
-pale blue	#d0fefe
-grass green	#3f9b0b
-navy	#01153e
-aquamarine	#04d8b2
-burnt orange	#c04e01
-neon green	#0cff0c
-bright blue	#0165fc
-rose	#cf6275
-light pink	#ffd1df
-mustard	#ceb301
-indigo	#380282
-lime	#aaff32
-sea green	#53fca1
-periwinkle	#8e82fe
-dark pink	#cb416b
-olive green	#677a04
-peach	#ffb07c
-pale green	#c7fdb5
-light brown	#ad8150
-hot pink	#ff028d
-black	#000000
-lilac	#cea2fd
-navy blue	#001146
-royal blue	#0504aa
-beige	#e6daa6
-salmon	#ff796c
-olive	#6e750e
-maroon	#650021
-bright green	#01ff07
-dark purple	#35063e
-mauve	#ae7181
-forest green	#06470c
-aqua	#13eac9
-cyan	#00ffff
-tan	#d1b26f
-dark blue	#00035b
-lavender	#c79fef
-turquoise	#06c2ac
-dark green	#033500
-violet	#9a0eea
-light purple	#bf77f6
-lime green	#89fe05
-grey	#929591
-sky blue	#75bbfd
-yellow	#ffff14
-magenta	#c20078
-light green	#96f97b
-orange	#f97306
-teal	#029386
-light blue	#95d0fc
-red	#e50000
-brown	#653700
-pink	#ff81c0
-blue	#0343df
-green	#15b01a
-purple	#7e1e9c