Squashed commit of the following: [reprs_and_member_names]

Closes #22
Closes #23
Closes #24
Closes #25
Closes #31
Closes #56

commit 43fac8f4f3
Author: John McCardle <mccardle.john@gmail.com>
Date:   Sat Apr 20 18:32:52 2024 -0400

    Typo in UIFrame repr

commit 3fd5ad93e2
Author: John McCardle <mccardle.john@gmail.com>
Date:   Sat Apr 20 18:32:30 2024 -0400

    Add UIGridPoint and UIGridPointState repr

commit 03376897b8
Author: John McCardle <mccardle.john@gmail.com>
Date:   Sat Apr 20 18:32:17 2024 -0400

    Add UIGrid repr

commit 48af072a33
Author: John McCardle <mccardle.john@gmail.com>
Date:   Sat Apr 20 18:32:05 2024 -0400

    Add UIEntity repr

CMakeLists.txt

@@ -17,10 +17,6 @@ include_directories(${CMAKE_SOURCE_DIR}/deps/libtcod)
 include_directories(${CMAKE_SOURCE_DIR}/deps/cpython)
 include_directories(${CMAKE_SOURCE_DIR}/deps/Python)
 
-# TODO: Move this into the WIN32 if block below (as 'else')
-#include_directories(${CMAKE_SOURCE_DIR}/platform/linux)
-include_directories(${CMAKE_SOURCE_DIR}/deps/platform/linux)
-
 # Collect all the source files
 file(GLOB_RECURSE SOURCES "src/*.cpp")
 
@@ -43,6 +39,9 @@ if(WIN32)
     # include_directories(path_to_additional_includes)
     # link_directories(path_to_additional_libs)
     # list(APPEND LINK_LIBS additional_windows_libs)
+    include_directories(${CMAKE_SOURCE_DIR}/deps/platform/windows)
+else()
+    include_directories(${CMAKE_SOURCE_DIR}/deps/platform/linux)
 endif()
 
 # Add the directory where the linker should look for the libraries

css_colors.txt

@@ -0,0 +1,157 @@
+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 

deps/platform/linux/platform.h

@@ -0,0 +1,40 @@
+#ifndef __PLATFORM
+#define __PLATFORM
+#define __PLATFORM_SET_PYTHON_SEARCH_PATHS 1
+std::wstring executable_path()
+{
+    /*
+	wchar_t buffer[MAX_PATH];
+	GetModuleFileName(NULL, buffer, MAX_PATH);
+	std::wstring exec_path = buffer;
+    */
+    auto exec_path = std::filesystem::canonical("/proc/self/exe").parent_path();
+	return exec_path.wstring();
+    //size_t path_index = exec_path.find_last_of('/');
+	//return exec_path.substr(0, path_index);
+    
+}
+
+std::wstring executable_filename()
+{
+    auto exec_path = std::filesystem::canonical("/proc/self/exe");
+    return exec_path.wstring();
+}
+
+std::wstring working_path()
+{
+	auto cwd = std::filesystem::current_path();
+	return cwd.wstring();
+}
+
+std::string narrow_string(std::wstring convertme)
+{
+    //setup converter
+    using convert_type = std::codecvt_utf8<wchar_t>;
+    std::wstring_convert<convert_type, wchar_t> converter;
+
+    //use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
+    return converter.to_bytes(convertme);
+}
+
+#endif

deps/platform/windows/platform.h

@@ -0,0 +1,39 @@
+#ifndef __PLATFORM
+#define __PLATFORM
+#define __PLATFORM_SET_PYTHON_SEARCH_PATHS 0
+#include <Windows.h>
+
+std::wstring executable_path()
+{
+	wchar_t buffer[MAX_PATH];
+	GetModuleFileName(NULL, buffer, MAX_PATH);
+	std::wstring exec_path = buffer;
+	size_t path_index = exec_path.find_last_of(L"\\/");
+	return exec_path.substr(0, path_index);
+}
+
+std::wstring executable_filename()
+{
+	wchar_t buffer[MAX_PATH];
+	GetModuleFileName(NULL, buffer, MAX_PATH);
+	std::wstring exec_path = buffer;
+	return exec_path;
+}
+
+std::wstring working_path()
+{
+	auto cwd = std::filesystem::current_path();
+	return cwd.wstring();
+}
+
+std::string narrow_string(std::wstring convertme)
+{
+	//setup converter
+	using convert_type = std::codecvt_utf8<wchar_t>;
+	std::wstring_convert<convert_type, wchar_t> converter;
+
+	//use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
+	return converter.to_bytes(convertme);
+}
+
+#endif

generate_color_table.py

@@ -0,0 +1,111 @@
+# 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?)

scripts/Grid.py

@@ -1,50 +0,0 @@
-class GridPoint:
-    def __init__(self, color, walkable, tilesprite, transparent, visible, discovered, color_overlay, tile_overlay, uisprite):
-        self.color = color
-        self.walkable = walkable
-        self.tilesprite = tilesprite
-        self.transparent = transparent
-        self.visible = visible
-        self.discovered = discovered
-        self.color_overlay = color_overlay
-        self.tile_overlay = tile_overlay
-        self.uisprite = uisprite
-
-    def __repr__(self):
-        return f"<GridPoint {self.color}, {self.tilesprite}/{self.uisprite} {'W' if self.walkable else '-'}{'T' if self.transparent else '-'}{'V' if self.visible else '-'}{'D' if self.discovered else '-'} {self.color_overlay}/{self.tile_overlay}>"
-
-class Grid:
-    def __init__(self, title, gx, gy, gs, x, y, w, h, visible=False):
-        self.title = title
-        self.grid_x = gx
-        self.grid_y = gy
-        self.grid_size = gs
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.visible = visible
-
-        self.points = []
-        self.entities = []
-        
-    def at(self, x, y):
-        if not (x > 0 and y > 0 and x < self.grid_x and y < self.grid_y): return None
-        return self.points[y * self.grid_y + x]
-
-    def __repr__(self):
-        return f"<Grid {self.grid_x}x{self.grid_y}, grid_size={self.grid_size}, (({self.x},{self.y}), ({self.w}, {self.h})), visible={self.visible}>"
-
-
-# CGrid(Grid* _g, int _ti, int _si, int _x, int _y, bool _v)
-class Entity:
-    def __init__(self, parent, tex_index, sprite_index, x, y, visible=True):
-        self.parent = parent
-        self.tex_index = tex_index
-        self.sprite_index = sprite_index
-        self.x = x
-        self.y = y
-        self.visible = visible
-        
-    def __repr__(self):
-        return f"<Entity on grid {repr(self.parent)}@({self.x},{self.y}), TI={self.tex_index}, SI={self.sprite_index}, visible={self.visible}>"

scripts/MusicScene.py

@@ -1,79 +0,0 @@
-import mcrfpy
-BLACK = (0, 0, 0)
-WHITE = (255, 255, 255)
-RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
-DARKRED, DARKGREEN, DARKBLUE = (192, 0, 0), (0, 192, 0), (0, 0, 192)
-class MusicScene:
-    def __init__(self, ui_name = "demobox1", grid_name = "demogrid"):
-        # Texture & Sound Loading
-        print("Load textures")
-        mcrfpy.createTexture("./assets/test_portraits.png", 32, 8, 8) #0 - portraits
-        mcrfpy.createTexture("./assets/alives_other.png", 16, 64, 64) #1 - TinyWorld NPCs
-        mcrfpy.createTexture("./assets/alives_other.png", 32, 32, 32) #2 - TinyWorld NPCs - 2x2 sprite
-    #     	{"createSoundBuffer", McRFPy_API::_createSoundBuffer, METH_VARARGS, "(filename)"},
-	#{"loadMusic", McRFPy_API::_loadMusic, METH_VARARGS, "(filename)"},
-	#{"setMusicVolume", McRFPy_API::_setMusicVolume, METH_VARARGS, "(int)"},
-	#{"setSoundVolume", McRFPy_API::_setSoundVolume, METH_VARARGS, "(int)"},
-	#{"playSound", McRFPy_API::_playSound, METH_VARARGS, "(int)"},
-	#{"getMusicVolume", McRFPy_API::_getMusicVolume, METH_VARARGS, ""},
-	#{"getSoundVolume", McRFPy_API::_getSoundVolume, METH_VARARGS, ""},
-    
-        mcrfpy.loadMusic("./assets/ultima.ogg")
-        mcrfpy.createSoundBuffer("./assets/boom.wav")
-        self.ui_name = ui_name
-        self.grid_name = grid_name
-
-        print("Create UI")
-        # Create dialog UI
-        mcrfpy.createMenu(ui_name, 20, 540, 500, 200)
-        mcrfpy.createCaption(ui_name, f"Music Volume: {mcrfpy.getMusicVolume()}", 24, RED)
-        mcrfpy.createCaption(ui_name, f"SFX Volume: {mcrfpy.getSoundVolume()}", 24, RED)
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKBLUE, (0, 0, 0), "clicky", "testaction")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKRED, (0, 0, 0), "Music+", "mvol+")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKGREEN, (0, 0, 0), "Music-", "mvol-")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, GREEN, "SFX+", "svol+")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, RED, "SFX-", "svol-")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKRED, (0, 0, 0), "REPL", "startrepl")
-        mcrfpy.createSprite(ui_name, 1, 0, 20, 40, 3.0)
-        
-        print("Create UI 2")
-        entitymenu = "entitytestmenu"
-        
-        mcrfpy.createMenu(entitymenu, 840, 20, 20, 500)
-        mcrfpy.createButton(entitymenu, 0, 10, 150, 40, DARKBLUE, BLACK, "PlayM", "playm")
-        mcrfpy.createButton(entitymenu, 0, 60, 150, 40, DARKBLUE, BLACK, "StopM", "stopm")
-        mcrfpy.createButton(entitymenu, 0, 110, 150, 40, DARKBLUE, BLACK, "SFX", "boom")
-        print("Make UIs visible")
-        self.menus = mcrfpy.listMenus()
-        self.menus[0].visible = True
-        self.menus[1].w = 170
-        self.menus[1].visible = True
-        mcrfpy.modMenu(self.menus[0])
-        mcrfpy.modMenu(self.menus[1])
-        self.mvol = mcrfpy.getMusicVolume()
-        self.svol = mcrfpy.getSoundVolume()
-        mcrfpy.registerPyAction("mvol+", lambda: self.setmvol(self.mvol+10))
-        mcrfpy.registerPyAction("mvol-", lambda: self.setmvol(self.mvol-10))
-        mcrfpy.registerPyAction("svol+", lambda: self.setsvol(self.svol+10))
-        mcrfpy.registerPyAction("svol-", lambda: self.setsvol(self.svol-10))
-        mcrfpy.registerPyAction("playm", lambda: None)
-        mcrfpy.registerPyAction("stopm", lambda: None)
-        mcrfpy.registerPyAction("boom", lambda: mcrfpy.playSound(0))
-        
-    def setmvol(self, v):
-        mcrfpy.setMusicVolume(int(v))
-        self.menus[0].captions[0].text = f"Music Volume: {mcrfpy.getMusicVolume():.1f}"
-        mcrfpy.modMenu(self.menus[0])
-        self.mvol = mcrfpy.getMusicVolume()
-        
-    def setsvol(self, v):
-        mcrfpy.setSoundVolume(int(v))
-        self.menus[0].captions[1].text = f"Sound Volume: {mcrfpy.getSoundVolume():.1f}"
-        mcrfpy.modMenu(self.menus[0])
-        self.svol = mcrfpy.getSoundVolume()
-
-scene = None
-def start():
-    global scene
-    scene = MusicScene()
-

scripts/TestScene.py

@@ -1,575 +0,0 @@
-import UIMenu
-import Grid
-import mcrfpy
-from random import randint, choice
-from pprint import pprint
-#print("TestScene imported")
-BLACK = (0, 0, 0)
-WHITE = (255, 255, 255)
-RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
-DARKRED, DARKGREEN, DARKBLUE = (192, 0, 0), (0, 192, 0), (0, 0, 192)
-
-animations_in_progress = 0
-
-# don't load grid over and over, use the global scene
-scene = None
-
-class TestEntity:
-    def __init__(self, grid, label, tex_index, basesprite, x, y, texture_width=64, walk_frames=5, attack_frames=6, do_fov=False):
-        self.grid = grid
-        self.basesprite = basesprite
-        self.texture_width = texture_width
-        self.walk_frames = walk_frames
-        self.attack_frames = attack_frames
-        self.x = x
-        self.y = y
-        self.facing_direction = 0
-        self.do_fov = do_fov
-        self.label = label
-        self.inventory = []
-        #print(f"Calling C++ with: {repr((self.grid, label, tex_index, self.basesprite, x, y, self))}")
-        grids = mcrfpy.listGrids()
-        for g in grids:
-            if g.title == self.grid:
-                self.entity_index = len(g.entities)
-        mcrfpy.createEntity(self.grid, label, tex_index, self.basesprite, x, y, self)
-        
-    def ai_act(self):
-        return # no AI motion
-        #if self.label == "player": return
-        self.move(randint(-1, 1), randint(-1, 1))
-        scene.actors += 1
-        
-    def player_act(self):
-        #print("I'M INTERVENING")
-        mcrfpy.unlockPlayerInput()
-        scene.updatehints()
-        
-    def die(self):
-        #self.x = -2
-        #self.y = -2
-        self.move(-1000,-1000)
-        self.animate(0,animove=(-1000,-1000))
-        self.x = -1000
-        self.y = -1000
-        self.label = "dead"
-        
-    def interact(self, initiator, callback):
-        print(f"Interacted with {self.label}. ", end='')
-        if self.label == 'item':
-            print("'taking' item.")
-            callback()
-            self.die()
-        else:
-            print("blocking movement.")
-    
-    def move(self, dx, dy, force=False):
-        # select animation direction
-        # prefer left or right for diagonals.
-        #grids = mcrfpy.listGrids()
-        for g in scene.grids:
-            if g.title == self.grid:
-                if not force and g.at(self.x + dx, self.y + dy) is None or not g.at(self.x + dx, self.y + dy).walkable:
-                    #print("Blocked at target location.")
-                    return
-                if not force: # entities can be stepped on when force=True (like collecting items!)
-                    for entity in scene.tes:
-                        if (entity.x, entity.y) == (self.x + dx, self.y + dy):
-                            print(f"Blocked by entity {entity.label} at ({entity.x}, {entity.y})")
-                            return entity.interact(self, lambda: self.move(dx, dy, force=True))
-        if self.label == "player": 
-            mcrfpy.lockPlayerInput()
-            scene.updatehints()
-        if (dx == 0 and dy == 0):
-            direction = self.facing_direction # TODO, jump straight to computer turn
-        elif (dx):
-            direction = 2 if dx == +1 else 3
-        else:
-            direction = 0 if dy == +1 else 1
-        self.animate(direction, move=True, animove=(self.x + dx, self.y+dy))
-        self.facing_direction = direction
-        if (self.do_fov): mcrfpy.refreshFov()
-
-        
-    def animate(self, direction, attacking=False, move=False, animove=None):
-        start_sprite = self.basesprite + (self.texture_width * (direction + (4 if attacking else 0)))
-        animation_frames = [start_sprite + i for i in range((self.attack_frames if attacking else self.walk_frames))]
-        mcrfpy.createAnimation(
-            0.15, # duration, seconds
-            self.grid, # parent: a UIMenu or Grid key
-            "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-            self.entity_index, # target id: integer index for menu or grid objs; None for grid/menu
-            "sprite", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-            self.animation_done, #callback: callable once animation is complete
-            False, #loop: repeat indefinitely
-            animation_frames # values: iterable of frames for 'sprite', lerp target for others
-        )
-        #global animations_in_progress
-        #animations_in_progress += 1
-        if move:
-            pos = [self.x, self.y]
-            if (direction == 0): pos[1] += 1
-            elif (direction == 1): pos[1] -= 1
-            elif (direction == 2): pos[0] += 1
-            elif (direction == 3): pos[0] -= 1
-            if not animove: 
-                self.x, self.y = pos
-                animove = pos
-            else: 
-                pos = animove
-                self.x, self.y = animove
-            #scene.move_entity(self.grid, self.entity_index, pos)
-            #for g in mcrfpy.listGrids():
-            for g in scene.grids:
-                if g.title == self.grid:
-                    g.entities[self.entity_index].x = pos[0]
-                    g.entities[self.entity_index].y = pos[1]
-                    mcrfpy.modGrid(g, True)
-        if animove:
-            mcrfpy.createAnimation(
-                0.25, # duration, seconds
-                self.grid, # parent: a UIMenu or Grid key
-                "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-                self.entity_index, # target id: integer index for menu or grid objs; None for grid/menu
-                "position", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-                self.animation_done, #callback: callable once animation is complete
-                False, #loop: repeat indefinitely
-                animove # values: iterable of frames for 'sprite', lerp target for others
-            )
-            #animations_in_progress += 1
-
-        
-    def animation_done(self):
-        #global animations_in_progress
-        #animations_in_progress -= 1
-        scene.actors -= 1
-        #print(f"{self} done animating - {scene.actors} remaining")
-        if scene.actors <= 0:
-            scene.actors = 0
-            mcrfpy.unlockPlayerInput()
-            scene.updatehints()
-
-class TestItemEntity(TestEntity):
-    def __init__(self, grid, label, tex_index, basesprite, x, y, texture_width=64, walk_frames=5, attack_frames=6, do_fov=False, item="Nothing"):
-        super().__init__(grid, label, tex_index, basesprite, x, y, texture_width, walk_frames, attack_frames, do_fov)
-        self.item = item
-    
-    def interact(self, initiator, callback):
-        if self.label == 'dead': return super().interact(initiator, callback)
-        print(f"Interacted with {self.label}, an item. Adding {self.item} to {initiator.label}'s inventory")
-        initiator.inventory.append(self.item)
-        callback()
-        scene.itemguis()
-        self.die()
-        
-class TestDoorEntity(TestEntity):
-    def __init__(self, grid, label, tex_index, basesprite, x, y, texture_width=64, walk_frames=5, attack_frames=6, do_fov=False, key="Nothing"):
-        super().__init__(grid, label, tex_index, basesprite, x, y, texture_width, walk_frames, attack_frames, do_fov)
-        self.key = key
-        
-    def interact(self, initiator, callback):
-        if self.label == 'dead': return super().interact(initiator, callback)
-        print(f"Interacted with {self.label}, a Door. ", end='')
-        if self.key in initiator.inventory:
-            initiator.inventory.remove(self.key)
-            print("Taking key & passing.")
-            callback()
-            scene.itemguis()
-            self.die()
-        else:
-            print("The door is locked.")
-
-class TestScene:
-    def __init__(self, ui_name = "demobox1", grid_name = "demogrid"):
-        # Texture & Sound Loading
-        self.actors = 0
-        #print("Load textures")
-        mcrfpy.createTexture("./assets/test_portraits.png", 32, 8, 8) #0 - portraits
-        mcrfpy.createTexture("./assets/alives_other.png", 16, 64, 64) #1 - TinyWorld NPCs
-        mcrfpy.createTexture("./assets/alives_other.png", 32, 32, 32) #2 - TinyWorld NPCs - 2x2 sprite
-        mcrfpy.createTexture("./assets/custom_player.png", 16, 5, 13) #3 - player
-        mcrfpy.createTexture("./assets/Sprite-0001.png", 80, 10, 10) #4 - LGJ2023 keycard + other icons
-        mcrfpy.createTexture("./assets/tiny_keycards.png", 16, 8, 8) #5 - tiny keycards (ground items)
-        self.ui_name = ui_name
-        self.grid_name = grid_name
-
-        # Menu index = 0
-        #print("Create UI")
-        # Create dialog UI
-        mcrfpy.createMenu(ui_name, 20, 540, 500, 200)
-        #mcrfpy.createCaption(ui_name, "Hello There", 18, BLACK)
-        mcrfpy.createCaption(ui_name, "", 24, RED)
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKBLUE, (0, 0, 0), "clicky", "testaction")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKRED, (0, 0, 0), "REPL", "startrepl")
-        ##mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKGREEN, (0, 0, 0), "map gen", "gridgen")
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKGREEN, (0, 0, 0), "mapL", "gridgen2")
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKBLUE, (192, 0, 0), "a_menu", "animtest")
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKRED, GREEN, "a_spr", "animtest2")
-        #mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, GREEN, "Next sp", "nextsp")
-        #mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, RED, "Prev sp", "prevsp")
-        #mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, DARKGREEN, "+16 sp", "skipsp")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKGREEN, (0, 0, 0), "Next", "nextsp")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, (0, 0, 0), "Prev", "prevsp")
-        mcrfpy.createSprite(ui_name, 4, 1, 10, 10, 2.0)
-        
-        # Menu index = 1
-        #print("Create UI 2")
-        entitymenu = "entitytestmenu"
-        mcrfpy.createMenu(entitymenu, 840, 20, 20, 500)
-        mcrfpy.createButton(entitymenu, 0, 10, 150, 40, DARKBLUE, BLACK, "Up", "test_up")
-        mcrfpy.createButton(entitymenu, 0, 60, 150, 40, DARKBLUE, BLACK, "Down", "test_down")
-        mcrfpy.createButton(entitymenu, 0, 110, 150, 40, DARKBLUE, BLACK, "Left", "test_left")
-        mcrfpy.createButton(entitymenu, 0, 160, 150, 40, DARKBLUE, BLACK, "Right", "test_right")
-        mcrfpy.createButton(entitymenu, 0, 210, 150, 40, DARKBLUE, BLACK, "Attack", "test_attack")
-        mcrfpy.createButton(entitymenu, 0, 210, 150, 40, DARKBLUE, RED, "TE", "testent")
-        
-        # Menu index = 2
-        mcrfpy.createMenu(   "gridtitlemenu", 0, -10, 0, 0)
-        mcrfpy.createCaption("gridtitlemenu", "<grid name>", 18, WHITE)
-        #mcrfpy.createCaption("gridtitlemenu", "<camstate>", 16, WHITE)
-        
-        # Menu index = 3
-        mcrfpy.createMenu(   "hintsmenu", 0, 505, 0, 0)
-        mcrfpy.createCaption("hintsmenu", "<hintline>", 16, WHITE)
-        
-        # Menu index = 4
-        # menu names must be created in alphabetical order (?!) - thanks, C++ hash map
-        mcrfpy.createMenu(   "i",            600, 20, 0, 0)
-        #mcrfpy.createMenu(   "camstatemenu", 600, 20, 0, 0)
-        mcrfpy.createCaption("i", "<camstate>", 16, WHITE)
-        
-        # Menu index = 5
-        mcrfpy.createMenu( "j", 600, 500, 0, 0)
-        mcrfpy.createButton( "j", 0, 0, 80, 40, DARKBLUE, WHITE, "Recenter", "activatecamfollow")
-        
-        # Menu index = 6, 7, 8, 9, 10: keycard sprites
-        mcrfpy.createMenu("k", 540, 540, 80, 80) #6
-        mcrfpy.createSprite("k", 4, 0, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("l", 540 + (80 * 1), 540, 80, 80) #7
-        mcrfpy.createSprite("l", 4, 1, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("m", 540 + (80 * 2), 540, 80, 80) #8
-        mcrfpy.createSprite("m", 4, 2, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("n", 540 + (80 * 3), 540, 80, 80) #9
-        mcrfpy.createSprite("n", 4, 3, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("o", 540 + (80 * 4), 540, 80, 80) #10
-        mcrfpy.createSprite("o", 4, 4, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("p", 20, 20, 40, 40) #11
-        #mcrfpy.createButton("p", 0, 0, 130, 40, DARKGREEN, (0, 0, 0), "Register", "keyregistration")
-        mcrfpy.createButton("p", 0, 0, 130, 40, DARKGREEN, (0, 0, 0), "Register", "startrepl")
-        mcrfpy.registerPyAction("keyregistration", keyregistration)
-        #print("Make UIs visible")
-        self.menus = mcrfpy.listMenus()
-        self.menus[0].visible = True
-        self.menus[1].w = 170
-        self.menus[1].visible = True
-        self.menus[2].visible = True
-        
-        for mn in range(2, 6):
-            self.menus[mn].bgcolor = BLACK
-            self.menus[mn].visible = True
-            mcrfpy.modMenu(self.menus[mn])
-        
-        for mn in range(6, 11):
-            self.menus[mn].bgcolor = BLACK
-            self.menus[mn].visible = False
-            mcrfpy.modMenu(self.menus[mn])
-        
-        self.menus[11].visible=True
-        mcrfpy.modMenu(self.menus[11])
-                                            
-        #self.menus[2].bgcolor = BLACK
-        #self.menus[3].visible = True
-        #self.menus[3].bgcolor = BLACK
-        #self.menus[4].visible = True
-        #self.menus[4].bgcolor = BLACK
-        #self.menus[5].visible = True
-        #mcrfpy.modMenu(self.menus[0])
-        #mcrfpy.modMenu(self.menus[1])
-        #mcrfpy.modMenu(self.menus[2])
-        #mcrfpy.modMenu(self.menus[3])
-        #mcrfpy.modMenu(self.menus[4])
-        #mcrfpy.modMenu(self.menus[5])
-        #pprint(mcrfpy.listMenus())
-        #print(f"UI 1 gave back this sprite: {self.menus[0].sprites}")
-
-        #print("Create grid")
-        # create grid (title, gx, gy, gs, x, y, w, h)
-        mcrfpy.createGrid(grid_name, 100, 100, 16, 20, 20, 800, 500)
-        self.grids = mcrfpy.listGrids()
-        #print(self.grids)
-        
-        #print("Create entities")
-        #mcrfpy.createEntity("demogrid", "dragon", 2, 545, 10, 10, lambda: None)
-        #mcrfpy.createEntity("demogrid", "tinyenemy", 1, 1538, 3, 6, lambda: None)
-        
-        #print("Create fancy entity")
-        self.player = TestEntity("demogrid", "player", 3, 20, 17, 3, 5, walk_frames=4, attack_frames=5, do_fov=True)
-        self.tes = [
-            TestEntity("demogrid", "classtest", 1, 1538, 5, 7, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1545, 7, 9, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1552, 9, 11, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1566, 11, 13, 64, walk_frames=4, attack_frames=6),
-            #TestEntity("demogrid", "item", 1, 1573, 13, 15, 64, walk_frames=4, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1583, 15, 17, 64, walk_frames=4, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 130, 9, 7, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 136, 11, 9, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 143, 13, 11, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 158, 15, 13, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 165, 17, 15, 64, walk_frames=5, attack_frames=6),
-            self.player,
-            
-            TestItemEntity("demogrid", "GreenKeyCard", 5, 0, 19, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Green Keycard"),
-            TestItemEntity("demogrid", "BlueKeyCard", 5, 1, 21, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Blue Keycard"),
-            TestItemEntity("demogrid", "RedKeyCard", 5, 2, 23, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Red Keycard"),
-            TestItemEntity("demogrid", "OrangeKeyCard", 5, 3, 25, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Orange Keycard"),
-            TestItemEntity("demogrid", "DevilKeyCard", 5, 4, 27, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Devil Keycard"),
-            
-             TestDoorEntity("demogrid", "GreenKeyDoor",  5, 8,   19, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Green Keycard"),
-             TestDoorEntity("demogrid", "BlueKeyDoor",   5, 9,   21, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Blue Keycard"),
-             TestDoorEntity("demogrid", "RedKeyDoor",    5, 10,  23, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Red Keycard"),
-             TestDoorEntity("demogrid", "OrangeKeyDoor", 5, 11,  25, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Orange Keycard"),
-             TestDoorEntity("demogrid", "DevilKeyDoor",  5, 12,  27, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Devil Keycard")
-            ]
-        self.grids = mcrfpy.listGrids()
-        
-        self.entity_direction = 0
-        mcrfpy.registerPyAction("test_down",   lambda: [te.animate(0, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_up",     lambda: [te.animate(1, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_right",  lambda: [te.animate(2, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_left",   lambda: [te.animate(3, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_attack", lambda: [te.animate(0, True) for te in self.tes])
-        mcrfpy.registerPyAction("testent",     lambda: [te.animate(2, True) for te in self.tes])
-        mcrfpy.registerPyAction("activatecamfollow", lambda: mcrfpy.camFollow(True))
-
-        # Button behavior
-        self.clicks = 0
-        self.sprite_index = 0
-        #mcrfpy.registerPyAction("testaction", self.click)
-        mcrfpy.registerPyAction("gridgen", self.gridgen)
-        #mcrfpy.registerPyAction("gridgen2", lambda: self.gridgen())
-        #mcrfpy.registerPyAction("animtest", lambda: self.createAnimation())
-        #mcrfpy.registerPyAction("animtest2", lambda: self.createAnimation2())
-        mcrfpy.registerPyAction("nextsp", lambda: self.changesprite(1))
-        mcrfpy.registerPyAction("prevsp", lambda: self.changesprite(-1))
-        mcrfpy.registerPyAction("skipsp", lambda: self.changesprite(16))
-        mcrfpy.unlockPlayerInput()
-        mcrfpy.setActiveGrid("demogrid")
-        self.gridgen()
-        self.updatehints()
-        mcrfpy.camFollow(True)
-        
-    def itemguis(self):
-        print(self.player.inventory)
-        items = ["Green Keycard", "Blue Keycard", "Red Keycard", "Orange Keycard", "Devil Keycard"]
-        for mn in range(6, 11):
-            self.menus[mn].visible = items[mn-6] in self.player.inventory
-            mcrfpy.modMenu(self.menus[mn])
-
-    def animate_entity(self, direction, attacking=False):
-        if direction is None:
-            direction = self.entity_direction
-        else:
-            self.entity_direction = direction
-        
-        dragon_sprite = 545 + (32 * (direction + (4 if attacking else 0)))
-        dragon_animation = [dragon_sprite + i for i in range((5 if attacking else 4))]
-        mcrfpy.createAnimation(
-            1.0, # duration, seconds
-            "demogrid", # parent: a UIMenu or Grid key
-            "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-            0, # target id: integer index for menu or grid objs; None for grid/menu
-            "sprite", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-            lambda: self.animation_done("demobox1"), #callback: callable once animation is complete
-            False, #loop: repeat indefinitely
-            dragon_animation # values: iterable of frames for 'sprite', lerp target for others
-        )
-        
-        orc_sprite = 1538 + (64 * (direction + (4 if attacking else 0)))
-        orc_animation = [orc_sprite + i for i in range((5 if attacking else 4))]
-        mcrfpy.createAnimation(
-            1.0, # duration, seconds
-            "demogrid", # parent: a UIMenu or Grid key
-            "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-             1, # target id: integer index for menu or grid objs; None for grid/menu
-             "sprite", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-             lambda: self.animation_done("demobox1"), #callback: callable once animation is complete
-             False, #loop: repeat indefinitely
-             orc_animation # values: iterable of frames for 'sprite', lerp target for others
-        )
-        
-    #def move_entity(self, targetgrid, entity_index, position):
-    #    for i, g in enumerate(self.grids):
-    #        if g.title == targetgrid:
-    #            g.entities[entity_index].x = position[0]
-    #            g.entities[entity_index].y = position[1]
-    #            #pts = g.points
-    #            g.visible = True
-    #            mcrfpy.modGrid(g)
-    #            self.grids = mcrfpy.listGrids()
-    #            #self.grids[i].points = pts
-    #            return
-        
-        
-    def changesprite(self, n):
-        self.sprite_index += n
-        self.menus[0].captions[0].text = f"Sprite #{self.sprite_index}"
-        self.menus[0].sprites[0].sprite_index = self.sprite_index
-        mcrfpy.modMenu(self.menus[0])
-        
-    def click(self):
-        self.clicks += 1
-        self.menus[0].captions[0].text = f"Clicks: {self.clicks}"
-        self.menus[0].sprites[0].sprite_index = randint(0, 3)
-        mcrfpy.modMenu(self.menus[0])
-        
-    def updatehints(self):
-        self.menus[2].captions[0].text=mcrfpy.activeGrid()
-        mcrfpy.modMenu(self.menus[2])
-        
-        self.menus[3].captions[0].text=mcrfpy.inputMode()
-        mcrfpy.modMenu(self.menus[3])
-        #self.menus[4].captions[0].text=f"follow: {mcrfpy.camFollow()}"
-        
-        self.menus[4].captions[0].text="following" if mcrfpy.camFollow() else "free"
-        mcrfpy.modMenu(self.menus[4])
-        
-        self.menus[5].visible = not mcrfpy.camFollow()
-        mcrfpy.modMenu(self.menus[5])
-        
-
-    def gridgen(self):
-        
-        #print(f"[Python] modifying {len(self.grids[0].points)} grid points")
-        for p in self.grids[0].points:
-            #p.color = (randint(0, 255), randint(64, 192), 0)
-            p.color = (0,0,0)
-            p.walkable = False
-            p.transparent = False
-            
-        room_centers = [(randint(0, self.grids[0].grid_x-1), randint(0, self.grids[0].grid_y-1)) for i in range(20)] + [(17, 3), (20,10) + (20,5)]
-        #room_centers.append((3, 5))
-        for r in room_centers:
-            # random hallway
-            target = choice(room_centers)
-            length1 = abs(target[0] - r[0])
-            
-            xbase = min(target[0], r[0])
-            for x in range(length1):
-                gpoint = self.grids[0].at(x, r[1])
-                if gpoint is None: continue
-                gpoint.walkable = True
-                gpoint.transparent = True
-                gpoint.color = (192, 192, 192)
-            
-            length2 = abs(target[1] - r[1])
-            ybase = min(target[1], r[1])
-            for y in range(length2):
-                gpoint = self.grids[0].at(r[0], y)
-                if gpoint is None: continue
-                gpoint.walkable = True
-                gpoint.transparent = True
-                gpoint.color = (192, 192, 192)
-                
-        for r in room_centers:
-            #print(r)
-            room_color = (randint(16, 24)*8, randint(16, 24)*8, randint(16, 24)*8)
-            #self.grids[0].at(r[0], r[1]).walkable = True
-            #self.grids[0].at(r[0], r[1]).color = room_color
-            halfx, halfy = randint(2, 11), randint(2,11)
-            for p_x in range(r[0] - halfx, r[0] + halfx):
-                for p_y in range(r[1] - halfy, r[1] + halfy):
-                    gpoint = self.grids[0].at(p_x, p_y)
-                    if gpoint is None: continue
-                    gpoint.walkable = True
-                    gpoint.transparent = True
-                    gpoint.color = room_color
-            #print()
-                    
-        #print("[Python] Modifying:")
-        self.grids[0].at(10, 10).color = (255, 255, 255)
-        self.grids[0].at(10, 10).walkable = False
-        self.grids[0].visible = True
-        mcrfpy.modGrid(self.grids[0])
-        #self.grids = mcrfpy.listGrids()
-        #print(f"Sent grid: {repr(self.grids[0])}")
-        #print(f"Received grid: {repr(mcrfpy.listGrids()[0])}")
-        
-    def animation_done(self, s):
-        print(f"The `{s}` animation completed.")
-        #self.menus = mcrfpy.listMenus()
-        
-    # if (!PyArg_ParseTuple(args, "fsssiOOO", &duration, &parent, &target_type, &target_id, &field, &callback, &loop_obj, &values_obj)) return NULL;
-    def createAnimation(self):
-        print(self.menus)
-        self.menus = mcrfpy.listMenus()
-        self.menus[0].w = 500
-        self.menus[0].h = 200
-        print(self.menus)
-        mcrfpy.modMenu(self.menus[0])
-        print(self.menus)
-        mcrfpy.createAnimation(
-            3.0, # duration, seconds
-            "demobox1", # parent: a UIMenu or Grid key
-            "menu", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-            0, # target id: integer index for menu or grid objs; None for grid/menu
-            "size", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-            lambda: self.animation_done("demobox1"), #callback: callable once animation is complete
-            False, #loop: repeat indefinitely
-            [150, 100] # values: iterable of frames for 'sprite', lerp target for others
-        )
-        
-    def createAnimation2(self):
-        mcrfpy.createAnimation(
-            5,
-            "demobox1",
-            "sprite",
-            0,
-            "sprite",
-            lambda: self.animation_done("sprite change"),
-            False,
-            [0, 1, 2, 1, 2, 0]
-        )
-
-def keytest():
-    print("Key tested.")
-
-def keyregistration():
-    print("Registering 'keytest'")
-    mcrfpy.registerPyAction("keytest", keytest)
-    print("Registering input")
-    print(mcrfpy.registerInputAction(15, "keytest")) # 15 = P
-    
-    mcrfpy.registerPyAction("player_move_up", lambda: scene.player.move(0, -1))
-    mcrfpy.registerPyAction("player_move_left", lambda: scene.player.move(-1, 0))
-    mcrfpy.registerPyAction("player_move_down", lambda: scene.player.move(0, 1))
-    mcrfpy.registerPyAction("player_move_right", lambda: scene.player.move(1, 0))
-    
-    mcrfpy.registerInputAction(ord('w') - ord('a'), "player_move_up")
-    mcrfpy.registerInputAction(ord('a') - ord('a'), "player_move_left")
-    mcrfpy.registerInputAction(ord('s') - ord('a'), "player_move_down")
-    mcrfpy.registerInputAction(ord('d') - ord('a'), "player_move_right")
-    
-
-def start():
-    global scene
-    #print("TestScene.start called")
-    scene = TestScene()
-    mcrfpy.refreshFov()
-    
-    
-    scene.updatehints()

scripts/UIMenu.py

@@ -1,48 +0,0 @@
-class Caption:
-    def __init__(self, text, textsize, color):
-        self.text = text
-        self.textsize = textsize
-        self.color = color
-
-    def __repr__(self):
-        return f"<Caption text={self.text}, textsize={self.textsize}, color={self.color}>"
-
-class Button:
-    def __init__(self, x, y, w, h, bgcolor, textcolor, text, actioncode):
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.bgcolor = bgcolor
-        self.textcolor = textcolor
-        self.text = text
-        self.actioncode = actioncode
-
-    def __repr__(self):
-        return f"<Button ({self.x}, {self.y}, {self.w}, {self.h}), bgcolor={self.bgcolor}, textcolor={self.textcolor}, actioncode={self.actioncode}>"
-
-class Sprite:
-    def __init__(self, tex_index, sprite_index, x, y):
-        self.tex_index = tex_index
-        self.sprite_index = sprite_index
-        self.x = x
-        self.y = y
-
-    def __repr__(self):
-        return f"<Sprite tex_index={self.tex_index}, self.sprite_index={self.sprite_index}, x={self.x}, y={self.y}>"
-
-class UIMenu:
-    def __init__(self, title, x, y, w, h, bgcolor, visible=False):
-        self.title = title
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.bgcolor = bgcolor
-        self.visible = visible
-        self.captions = []
-        self.buttons = []
-        self.sprites = []
-
-    def __repr__(self):
-        return f"<UIMenu title={repr(self.title)}, x={self.x}, y={self.y}, w={self.w}, h={self.h}, bgcolor={self.bgcolor}, visible={self.visible}, {len(self.captions)} captions, {len(self.buttons)} buttons, {len(self.sprites)} sprites>"

scripts/engine_user.py

@@ -1,10 +0,0 @@
-print("[Python] Attempting import")
-import scriptable
-
-print(f"[Python] calling fibonacci(8): {scriptable.fibonacci(8)}")
-print(f"[Python] calling fibonacci(15): {scriptable.fibonacci(15)}")
-
-import venv
-print("[Python] Importing library installed with pip")
-import numpy
-

scripts/test_ui.py

@@ -1,37 +0,0 @@
-import mcrfpy
-mcrfpy.createTexture("./assets/test_portraits.png", 32, 8, 8)
-from random import choice, randint
-
-box_colors = [
-	(0, 0, 192),
-	(0, 192, 0),
-	(192, 0, 0),
-	(192, 192, 0),
-	(0, 192, 192),
-	(192, 0, 192)
-	]
-
-text_colors = [
-	(0, 0, 255),
-	(0, 255, 0),
-	(255, 0, 0),
-	(255, 255, 0),
-	(0, 255, 255),
-	(255, 0, 255)
-	]
-
-test_x = 500
-test_y = 10
-for i in range(40):
-	ui_name = f"test{i}"
-	mcrfpy.createMenu(ui_name, test_x, test_y, 400, 200)
-	mcrfpy.createCaption(ui_name, "Hello There", 18, choice(text_colors))
-	mcrfpy.createButton(ui_name, 250, 20, 100, 50, choice(box_colors), (0, 0, 0), "asdf", "testaction")
-	
-	mcrfpy.createSprite(ui_name, 0, randint(0, 3), 650, 60, 5.0)
-
-	test_x -= 50
-	test_y += 50
-	if (test_x <= 50):
-		test_x = 500
-	#print(test_x)

src/ActionCode.h

@@ -31,4 +31,116 @@ public:
         if (a & WHEEL_NEG) factor = -1;
         return (a & WHEEL_DEL) * factor;
     }
+
+    static std::string key_str(sf::Keyboard::Key& keycode)
+    {
+        switch(keycode)
+        {
+            case sf::Keyboard::Key::Unknown: return "Unknown"; break;
+            case sf::Keyboard::Key::A: return "A"; break;
+            case sf::Keyboard::Key::B: return "B"; break;
+            case sf::Keyboard::Key::C: return "C"; break;
+            case sf::Keyboard::Key::D: return "D"; break;
+            case sf::Keyboard::Key::E: return "E"; break;
+            case sf::Keyboard::Key::F: return "F"; break;
+            case sf::Keyboard::Key::G: return "G"; break;
+            case sf::Keyboard::Key::H: return "H"; break;
+            case sf::Keyboard::Key::I: return "I"; break;
+            case sf::Keyboard::Key::J: return "J"; break;
+            case sf::Keyboard::Key::K: return "K"; break;
+            case sf::Keyboard::Key::L: return "L"; break;
+            case sf::Keyboard::Key::M: return "M"; break;
+            case sf::Keyboard::Key::N: return "N"; break;
+            case sf::Keyboard::Key::O: return "O"; break;
+            case sf::Keyboard::Key::P: return "P"; break;
+            case sf::Keyboard::Key::Q: return "Q"; break;
+            case sf::Keyboard::Key::R: return "R"; break;
+            case sf::Keyboard::Key::S: return "S"; break;
+            case sf::Keyboard::Key::T: return "T"; break;
+            case sf::Keyboard::Key::U: return "U"; break;
+            case sf::Keyboard::Key::V: return "V"; break;
+            case sf::Keyboard::Key::W: return "W"; break;
+            case sf::Keyboard::Key::X: return "X"; break;
+            case sf::Keyboard::Key::Y: return "Y"; break;
+            case sf::Keyboard::Key::Z: return "Z"; break;
+            case sf::Keyboard::Key::Num0: return "Num0"; break;
+            case sf::Keyboard::Key::Num1: return "Num1"; break;
+            case sf::Keyboard::Key::Num2: return "Num2"; break;
+            case sf::Keyboard::Key::Num3: return "Num3"; break;
+            case sf::Keyboard::Key::Num4: return "Num4"; break;
+            case sf::Keyboard::Key::Num5: return "Num5"; break;
+            case sf::Keyboard::Key::Num6: return "Num6"; break;
+            case sf::Keyboard::Key::Num7: return "Num7"; break;
+            case sf::Keyboard::Key::Num8: return "Num8"; break;
+            case sf::Keyboard::Key::Num9: return "Num9"; break;
+            case sf::Keyboard::Key::Escape: return "Escape"; break;
+            case sf::Keyboard::Key::LControl: return "LControl"; break;
+            case sf::Keyboard::Key::LShift: return "LShift"; break;
+            case sf::Keyboard::Key::LAlt: return "LAlt"; break;
+            case sf::Keyboard::Key::LSystem: return "LSystem"; break;
+            case sf::Keyboard::Key::RControl: return "RControl"; break;
+            case sf::Keyboard::Key::RShift: return "RShift"; break;
+            case sf::Keyboard::Key::RAlt: return "RAlt"; break;
+            case sf::Keyboard::Key::RSystem: return "RSystem"; break;
+            case sf::Keyboard::Key::Menu: return "Menu"; break;
+            case sf::Keyboard::Key::LBracket: return "LBracket"; break;
+            case sf::Keyboard::Key::RBracket: return "RBracket"; break;
+            case sf::Keyboard::Key::Semicolon: return "Semicolon"; break;
+            case sf::Keyboard::Key::Comma: return "Comma"; break;
+            case sf::Keyboard::Key::Period: return "Period"; break;
+            case sf::Keyboard::Key::Apostrophe: return "Apostrophe"; break;
+            case sf::Keyboard::Key::Slash: return "Slash"; break;
+            case sf::Keyboard::Key::Backslash: return "Backslash"; break;
+            case sf::Keyboard::Key::Grave: return "Grave"; break;
+            case sf::Keyboard::Key::Equal: return "Equal"; break;
+            case sf::Keyboard::Key::Hyphen: return "Hyphen"; break;
+            case sf::Keyboard::Key::Space: return "Space"; break;
+            case sf::Keyboard::Key::Enter: return "Enter"; break;
+            case sf::Keyboard::Key::Backspace: return "Backspace"; break;
+            case sf::Keyboard::Key::Tab: return "Tab"; break;
+            case sf::Keyboard::Key::PageUp: return "PageUp"; break;
+            case sf::Keyboard::Key::PageDown: return "PageDown"; break;
+            case sf::Keyboard::Key::End: return "End"; break;
+            case sf::Keyboard::Key::Home: return "Home"; break;
+            case sf::Keyboard::Key::Insert: return "Insert"; break;
+            case sf::Keyboard::Key::Delete: return "Delete"; break;
+            case sf::Keyboard::Key::Add: return "Add"; break;
+            case sf::Keyboard::Key::Subtract: return "Subtract"; break;
+            case sf::Keyboard::Key::Multiply: return "Multiply"; break;
+            case sf::Keyboard::Key::Divide: return "Divide"; break;
+            case sf::Keyboard::Key::Left: return "Left"; break;
+            case sf::Keyboard::Key::Right: return "Right"; break;
+            case sf::Keyboard::Key::Up: return "Up"; break;
+            case sf::Keyboard::Key::Down: return "Down"; break;
+            case sf::Keyboard::Key::Numpad0: return "Numpad0"; break;
+            case sf::Keyboard::Key::Numpad1: return "Numpad1"; break;
+            case sf::Keyboard::Key::Numpad2: return "Numpad2"; break;
+            case sf::Keyboard::Key::Numpad3: return "Numpad3"; break;
+            case sf::Keyboard::Key::Numpad4: return "Numpad4"; break;
+            case sf::Keyboard::Key::Numpad5: return "Numpad5"; break;
+            case sf::Keyboard::Key::Numpad6: return "Numpad6"; break;
+            case sf::Keyboard::Key::Numpad7: return "Numpad7"; break;
+            case sf::Keyboard::Key::Numpad8: return "Numpad8"; break;
+            case sf::Keyboard::Key::Numpad9: return "Numpad9"; break;
+            case sf::Keyboard::Key::F1: return "F1"; break;
+            case sf::Keyboard::Key::F2: return "F2"; break;
+            case sf::Keyboard::Key::F3: return "F3"; break;
+            case sf::Keyboard::Key::F4: return "F4"; break;
+            case sf::Keyboard::Key::F5: return "F5"; break;
+            case sf::Keyboard::Key::F6: return "F6"; break;
+            case sf::Keyboard::Key::F7: return "F7"; break;
+            case sf::Keyboard::Key::F8: return "F8"; break;
+            case sf::Keyboard::Key::F9: return "F9"; break;
+            case sf::Keyboard::Key::F10: return "F10"; break;
+            case sf::Keyboard::Key::F11: return "F11"; break;
+            case sf::Keyboard::Key::F12: return "F12"; break;
+            case sf::Keyboard::Key::F13: return "F13"; break;
+            case sf::Keyboard::Key::F14: return "F14"; break;
+            case sf::Keyboard::Key::F15: return "F15"; break;
+            case sf::Keyboard::Key::Pause: return "Pause"; break;
+        default:
+            return "Any";
+            break;
+        }
+    }
 };

src/Animation.cpp

@@ -1,124 +0,0 @@
-#include "Animation.h"
-
-Animation::Animation(float _d, std::function<void()> _cb, bool _l)
-:duration(_d), callback(_cb), loop(_l), elapsed(0.0f) {}
-
-// linear interpolation constructor
-template<typename T>
-LerpAnimation<T>::LerpAnimation(float _d, T _ev, T _sv, std::function<void()> _cb, std::function<void(T)> _w, bool _l)
-:Animation(_d, _cb, _l), //duration(_d), target(_t), callback(_cb), loop(_l),elapsed(0.0f),
-startvalue(_sv), endvalue(_ev), write(_w) {}
-
-// discrete values constructor
-template<typename T>
-DiscreteAnimation<T>::DiscreteAnimation(float _d, std::vector<T> _v, std::function<void()> _cb, std::function<void(T)> _w, bool _l)
-:Animation(_d, _cb, _l), //duration(_d), target(_t), callback(_cb), loop(_l), elapsed(0.0f),
-index(0), nonelapsed(0.0f), values(_v), write(_w) {
-    timestep = _d / _v.size();
-}
-
-/* // don't call virtual functions (like cancel()) from base class destructor
- * // child classes destructors' are called first anyway
-Animation::~Animation() {
-    // deconstructor sets target to desired end state (no partial values)
-    cancel();
-}
-*/
-
-template<>
-void LerpAnimation<std::string>::lerp() {
-    //*(std::string*)target = ;
-    write(endvalue.substr(0, endvalue.length() * (elapsed / duration)));
-}
-
-template<>
-void LerpAnimation<int>::lerp() {
-    int delta = endvalue - startvalue;
-    //*(int*)target = ;
-    write(startvalue + (elapsed / duration * delta));
-}
-
-template<>
-void LerpAnimation<float>::lerp() {
-    int delta = endvalue - startvalue;
-    //*(float*)target = ;
-    write(startvalue + (elapsed / duration * delta));
-}
-
-template<>
-void LerpAnimation<sf::Vector2f>::lerp() {
-    //std::cout << "sf::Vector2f implementation of lerp." << std::endl;
-    int delta_x = endvalue.x - startvalue.x;
-    int delta_y = endvalue.y - startvalue.y;
-    //std::cout << "Start: " << startvalue.x << ", " << startvalue.y << "; End: " << endvalue.x << ", " << endvalue.y << std::endl;
-    //std::cout << "Delta: " << delta_x << ", " << delta_y << std::endl;
-    //((sf::Vector2f*)target)->x = startvalue.x + (elapsed / duration * delta_x);
-    //((sf::Vector2f*)target)->y = startvalue.y + (elapsed / duration * delta_y);
-    write(sf::Vector2f(startvalue.x + (elapsed / duration * delta_x), 
-                       startvalue.y + (elapsed / duration * delta_y)));
-}
-
-template<>
-void LerpAnimation<sf::Vector2i>::lerp() {
-    int delta_x = endvalue.x - startvalue.y;
-    int delta_y = endvalue.y - startvalue.y;
-    //((sf::Vector2i*)target)->x = startvalue.x + (elapsed / duration * delta_x);
-    //((sf::Vector2i*)target)->y = startvalue.y + (elapsed / duration * delta_y);
-    write(sf::Vector2i(startvalue.x + (elapsed / duration * delta_x), 
-                       startvalue.y + (elapsed / duration * delta_y)));
-}
-
-template<typename T>
-void LerpAnimation<T>::step(float delta) {
-	if (complete) return;
-    elapsed += delta;
-    //std::cout << "LerpAnimation step function. Elapsed: " << elapsed <<std::endl;
-    lerp();
-    if (isDone()) { callback(); complete = true; cancel(); }; //use the exact value, not my math
-}
-
-template<typename T>
-void DiscreteAnimation<T>::step(float delta)
-{
-	if (complete) return;
-    nonelapsed += delta;
-    //std::cout << "Nonelapsed: " << nonelapsed << " elapsed (pre-add): " << elapsed << " timestep: " << timestep << " duration: " << duration << " index: " << index << std::endl;
-    if (nonelapsed < timestep) return;
-    //std::cout << "values size: " << values.size() << " isDone(): " << isDone() << std::endl;
-    if (elapsed > duration && !complete) {callback(); complete = true; return; }
-    elapsed += nonelapsed; // or should it be += timestep?
-    if (index == values.size() - 1) return;
-    nonelapsed = 0; // or should it -= timestep?
-    index++;
-    //*(T*)target = values[index];
-    write(values[index]);
-}
-
-template<typename T>
-void LerpAnimation<T>::cancel() {
-    //*(T*)target = endvalue;
-    write(endvalue);
-}
-
-template<typename T>
-void DiscreteAnimation<T>::cancel() {
-    //*(T*)target = values[values.size() - 1];
-    write(values[values.size() - 1]);
-}
-
-bool Animation::isDone() {
-    return elapsed + Animation::EPSILON >= duration;
-}
-
-namespace animation_template_implementations {
-    // instantiate to compile concrete templates
-    //LerpAnimation<sf::Vector2f> implement_vector2f;
-
-    auto implement_v2f_const = LerpAnimation<sf::Vector2<float>>(4.0, sf::Vector2<float>(), sf::Vector2f(1,1), [](){}, [](sf::Vector2f v){}, false);
-    auto implement_disc_i = DiscreteAnimation<int>(3.0, std::vector<int>{0},[](){},[](int){},false);
-    //LerpAnimation<sf::Vector2i> implement_vector2i;
-    //LerpAnimation<int> implment_int;
-    //LerpAnimation<std::string> implment_string;
-    //LerpAnimation<float> implement_float;
-    //DiscreteAnimation<int> implement_int_discrete;
-}

src/Animation.h

@@ -1,50 +0,0 @@
-#pragma once
-#include "Common.h"
-#include <functional>
-
-class Animation
-{
-protected:
-    static constexpr float EPSILON = 0.05;
-    float duration, elapsed;
-    std::function<void()> callback;
-    bool loop;
-	bool complete=false;
-public:
-    //Animation(float, T, T*, std::function<void()>, bool); // lerp
-    //Animation(float, std::vector<T>, T*, std::function<void()>, bool); // discrete 
-    Animation(float, std::function<void()>, bool);
-    //Animation() {};
-    virtual void step(float) = 0;
-    virtual void cancel() = 0;
-    bool isDone();
-};
-
-template<typename T>
-class LerpAnimation: public Animation
-{
-    T startvalue, endvalue;
-    std::function<void(T)> write;
-    void lerp();
-public:
-    ~LerpAnimation() { cancel(); }
-    LerpAnimation(float, T, T, std::function<void()>, std::function<void(T)>, bool);
-    //LerpAnimation() {};
-    void step(float) override final;
-    void cancel() override final;
-};
-
-template<typename T>
-class DiscreteAnimation: public Animation
-{
-    std::vector<T> values;
-    std::function<void(T)> write;
-    float nonelapsed, timestep;
-    int index;
-public:
-    DiscreteAnimation(float, std::vector<T>, std::function<void()>, std::function<void(T)>, bool);
-    DiscreteAnimation() {};
-    ~DiscreteAnimation() { cancel(); }
-    void step(float) override final;
-    void cancel() override final;
-};

src/Button.cpp

@@ -1,24 +0,0 @@
-#include "Button.h"
-
-void Button::render(sf::RenderWindow & window)
-{
-    window.draw(rect);
-    window.draw(caption);
-}
-
-Button::Button(int x, int y, int w, int h,
-        sf::Color _background, sf::Color _textcolor,
-        const char * _caption, sf::Font & font,
-        const char * _action)
-{
-    rect.setPosition(sf::Vector2f(x, y));
-    rect.setSize(sf::Vector2f(w, h));
-    rect.setFillColor(_background);
-
-    caption.setFillColor(_textcolor);
-    caption.setPosition(sf::Vector2f(x, y));
-    caption.setString(_caption);
-    caption.setFont(font);
-
-    action = _action;
-}

src/Button.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include "Common.h"
-
-class Button
-{
-
-protected:
-
-public:
-    // TODO / JankMode: setter & getter for these three fields
-    // were protected, but directly changing them should be...fine?
-    sf::RectangleShape rect;
-    sf::Text caption;
-    std::string action;
-
-    Button() {};
-    Button(int x, int y, int w, int h,
-        sf::Color _background, sf::Color _textcolor,
-        const char * _caption, sf::Font & font,
-        const char * _action);
-    void setPosition(sf::Vector2f v) { rect.setPosition(v); caption.setPosition(v); }
-    void setSize(sf::Vector2f & v) { rect.setSize(v); }
-    void setBackground(sf::Color c) { rect.setFillColor(c); }
-    void setCaption(std::string & s) { caption.setString(s); }
-    void setTextColor(sf::Color c) { caption.setFillColor(c); }
-    void render(sf::RenderWindow & window);
-    auto contains(sf::Vector2i p) { return rect.getGlobalBounds().contains(p.x, p.y); }
-    auto contains(sf::Vector2f rel, sf::Vector2i p) { 
-		return rect.getGlobalBounds().contains(p.x - rel.x, p.y - rel.y);
-	}
-    auto getAction() { return action; }
-
-private:
-};

src/Components.h

@@ -1,138 +0,0 @@
-#pragma once
-
-#include "Common.h"
-#include "IndexSprite.h"
-#include "Grid.h"
-//#include "Item.h"
-#include "Python.h"
-#include <list>
-
-class CGrid
-{
-public:
-	bool visible;
-	int x, y;
-	IndexSprite indexsprite;
-	Grid* grid;
-	CGrid(Grid* _g, int _ti, int _si, int _x, int _y, bool _v)
-	: visible(_v), x(_x), y(_y), grid(_g), indexsprite(_ti, _si, _x, _y, 1.0) {}
-};
-
-class CInventory
-{
-public:
-	//std::list<std::shared_ptr<Item>>;
-	int x;
-};
-
-class CBehavior
-{
-public:
-	PyObject* object;
-	CBehavior(PyObject* p): object(p) {}
-};
-
-/*
-class CCombatant
-{
-public:
-	int hp;
-	int maxhp; 
-}
-
-class CCaster
-{
-public:
-	int mp;
-	int maxmp;
-}
-
-class CLevel
-{
-	int constitution; // +HP, resist effects
-	int strength; // +damage, block/parry
-	int dexterity; // +speed, dodge
-	int intelligence; // +MP, spell resist
-	int wisdom; // +damage, deflect
-	int luck; // crit, loot
-}
-*/
-
-
-/*
-class CTransform
-{
-public:
-    Vec2 pos = { 0.0, 0.0 };
-    Vec2 velocity = { 0.0, 0.0 };
-    float angle = 0;
-
-    CTransform(const Vec2 & p, const Vec2 & v, float a)
-        : pos(p), velocity(v), angle(a) {}
-};
-*/
-
-/*
-class CShape
-{
-public:
-    sf::CircleShape circle;
-
-    CShape(float radius, int points, const sf::Color & fill, const sf::Color & outline, float thickness)
-        : circle(radius, points)
-    {
-        circle.setFillColor(fill);
-        circle.setOutlineColor(outline);
-        circle.setOutlineThickness(thickness);
-        circle.setOrigin(radius, radius);
-    }
-};
-
-class CCollision
-{
-public:
-    float radius = 0;
-    CCollision(float r)
-        : radius(r) {}
-};
-
-class CScore
-{
-public:
-    int score = 0;
-    CScore(int s)
-        : score(s) {}
-};
-
-class CLifespan
-{
-public:
-    int remaining = 0;
-    int total = 0;
-    CLifespan(int t)
-        : remaining(t), total(t) {}
-};
-
-class CInput
-{
-public:
-    bool up = false;
-    bool left = false;
-    bool right = false;
-    bool down = false;
-    bool fire = false;
-
-    CInput() {}
-};
-
-class CSteer
-{
-public:
-    sf::Vector2f position;
-    sf::Vector2f velocity;
-    float v_max;
-    float dv_max;
-    float theta_max;
-    float dtheta_max;
-};
-*/

src/Entity.cpp

@@ -1,25 +0,0 @@
-#include "Entity.h"
-
-Entity::Entity(const size_t i, const std::string & t)
-    : m_id(i), m_tag(t) {}
-
-bool Entity::isActive() const
-{
-    return m_active;
-}
-
-const std::string & Entity::tag() const
-{
-    return m_tag;
-}
-
-const size_t Entity::id() const
-{
-    return m_id;
-}
-
-void Entity::destroy()
-{
-    m_active = false;
-}
-

src/Entity.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include "Common.h"
-
-#include "Components.h"
-
-class Entity
-{
-    friend class EntityManager;
-
-    bool m_active = true;
-    size_t m_id = 0;
-    std::string m_tag = "default";
-
-    //constructor and destructor
-    Entity(const size_t id, const std::string & t);
-
-public:
-    // component pointers
-    //std::shared_ptr<CTransform> cTransform;
-    //std::shared_ptr<CShape> cShape;
-    //std::shared_ptr<CCollision> cCollision;
-    //std::shared_ptr<CInput> cInput;
-    //std::shared_ptr<CScore> cScore;
-    //std::shared_ptr<CLifespan> cLifespan;
-    std::shared_ptr<CGrid> cGrid;
-    std::shared_ptr<CInventory> cInventory;
-    std::shared_ptr<CBehavior> cBehavior;
-
-    //private member access functions
-    bool isActive() const;
-    const std::string & tag() const;
-    const size_t id() const;
-    void destroy();
-};

src/EntityManager.cpp

@@ -1,73 +0,0 @@
-#include "EntityManager.h"
-
-EntityManager::EntityManager()
-    :m_totalEntities(0) {}
-
-void EntityManager::update()
-{
-    //TODO: add entities from m_entitiesToAdd to all vector / tag map
-    removeDeadEntities(m_entities);
-
-    // C++17 way of iterating!
-    for (auto& [tag, entityVec] : m_entityMap)
-    {
-        removeDeadEntities(entityVec);
-    }
-
-    for (auto& e : m_entitiesToAdd)
-    {
-        m_entities.push_back(e);
-        m_entityMap[e->tag()].push_back(e);
-    }
-    //if (m_entitiesToAdd.size())
-    //    m_entitiesToAdd.erase(m_entitiesToAdd.begin(), m_entitiesToAdd.end());
-    m_entitiesToAdd = EntityVec();
-    
-}
-
-void EntityManager::removeDeadEntities(EntityVec & vec)
-{
-    EntityVec survivors; // New vector
-    for (auto& e : m_entities){
-        if (e->isActive()) survivors.push_back(e); // populate new vector
-        else if (e->cGrid) { // erase vector from grid
-			for( auto it = e->cGrid->grid->entities.begin(); it != e->cGrid->grid->entities.end(); it++){
-				if( *it == e ){
-					e->cGrid->grid->entities.erase( it );
-					break;
-				}
-			}
-		}
-    }
-    //std::cout << "All entities: " << m_entities.size() << " Survivors: " << survivors.size() << std::endl;
-    m_entities = survivors; // point to new vector
-    for (auto& [tag, entityVec] : m_entityMap)
-    {
-        EntityVec tag_survivors; // New vector
-        for (auto& e : m_entityMap[tag])
-        {
-            if (e->isActive()) tag_survivors.push_back(e); // populate new vector
-        }
-        m_entityMap[tag] = tag_survivors; // point to new vector
-    //std::cout << tag << " entities: " << m_entityMap[tag].size() << " Survivors: " << tag_survivors.size() << std::endl;
-    }
-}
-
-std::shared_ptr<Entity> EntityManager::addEntity(const std::string & tag)
-{
-    // create the entity shared pointer
-    auto entity = std::shared_ptr<Entity>(new Entity(m_totalEntities++, tag));
-    m_entitiesToAdd.push_back(entity);
-    return entity;
-}
-
-const EntityVec & EntityManager::getEntities()
-{
-    return m_entities;
-}
-
-const EntityVec & EntityManager::getEntities(const std::string & tag)
-{
-    return m_entityMap[tag];
-}
-

src/EntityManager.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include "Common.h"
-#include "Entity.h"
-
-typedef std::vector<std::shared_ptr<Entity>> EntityVec;
-typedef std::map<std::string, EntityVec> EntityMap;
-
-class EntityManager
-{
-    EntityVec m_entities;
-    EntityVec m_entitiesToAdd;
-    EntityMap m_entityMap;
-    size_t m_totalEntities;
-
-    void removeDeadEntities(EntityVec & vec);
-
-public:
-    EntityManager();
-    void update();
-    std::shared_ptr<Entity> addEntity(const std::string & tag);
-    const EntityVec & getEntities();
-    const EntityVec & getEntities(const std::string & tag);
-};
-

src/GameEngine.cpp

@@ -1,9 +1,7 @@
 #include "GameEngine.h"
-#include "MenuScene.h"
-//#include "UITestScene.h"
 #include "ActionCode.h"
 #include "McRFPy_API.h"
-#include "PythonScene.h"
+#include "PyScene.h"
 #include "UITestScene.h"
 #include "Resources.h"
 
@@ -11,39 +9,44 @@ GameEngine::GameEngine()
 {
     Resources::font.loadFromFile("./assets/JetbrainsMono.ttf");
     Resources::game = this;
-    window_title = "McRogueFace - r/RoguelikeDev Tutorial Run";
-    window.create(sf::VideoMode(1024, 768), window_title);
+    window_title = "McRogueFace - 7DRL 2024 Engine Demo";
+    window.create(sf::VideoMode(1024, 768), window_title, sf::Style::Titlebar | sf::Style::Close);
     visible = window.getDefaultView();
     window.setFramerateLimit(30);
     scene = "uitest";
-    //std::cout << "Constructing MenuScene" << std::endl;
-    scenes["menu"] = new MenuScene(this);
     scenes["uitest"] = new UITestScene(this);
-
-    //std::cout << "Constructed MenuScene" <<std::endl;
-    //scenes["play"] = new UITestScene(this);
-    //api = new McRFPy_API(this);
     
     McRFPy_API::game = this;
     McRFPy_API::api_init();
     McRFPy_API::executePyString("import mcrfpy");
-    //McRFPy_API::executePyString("from UIMenu import *");
-    //McRFPy_API::executePyString("from Grid import *");
-
-    //scenes["py"] = new PythonScene(this, "TestScene");
-
-    IndexSprite::game = this;
+    McRFPy_API::executeScript("scripts/game.py");
 
     clock.restart();
+    runtime.restart();
 }
 
 Scene* GameEngine::currentScene() { return scenes[scene]; }
-void GameEngine::changeScene(std::string s) { std::cout << "Current scene is now '" << s << "'\n"; scene = s; }
+void GameEngine::changeScene(std::string s)
+{
+    /*std::cout << "Current scene is now '" << s << "'\n";*/
+    if (scenes.find(s) != scenes.end())
+        scene = s;
+    else
+        std::cout << "Attempted to change to a scene that doesn't exist (`" << s << "`)" << std::endl;
+}
 void GameEngine::quit() { running = false; }
 void GameEngine::setPause(bool p) { paused = p; }
 sf::Font & GameEngine::getFont() { /*return font; */ return Resources::font; }
 sf::RenderWindow & GameEngine::getWindow() { return window; }
 
+void GameEngine::createScene(std::string s) { scenes[s] = new PyScene(this); }
+
+void GameEngine::setWindowScale(float multiplier)
+{
+    window.setSize(sf::Vector2u(1024 * multiplier, 768 * multiplier)); // 7DRL 2024: window scaling
+    //window.create(sf::VideoMode(1024 * multiplier, 768 * multiplier), window_title, sf::Style::Titlebar | sf::Style::Close);
+}
+
 void GameEngine::run()
 {
     float fps = 0.0;
@@ -51,11 +54,12 @@ void GameEngine::run()
     while (running)
     {
         currentScene()->update();
+        testTimers();
         sUserInput();
         if (!paused)
         {
         }
-        currentScene()->sRender();
+        currentScene()->render();
         currentFrame++;
         frameTime = clock.restart().asSeconds();
         fps = 1 / frameTime;
@@ -63,6 +67,44 @@ void GameEngine::run()
     }
 }
 
+void GameEngine::manageTimer(std::string name, PyObject* target, int interval)
+{
+    auto it = timers.find(name);
+    if (it != timers.end()) // overwrite existing
+    {
+        if (target == NULL || target == Py_None)
+        {
+            // Delete: Overwrite existing timer with one that calls None. This will be deleted in the next timer check
+            // see gitea issue #4: this allows for a timer to be deleted during its own call to itself
+            timers[name] = std::make_shared<PyTimerCallable>(Py_None, 1000, runtime.getElapsedTime().asMilliseconds());
+            return;
+        }
+    }
+    if (target == NULL || target == Py_None)
+    {
+        std::cout << "Refusing to initialize timer to None. It's not an error, it's just pointless." << std::endl;
+        return;
+    }
+    timers[name] = std::make_shared<PyTimerCallable>(target, interval, runtime.getElapsedTime().asMilliseconds());
+}
+
+void GameEngine::testTimers()
+{
+    int now = runtime.getElapsedTime().asMilliseconds();
+    auto it = timers.begin();
+    while (it != timers.end())
+    {
+        it->second->test(now);
+        
+        if (it->second->isNone())
+        {
+            it = timers.erase(it);
+        }
+        else
+            it++;
+    }
+}
+
 void GameEngine::sUserInput()
 {
     sf::Event event;
@@ -72,12 +114,20 @@ void GameEngine::sUserInput()
         int actionCode = 0;
 
         if (event.type == sf::Event::Closed) { running = false; continue; }
+        // TODO: add resize event to Scene to react; call it after constructor too, maybe
         else if (event.type == sf::Event::Resized) {
+            continue; // 7DRL short circuit. Resizing manually disabled
+            /*
             sf::FloatRect area(0.f, 0.f, event.size.width, event.size.height);
+            //sf::FloatRect area(0.f, 0.f, 1024.f, 768.f); // 7DRL 2024: attempt to set scale appropriately
+            //sf::FloatRect area(0.f, 0.f, event.size.width, event.size.width * 0.75);
             visible = sf::View(area);
             window.setView(visible);
-            //std::cout << "Visible area set to (0, 0, " << event.size.width << ", " << event.size.height <<")"<<std::endl;
+            //window.setSize(sf::Vector2u(event.size.width, event.size.width * 0.75)); // 7DRL 2024: window scaling
+            std::cout << "Visible area set to (0, 0, " << event.size.width << ", " << event.size.height <<")"<<std::endl;
             actionType = "resize";
+            //window.setSize(sf::Vector2u(event.size.width, event.size.width * 0.75)); // 7DRL 2024: window scaling
+            */
         }
 
         else if (event.type == sf::Event::KeyPressed || event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseWheelScrolled) actionType = "start";
@@ -114,6 +164,23 @@ void GameEngine::sUserInput()
             std::string name = currentScene()->action(actionCode);
             currentScene()->doAction(name, actionType);
         }
+        else if (currentScene()->key_callable)
+        {
+            currentScene()->key_callable->call(ActionCode::key_str(event.key.code), actionType);
+            /*
+            PyObject* args = Py_BuildValue("(ss)", ActionCode::key_str(event.key.code).c_str(), actionType.c_str());
+            PyObject* retval = PyObject_Call(currentScene()->key_callable, args, NULL);
+            if (!retval)
+            {   
+                std::cout << "key_callable has raised an exception. It's going to STDERR and being dropped:" << std::endl;
+                PyErr_Print();
+                PyErr_Clear();
+            } else if (retval != Py_None)
+            {   
+                std::cout << "key_callable returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+            }
+            */
+        }
         else
         {
             //std::cout << "[GameEngine] Action not registered for input: " << actionCode << ": " << actionType << std::endl;

src/GameEngine.h

@@ -1,17 +1,16 @@
 #pragma once
 
 #include "Common.h"
-#include "Entity.h"
-#include "EntityManager.h"
 #include "Scene.h"
 #include "McRFPy_API.h"
 #include "IndexTexture.h"
+#include "Timer.h"
+#include "PyCallable.h"
 
 class GameEngine
 {
     sf::RenderWindow window;
     sf::Font font;
-    std::string scene;
     std::map<std::string, Scene*> scenes;
     bool running = true;
     bool paused = false;
@@ -21,10 +20,17 @@ class GameEngine
     float frameTime;
     std::string window_title;
 
+    sf::Clock runtime;
+    //std::map<std::string, Timer> timers;
+    std::map<std::string, std::shared_ptr<PyTimerCallable>> timers;
+    void testTimers();
+
 public:
+    std::string scene;
     GameEngine();
     Scene* currentScene();
     void changeScene(std::string);
+    void createScene(std::string);
     void quit();
     void setPause(bool);
     sf::Font & getFont();
@@ -34,6 +40,8 @@ public:
     int getFrame() { return currentFrame; }
     float getFrameTime() { return frameTime; }
     sf::View getView() { return visible; }
+    void manageTimer(std::string, PyObject*, int);
+    void setWindowScale(float);
 
     // global textures for scripts to access
     std::vector<IndexTexture> textures;

src/Grid.cpp

@@ -1,340 +0,0 @@
-#include "Grid.h"
-#include <cmath>
-#include "Entity.h"
-
-GridPoint::GridPoint():
-    color(0, 0, 0, 0), walkable(false), tilesprite(-1), transparent(false), visible(false), discovered(false), color_overlay(0,0,0,255), tile_overlay(-1), uisprite(-1)
-{};
-
-void Grid::setSprite(int ti)
-{
-        int tx = ti % texture_width, ty = ti / texture_width;
-            sprite.setTextureRect(sf::IntRect(tx * grid_size, ty * grid_size, grid_size, grid_size));
-}
-
-Grid::Grid(int gx, int gy, int gs, int _x, int _y, int _w, int _h):
-    grid_size(gs),
-    grid_x(gx), grid_y(gy), 
-    zoom(1.0f), center_x((gx/2) * gs), center_y((gy/2) * gs),
-    texture_width(12), texture_height(11), visible(false)
-{
-    //grid_size = gs;
-    //zoom = 1.0f;
-    //grid_x = gx;
-    //grid_y = gy;
-    tcodmap = new TCODMap(gx, gy);
-    points.resize(gx*gy);
-    box.setSize(sf::Vector2f(_w, _h));
-    box.setPosition(sf::Vector2f(_x, _y));
-    box.setFillColor(sf::Color(0,0,0,0));
-
-    renderTexture.create(_w, _h);
-
-    texture.loadFromFile("./assets/kenney_tinydungeon.png");
-    texture.setSmooth(false);
-    sprite.setTexture(texture);
-
-    //output.setSize(box.getSize());
-    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());
-
-    // Show one texture at a time
-    sprite.setTexture(texture);
-}
-
-void Grid::refreshTCODmap() {
-	//int total = 0, walkable = 0, transparent = 0;
-	for (int x = 0; x < grid_x; x++) {
-		for (int y = 0; y < grid_y; y++) {
-			auto p = at(x, y);
-			//total++; if (p.walkable) walkable++; if (p.transparent) transparent++;
-			tcodmap->setProperties(x, y, p.transparent, p.walkable);
-		}
-	}
-	//std::cout << "Map refreshed: " << total << " squares, " << walkable << "walkable, " << transparent << " transparent" << std::endl;
-}
-void Grid::refreshTCODsight(int x, int y) {
-	tcodmap->computeFov(x,y, 0, true, FOV_PERMISSIVE_8);
-	for (int x = 0; x < grid_x; x++) {
-		for (int y = 0; y < grid_y; y++) {
-			auto& p = at(x, y);
-			if (p.visible && !tcodmap->isInFov(x, y)) {
-				p.discovered = true;
-				p.visible = false;
-			} else if (!p.visible && tcodmap->isInFov(x,y)) {
-				p.discovered = true;
-				p.visible = true;
-			}
-		}
-	}
-}
-
-bool Grid::inBounds(int x, int y) {
-    return (x >= 0 && y >= 0 && x < grid_x && y < grid_y);
-}
-
-void Grid::screenToGrid(int sx, int sy, int& gx, int& gy) {
-
-    float center_x_sq = center_x / grid_size;
-    float center_y_sq = center_y / grid_size;
-
-    float width_sq = box.getSize().x / (grid_size * zoom);
-    float height_sq = box.getSize().y / (grid_size * zoom);
-    float left_edge = center_x_sq - (width_sq / 2.0);
-    float right_edge = center_x_sq + (width_sq / 2.0);
-    float top_edge = center_y_sq - (height_sq / 2.0);
-    float bottom_edge = center_y_sq + (height_sq / 2.0);
-
-    float grid_px = zoom * grid_size;
-    //std::cout <<  "##############################" << 
-    //    "\nscreen coord: (" << sx << ", " << sy << ")" << std::endl;
-
-    sx -= box.getPosition().x;
-    sy -= box.getPosition().y;
-
-    //std::cout << "box coord: (" << sx << ", " << sy << ")" << std::endl;
-    float mouse_x_sq = sx / grid_px;
-    float mouse_y_sq = sy / grid_px;
-
-    float ans_x = mouse_x_sq + left_edge;
-    float ans_y = mouse_y_sq + top_edge;
-
-    // compare integer method with this (mostly working) one
-    //int diff_realpixel_x = box.getSize().x / 2.0 - sx;
-    //int diff_realpixel_y = box.getSize().y / 2.0 - sy;
-    int left_spritepixels = center_x - (box.getSize().x / 2.0 / zoom);
-    int top_spritepixels = center_y - (box.getSize().y / 2.0 / zoom);
-
-    std::cout << "Float method got ans (" << ans_x << ", " << ans_y << ")"
-        << std::endl << "Int method px (" << left_spritepixels + (sx/zoom) << ", " << 
-        top_spritepixels + (sy/zoom) << ")" << std::endl << 
-        "Int grid (" << (left_spritepixels + (sx/zoom) ) / grid_size << 
-        ", " << (top_spritepixels + (sy/zoom)) / grid_size << ")" << 
-
-        std::endl;
-
-    // casting float turns -0.5 to 0; I want any negative coord to be OOB
-    if (ans_x < 0) ans_x = -1;
-    if (ans_y < 0) ans_y = -1;
-
-    gx = ans_x;
-    gy = ans_y;
-    /*
-    std::cout <<
-        "C: (" << center_x << ", " << center_y << ")" << std::endl <<
-        "W: " << width_sq << " H: " << height_sq << std::endl <<
-        "L: " << left_edge << " T: " << top_edge << std::endl <<
-        "R: " << right_edge << " B: " << bottom_edge << std::endl <<
-        "Grid Px: " << grid_px << "( zoom: " << zoom << ")" << std::endl <<
-        "answer: G(" << ans_x << ", " << ans_y << ")" << std::endl << 
-        "##############################" << 
-        std::endl;
-    */
-}
-
-void Grid::renderPxToGrid(int sx, int sy, int& gx, int& gy) {
-    // just like screen px coversion, but no offset by grid's position
-    float center_x_sq = center_x / grid_size;
-    float center_y_sq = center_y / grid_size;
-
-    float width_sq = box.getSize().x / (grid_size * zoom);
-    float height_sq = box.getSize().y / (grid_size * zoom);
-
-    int width_px = box.getSize().x / 2.0;
-    int height_px = box.getSize().y / 2.0;
-
-    float left_edge = center_x_sq - (width_sq / 2.0);
-    float top_edge = center_y_sq - (height_sq / 2.0);
-
-    float grid_px = zoom * grid_size;
-    float sx_sq = sx / grid_px;
-    float sy_sq = sy / grid_px;
-
-    float ans_x = sx_sq + left_edge;
-    float ans_y = sy_sq + top_edge;
-
-    if (ans_x < 0) ans_x = -1;
-    if (ans_y < 0) ans_y = -1;
-
-    gx = ans_x;
-    gy = ans_y;
-}
-
-void Grid::integerGrid(float fx, float fy, int& gx, int& gy) {
-    if (fx < 0) fx -= 0.5;
-    if (fy < 0) fy -= 0.5;
-    gx = fx;
-    gy = fy;
-}
-
-void Grid::gridToRenderPx(int gx, int gy, int& sx, int& sy) {
-    // integer grid square (gx, gy) - what pixel (on rendertexture)
-    // should it's top left corner be at (the sprite's position)
-
-    // eff_gridsize = grid_size * zoom
-    // if center_x = 161, and grid_size is 16, that's 10 + 1/16 sprites
-    // center_x - (box.getSize().x / 2 / zoom) = left edge (in px)
-    // gx * eff_gridsize = pixel position without panning
-    // pixel_gx - left_edge = grid's render position
-
-    sx = (gx * grid_size * zoom) - (center_x - (box.getSize().x / 2.0 / zoom));
-    sy = (gy * grid_size * zoom) - (center_y - (box.getSize().y / 2.0 / zoom));
-}
-
-void Grid::render(sf::RenderWindow & window)
-{
-    renderTexture.clear();
-    //renderTexture.draw(box);
-
-    // sprites that are visible according to zoom, center_x, center_y, and box width
-    float center_x_sq = center_x / grid_size;
-    float center_y_sq = center_y / grid_size;
-
-    float width_sq = box.getSize().x / (grid_size * zoom);
-    float height_sq = box.getSize().y / (grid_size * zoom);
-    float left_edge = center_x_sq - (width_sq / 2.0);
-    //float right_edge = center_x_sq + (width_sq / 2.0);
-    float top_edge = center_y_sq - (height_sq / 2.0);
-    //float bottom_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(grid_size * zoom, 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;
-
-    //for (float x = (left_edge >= 0 ? left_edge : 0); 
-    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)
-        {
-            // Converting everything to integer pixels to avoid jitter
-            //auto pixel_pos = sf::Vector2f(
-            //    (x - left_edge) * (zoom * grid_size),
-            //    (y - top_edge) * (zoom * grid_size));
-
-            // This failed horribly:
-            //int gx, gy; integerGrid(x, y, gx, gy);
-            //int px_x, px_y; gridToRenderPx(gx, gy, px_x, px_y);
-            //auto pixel_pos = sf::Vector2f(px_x, px_y);
-           
-            // this draws coherently, but the coordinates
-            // don't match up with the mouse cursor function
-            // jitter not eliminated
-            auto pixel_pos = sf::Vector2f(
-                    (x*grid_size - left_spritepixels) * zoom,
-                    (y*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);
-            }
-            
-            
-
-        }
-    }
-    
-    for (auto e : entities) {
-		auto drawent = e->cGrid->indexsprite.drawable();
-		drawent.setScale(zoom, zoom);
-		auto pixel_pos = sf::Vector2f(
-			(drawent.getPosition().x*grid_size - left_spritepixels) * zoom,
-			(drawent.getPosition().y*grid_size - top_spritepixels) * zoom );
-		drawent.setPosition(pixel_pos);
-		renderTexture.draw(drawent);
-	}
-	
-	// loop again and draw on top of entities
-	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*grid_size - left_spritepixels) * zoom,
-                    (y*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();
-    window.draw(output);
-}
-
-GridPoint& Grid::at(int x, int y)
-{
-    return points[y * grid_x + x];
-}

src/Grid.h

@@ -1,56 +0,0 @@
-#pragma once
-#include "Common.h"
-#include "libtcod.h"
-
-//#include "Entity.h"
-class Entity; // forward declare
-
-class GridPoint
-{
-public:
-    // Layers: color, walkable, tilesprite, transparent, visible, discovered, overlay, uisprite
-    sf::Color color;
-    bool walkable;
-    int tilesprite;
-    bool transparent, visible, discovered;
-    sf::Color color_overlay;
-    int tile_overlay, uisprite;
-    GridPoint();
-};
-
-class Grid
-{
-private:
-public:
-    Grid();
-    sf::RectangleShape box; // view on window
-    bool visible;
-    sf::Texture texture;
-    sf::Sprite sprite, output;
-    sf::RenderTexture renderTexture;
-    TCODMap* tcodmap;
-    void setSprite(int);
-    const int texture_width, texture_height;
-    auto contains(sf::Vector2i p) { return box.getGlobalBounds().contains(p.x, p.y); }
-
-    Grid(int gx, int gy, int gs, int _x, int _y, int _w, int _h);
-    int grid_x, grid_y; // rectangle map size (integer - sprites)
-    int grid_size; // pixel size of 1 sprite
-    float zoom;
-    int center_x, center_y; // center in 1.0x Pixels
-
-    std::vector<GridPoint> points; // grid visible contents
-    std::vector<std::shared_ptr<Entity>> entities;
-    void render(sf::RenderWindow&); // draw to screen
-    GridPoint& at(int, int);
-    bool inBounds(int, int);
-    void screenToGrid(int, int, int&, int&);
-
-    void renderPxToGrid(int, int, int&, int&);
-    void gridToRenderPx(int, int, int&, int&);
-    void integerGrid(float, float, int&, int&);
-    
-    void refreshTCODmap();
-    void refreshTCODsight(int, int);
-    TCODDijkstra *dijkstra; //= new TCODDijkstra(myMap);
-};

src/IndexSprite.cpp

@@ -1,24 +0,0 @@
-#include "IndexSprite.h"
-#include "GameEngine.h"
-
-//int texture_index, sprite_index, x, y;
-
-GameEngine* IndexSprite::game;
-
-sf::Sprite IndexSprite::drawable()
-{
-    sf::Sprite s;
-    auto& tex = IndexSprite::game->textures[texture_index];
-    s.setTexture(tex.texture);
-    s.setScale(sf::Vector2f(scale, scale));
-    s.setPosition(sf::Vector2f(x, y));
-    //std::cout << "Drawable position: " << x << ", " << y << " -> " << s.getPosition().x << ", " << s.getPosition().y << std::endl;
-    s.setTextureRect(tex.spriteCoordinates(sprite_index));
-    return s;
-}
-
-IndexSprite::IndexSprite(int _ti, int _si, float _x, float _y, float _s):
-    texture_index(_ti), sprite_index(_si), x(_x), y(_y), scale(_s) {
-		//std::cout << "IndexSprite constructed with x, y " << _x << ", " << _y << std::endl;
-		//std::cout << "  * Stored x, y " << x << ", " << y << std::endl;
-}

src/IndexSprite.h

@@ -1,13 +0,0 @@
-#pragma once
-#include "Common.h"
-class GameEngine; // forward declare
-
-class IndexSprite {
-public:
-    int texture_index, sprite_index;
-    float x, y;
-    float scale;
-    static GameEngine* game;
-    sf::Sprite drawable();
-    IndexSprite(int, int, float, float, float);
-};

src/McRFPy_API.h

@@ -1,19 +1,10 @@
 #pragma once
 #include "Common.h"
-#include "Entity.h"
-//#include "EntityManager.h"
-//#include "Scene.h"
-//#include "GameEngine.h" // can't - need forward declaration
-//#include "ActionCode.h"
 #include "Python.h"
-#include "UIMenu.h"
-#include "Grid.h"
-#include "IndexSprite.h"
-#include "EntityManager.h"
 #include <list>
 
-// implementation required to link templates
-#include "Animation.h"
+#include "PyFont.h"
+#include "PyTexture.h"
 
 class GameEngine; // forward declared (circular members)
 
@@ -24,63 +15,29 @@ private:
         texture_width = 12, texture_height = 11, // w & h sprite/frame count
         texture_sprite_count = 11 * 12; // t_width * t_height, minus blanks?
 
-    // TODO: this is wrong, load resources @ GameEngineSprite sprite;
-    // sf::Texture texture;
-
-    //std::vector<PyMethodDef> mcrfpyMethodsVector;
-    //static PyObject* PyInit_mcrfpy();
-
     McRFPy_API();
 
+
 public:
-    inline static sf::Sprite sprite;
-    inline static sf::Texture texture;
-    static void setSpriteTexture(int);
+    static PyObject* mcrf_module;
+    static std::shared_ptr<PyFont> default_font;
+    static std::shared_ptr<PyTexture> default_texture;
+    //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();
     // Python API functionality - use mcrfpy.* in scripts
-    static PyObject* _drawSprite(PyObject*, PyObject*);
+    //static PyObject* _drawSprite(PyObject*, PyObject*);
     static void REPL_device(FILE * fp, const char *filename);
     static void REPL();
 
-    // Jank mode engage: let the API hold data for Python to hack on
-    static std::map<std::string, UIMenu*> menus;
-    static EntityManager entities; // this is also kinda good, entities not on the current grid can still act (like monsters following you through doors??)
-    static std::map<std::string, Grid*> grids;
-    static std::list<Animation*> animations;
     static std::vector<sf::SoundBuffer> soundbuffers;
     static sf::Music music;
     static sf::Sound sfx;
     
-    static std::shared_ptr<Entity> player;
-
     static std::map<std::string, PyObject*> callbacks;
-
-    // Jank Python Method Exposures
-    static PyObject* _createMenu(PyObject*, PyObject*); // creates a new menu object in McRFPy_API::menus
-    static PyObject* _listMenus(PyObject*, PyObject*);
-    static PyObject* _modMenu(PyObject*, PyObject*);
-
-    static PyObject* _createCaption(PyObject*, PyObject*); // calls menu.add_caption
-    static PyObject* _createButton(PyObject*, PyObject*);
-    static PyObject* _createTexture(PyObject*, PyObject*);
-    static PyObject* _listTextures(PyObject*, PyObject*);
-    static PyObject* _createSprite(PyObject*, PyObject*);
-
-    // use _listMenus, probably will not implement
-    //static PyObject* _listCaptions(PyObject*, PyObject*);
-    //static PyObject* _listButtons(PyObject*, PyObject*);
-
-    static PyObject* _createEntity(PyObject*, PyObject*);
-    //static PyObject* _listEntities(PyObject*, PyObject*);
-
-    static PyObject* _createGrid(PyObject*, PyObject*);
-    static PyObject* _listGrids(PyObject*, PyObject*);
-    static PyObject* _modGrid(PyObject*, PyObject*);
-
-    static PyObject* _createAnimation(PyObject*, PyObject*);
-    
     static PyObject* _registerPyAction(PyObject*, PyObject*);
     static PyObject* _registerInputAction(PyObject*, PyObject*);
     
@@ -92,71 +49,29 @@ public:
     static PyObject* _getMusicVolume(PyObject*, PyObject*);
     static PyObject* _getSoundVolume(PyObject*, PyObject*);
     
-    // allow all player actions (items, menus, movement, combat)
-    static PyObject* _unlockPlayerInput(PyObject*, PyObject*);
-    // disallow player actions (animating enemy actions)
-    static PyObject* _lockPlayerInput(PyObject*, PyObject*);
-    // prompt C++/Grid Objects to callback with a target Entity or grid space
-    static PyObject* _requestGridTarget(PyObject*, PyObject*);
-    // string for labeling the map
-    static std::string active_grid;
-    static PyObject* _activeGrid(PyObject*, PyObject*);
-    static PyObject* _setActiveGrid(PyObject*, PyObject*);
-    // string for prompting input
-    static std::string input_mode;
-    static PyObject* _inputMode(PyObject*, PyObject*);
-    // turn cycle
-    static int turn_number;
-    static PyObject* _turnNumber(PyObject*, PyObject*);
-    static PyObject* _refreshFov(PyObject*, PyObject*);
-    static bool do_camfollow;
-    static void camFollow();
-    static PyObject* _camFollow(PyObject*, PyObject*);
-
     static PyObject* _sceneUI(PyObject*, PyObject*);
-    
+
+    // scene control
+    static PyObject* _setScene(PyObject*, PyObject*);
+    static PyObject* _currentScene(PyObject*, PyObject*);
+    static PyObject* _createScene(PyObject*, PyObject*);
+    static PyObject* _keypressScene(PyObject*, PyObject*); 
+
+    // timer control
+    static PyObject* _setTimer(PyObject*, PyObject*);
+    static PyObject* _delTimer(PyObject*, PyObject*);
+
+    static PyObject* _exit(PyObject*, PyObject*);
+    static PyObject* _setScale(PyObject*, PyObject*);
+
     // accept keyboard input from scene
     static sf::Vector2i cursor_position;
     static void player_input(int, int);
     static void computerTurn();
     static void playerTurn();
-
-    // Jank Functionality
-    static UIMenu* createMenu(int posx, int posy, int sizex, int sizey);
-    static void createCaption(std::string menukey, std::string text, int fontsize, sf::Color textcolor);
-    static void createButton(std::string menukey, int x, int y, int w, int h, sf::Color bgcolor, sf::Color textcolor, std::string caption, std::string action);
-    static void createSprite(std::string menukey, int ti, int si, float x, float y, float scale);
-    static int createTexture(std::string filename, int grid_size, int grid_width, int grid_height);
-    //static void playSound(const char * filename);
-    //static void playMusic(const char * filename);
     
     static void doAction(std::string);
 
-    //    McRFPy_API(GameEngine*);
-
-    // API functionality - use from C++ directly
-
-    //void spawnEntity(int tex_index, int grid_x, int grid_y, PyObject* script);
-
     static void executeScript(std::string);
     static void executePyString(std::string);
 };
-
-/*
-static PyMethodDef mcrfpyMethods[] = {
-    {"drawSprite", McRFPy_API::_drawSprite, METH_VARARGS,
-        "Draw a sprite (index, x, y)"},
-    {NULL, NULL, 0, NULL}
-};
-
-static PyModuleDef mcrfpyModule = {
-    PyModuleDef_HEAD_INIT, "mcrfpy", NULL, -1, mcrfpyMethods,
-    NULL, NULL, NULL, NULL
-};
-
-// Module initializer fn, passed to PyImport_AppendInittab
-PyObject* PyInit_mcrfpy()
-{
-    return PyModule_Create(&mcrfpyModule);
-}
-*/

src/MenuScene.cpp

@@ -1,53 +0,0 @@
-#include "MenuScene.h"
-#include "ActionCode.h"
-
-MenuScene::MenuScene(GameEngine* g) : Scene(g)
-{
-    text.setFont(game->getFont());
-    text.setString("McRogueFace Engine - r/RoguelikeDev Tutorial 2023");
-    text.setCharacterSize(24);
-    //std::cout << "MenuScene Initialized. " << game << std::endl;
-    //std::cout << "Font: " << game->getFont().getInfo().family << std::endl;
-
-    text2.setFont(game->getFont());
-    text2.setString("Press 'Spacebar' to run demo");
-    text2.setCharacterSize(16);
-    text2.setPosition(0.0f, 50.0f);
-    
-    text3.setFont(game->getFont());
-    text3.setString("use 'W' 'A' 'S' 'D' to move (even when blank; it's a bug)");
-    text3.setCharacterSize(16);
-    text3.setPosition(0.0f, 80.0f);
-
-    registerAction(ActionCode::KEY + sf::Keyboard::Space, "start_game");
-    registerAction(ActionCode::KEY + sf::Keyboard::Up, "up");
-    registerAction(ActionCode::KEY + sf::Keyboard::Down, "down");
-}
-
-void MenuScene::update()
-{
-    //std::cout << "MenuScene update" << std::endl;
-}
-
-void MenuScene::doAction(std::string name, std::string type)
-{
-    //std::cout << "MenuScene doAction: " << name << ", " << type << std::endl;
-    //if (name.compare("start_game") == 0 and type.compare("start") == 0)
-    if(ACTION("start_game", "start"))
-        game->changeScene("py");
-    /*
-    else if(ACTIONONCE("up"))
-        game->getWindow().setSize(sf::Vector2u(1280, 800));
-    else if(ACTIONONCE("down"))
-        game->getWindow().setSize(sf::Vector2u(1024, 768));
-    */
-}
-
-void MenuScene::sRender()
-{
-    game->getWindow().clear();
-    game->getWindow().draw(text);
-    game->getWindow().draw(text2);
-    game->getWindow().draw(text3);
-    game->getWindow().display();
-}

src/PyCallable.cpp

@@ -0,0 +1,114 @@
+#include "PyCallable.h"
+
+PyCallable::PyCallable(PyObject* _target)
+{
+    target = Py_XNewRef(_target);
+}
+
+PyCallable::~PyCallable()
+{
+    if (target)
+        Py_DECREF(target);
+}
+
+PyObject* PyCallable::call(PyObject* args, PyObject* kwargs)
+{
+    return PyObject_Call(target, args, kwargs);
+}
+
+bool PyCallable::isNone()
+{
+    return (target == Py_None || target == NULL);
+}
+
+PyTimerCallable::PyTimerCallable(PyObject* _target, int _interval, int now)
+: PyCallable(_target), interval(_interval), last_ran(now)
+{}
+
+PyTimerCallable::PyTimerCallable()
+: PyCallable(Py_None), interval(0), last_ran(0)
+{}
+
+bool PyTimerCallable::hasElapsed(int now)
+{
+    return now >= last_ran + interval;
+}
+
+void PyTimerCallable::call(int now)
+{
+    PyObject* args = Py_BuildValue("(i)", now);
+    PyObject* retval = PyCallable::call(args, NULL);
+    if (!retval)
+    {
+        PyErr_Print();
+        PyErr_Clear();
+    } else if (retval != Py_None)
+    {
+        std::cout << "timer returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+        std::cout << PyUnicode_AsUTF8(PyObject_Repr(retval)) << std::endl;
+    }
+}
+
+bool PyTimerCallable::test(int now)
+{
+    if(hasElapsed(now))
+    {
+        call(now);
+        last_ran = now;
+        return true;
+    }
+    return false;
+}
+
+PyClickCallable::PyClickCallable(PyObject* _target)
+: PyCallable(_target)
+{}
+
+PyClickCallable::PyClickCallable()
+: PyCallable(Py_None)
+{}
+
+void PyClickCallable::call(sf::Vector2f mousepos, std::string button, std::string action)
+{
+    PyObject* args = Py_BuildValue("(iiss)", (int)mousepos.x, (int)mousepos.y, button.c_str(), action.c_str());
+    PyObject* retval = PyCallable::call(args, NULL);
+    if (!retval)
+    {
+        std::cout << "ClickCallable has raised an exception. It's going to STDERR and being dropped:" << std::endl;
+        PyErr_Print();
+        PyErr_Clear();
+    } else if (retval != Py_None)
+    {
+        std::cout << "ClickCallable returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+        std::cout << PyUnicode_AsUTF8(PyObject_Repr(retval)) << std::endl;
+    }
+}
+
+PyObject* PyClickCallable::borrow()
+{
+    return target;
+}
+
+PyKeyCallable::PyKeyCallable(PyObject* _target)
+: PyCallable(_target)
+{}
+
+PyKeyCallable::PyKeyCallable()
+: PyCallable(Py_None)
+{}
+
+void PyKeyCallable::call(std::string key, std::string action)
+{
+    if (target == Py_None || target == NULL) return;
+    PyObject* args = Py_BuildValue("(ss)", key.c_str(), action.c_str());
+    PyObject* retval = PyCallable::call(args, NULL);
+    if (!retval)
+    {
+        std::cout << "KeyCallable has raised an exception. It's going to STDERR and being dropped:" << std::endl;
+        PyErr_Print();
+        PyErr_Clear();
+    } else if (retval != Py_None)
+    {
+        std::cout << "KeyCallable returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+    }
+}

src/PyCallable.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+
+class PyCallable
+{
+protected:
+    PyObject* target;
+    PyCallable(PyObject*);
+    ~PyCallable();
+    PyObject* call(PyObject*, PyObject*);
+public:
+    bool isNone();
+};
+
+class PyTimerCallable: public PyCallable
+{
+private:
+    int interval;
+    int last_ran;
+    void call(int);
+public:
+    bool hasElapsed(int);
+    bool test(int);
+    PyTimerCallable(PyObject*, int, int);
+    PyTimerCallable();
+};
+
+class PyClickCallable: public PyCallable
+{
+public:
+    void call(sf::Vector2f, std::string, std::string);
+    PyObject* borrow();
+    PyClickCallable(PyObject*);
+    PyClickCallable();
+};
+
+class PyKeyCallable: public PyCallable
+{
+public:
+    void call(std::string, std::string);
+    //PyObject* borrow(); // not yet implemented
+    PyKeyCallable(PyObject*);
+    PyKeyCallable();
+};

src/PyColor.cpp

@@ -0,0 +1,150 @@
+#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

@@ -0,0 +1,48 @@
+#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

@@ -0,0 +1,63 @@
+#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

@@ -0,0 +1,39 @@
+#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

@@ -0,0 +1,74 @@
+#include "PyScene.h"
+#include "ActionCode.h"
+#include "Resources.h"
+#include "PyCallable.h"
+
+PyScene::PyScene(GameEngine* g) : Scene(g)
+{
+    // mouse events
+    registerAction(ActionCode::MOUSEBUTTON + sf::Mouse::Left, "left");
+    registerAction(ActionCode::MOUSEBUTTON + sf::Mouse::Right, "right");
+    registerAction(ActionCode::MOUSEWHEEL + ActionCode::WHEEL_DEL, "wheel_up");
+    registerAction(ActionCode::MOUSEWHEEL + ActionCode::WHEEL_NEG + ActionCode::WHEEL_DEL, "wheel_down");
+
+    registerAction(ActionCode::KEY + sf::Keyboard::Grave, "debug_menu");
+}
+
+void PyScene::update()
+{
+}
+
+void PyScene::do_mouse_input(std::string button, std::string type)
+{
+    auto unscaledmousepos = sf::Mouse::getPosition(game->getWindow());
+    auto mousepos = game->getWindow().mapPixelToCoords(unscaledmousepos);
+    UIDrawable* target;
+    for (auto d: *ui_elements)
+    {
+        target = d->click_at(sf::Vector2f(mousepos));
+        if (target)
+        {
+            /*
+            PyObject* args = Py_BuildValue("(iiss)", (int)mousepos.x, (int)mousepos.y, button.c_str(), type.c_str());
+            PyObject* retval = PyObject_Call(target->click_callable, args, NULL);
+            if (!retval)
+            {   
+                std::cout << "click_callable has raised an exception. It's going to STDERR and being dropped:" << std::endl;
+                PyErr_Print();
+                PyErr_Clear();
+            } else if (retval != Py_None)
+            {   
+                std::cout << "click_callable returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+            }
+            */
+            target->click_callable->call(mousepos, button, type);
+        }
+    }
+}
+
+void PyScene::doAction(std::string name, std::string type)
+{
+    if (ACTIONPY) {
+        McRFPy_API::doAction(name.substr(0, name.size() - 3));
+    }
+    else if (name.compare("left") == 0 || name.compare("rclick") == 0 || name.compare("wheel_up") == 0 || name.compare("wheel_down") == 0) {
+        do_mouse_input(name, type);
+    }
+    else if ACTIONONCE("debug_menu") {
+        McRFPy_API::REPL();
+    }
+}
+
+void PyScene::render()
+{
+    game->getWindow().clear();
+    
+    auto vec = *ui_elements;
+    for (auto e: vec)
+    {
+        if (e)
+            e->render();
+    }
+    
+    game->getWindow().display();
+}

src/PyScene.h

@@ -4,15 +4,14 @@
 #include "Scene.h"
 #include "GameEngine.h"
 
-class MenuScene: public Scene
+class PyScene: public Scene
 {
-    sf::Text text;
-    sf::Text text2;
-    sf::Text text3;
 
 public:
-    MenuScene(GameEngine*);
+    PyScene(GameEngine*);
     void update() override final;
     void doAction(std::string, std::string) override final;
-    void sRender() override final;
+    void render() override final;
+
+    void do_mouse_input(std::string, std::string);
 };

src/PyTexture.cpp

@@ -0,0 +1,82 @@
+#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

@@ -0,0 +1,43 @@
+#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

@@ -0,0 +1,111 @@
+#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

@@ -0,0 +1,42 @@
+#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/PythonScene.cpp

@@ -1,269 +0,0 @@
-#include "PythonScene.h"
-#include "ActionCode.h"
-#include "McRFPy_API.h"
-//#include "Animation.h"
-
-PythonScene::PythonScene(GameEngine* g, std::string pymodule)
-: Scene(g) {
-    // mouse events
-    registerAction(ActionCode::MOUSEBUTTON + sf::Mouse::Left, "click");
-    registerAction(ActionCode::MOUSEBUTTON + sf::Mouse::Right, "rclick");
-    registerAction(ActionCode::MOUSEWHEEL + ActionCode::WHEEL_DEL, "wheel_up");
-    registerAction(ActionCode::MOUSEWHEEL + ActionCode::WHEEL_NEG + ActionCode::WHEEL_DEL, "wheel_down");
-
-    // keyboard events
-    /*
-    registerAction(ActionCode::KEY + sf::Keyboard::Q, "upleft");
-    registerAction(ActionCode::KEY + sf::Keyboard::W, "up");
-    registerAction(ActionCode::KEY + sf::Keyboard::E, "upright");
-    registerAction(ActionCode::KEY + sf::Keyboard::A, "left");
-    registerAction(ActionCode::KEY + sf::Keyboard::S, "down");
-    registerAction(ActionCode::KEY + sf::Keyboard::D, "right");
-    registerAction(ActionCode::KEY + sf::Keyboard::Z, "downleft");
-    registerAction(ActionCode::KEY + sf::Keyboard::X, "wait");
-    registerAction(ActionCode::KEY + sf::Keyboard::C, "downright");
-
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad7, "upleft");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad8, "up");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad9, "upright");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad4, "left");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad5, "wait");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad6, "right");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad1, "downleft");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad2, "down");
-    registerAction(ActionCode::KEY + sf::Keyboard::Numpad3, "downright");
-    */
-    // window resize
-    registerAction(0, "event");
-
-    dragging = false;
-    drag_grid = NULL;
-    
-    // import pymodule and call start()
-    McRFPy_API::executePyString("import " + pymodule);
-    McRFPy_API::executePyString(pymodule + ".start()");
-    
-}
-
-void PythonScene::animate() {
-    //std::cout << "Number of animations: " << McRFPy_API::animations.size() << std::endl;
-    auto frametime = game->getFrameTime();
-    auto it = McRFPy_API::animations.begin();
-    while (it != McRFPy_API::animations.end()) {
-        //std::cout << "Iterating" << std::endl;
-        (*it)->step(frametime);
-        //std::cout << "Step complete" << std::endl;
-        if ((*it)->isDone()) {
-            //std::cout << "Cleaning up Animation" << std::endl;
-            auto prev = it;
-            it++;
-            McRFPy_API::animations.erase(prev);
-        } else it++;
-    }
-    /* // workin on it
-    for (auto p : animations) {
-        if (p.first == "int") {
-            ((Animation<int>)p.second).step(frametime);
-        } else if (p.first == "string") {
-            ((Animation<std::string>)p.second).step(frametime);
-        } else if (p.first == "float") {
-            ((Animation<float>)p.second).step(frametime);
-        } else if (p.first == "vector2f") {
-            ((Animation<sf::Vector2f>)p.second).step(frametime);
-        } else if (p.first == "vector2i") {
-            ((Animation<sf::Vector2i>)p.second).step(frametime);
-        } else if (p.first == "color") {
-            ((Animation<int>)p.second).step(frametime); // TODO
-        } else {
-            std::cout << "Animation has label " << p.first << "; no type found" << std::endl;
-        }
-    }
-    auto it = animations.begin();
-    while (it != animations.end()) {
-        bool done = false;
-        if (p.first == "int") {
-            ((Animation<int>)p.second).step(frametime);
-        } else if (p.first == "string") {
-            if ((Animation<std::string>)p.second).isDone()
-                delete (Animation<std::string>)p.second
-        } else if (p.first == "float") {
-            ((Animation<float>)p.second).step(frametime);
-        } else if (p.first == "vector2f") {
-            ((Animation<sf::Vector2f>)p.second).step(frametime);
-        } else if (p.first == "vector2i") {
-            ((Animation<sf::Vector2i>)p.second).step(frametime);
-        } else if (p.first == "color") {
-            ((Animation<int>)p.second).step(frametime); // TODO
-        if ((*it).second.isDone()) {
-            animations.erase(it++);
-        } else { it++; }
-    }
-        */
-}
-
-void PythonScene::update() {
-	
-	// turn cycle: If player's input made the state "computerturnwait", finish
-	// 		all animations and then let the NPCs act
-	if (McRFPy_API::animations.size() == 0 && McRFPy_API::input_mode.compare("computerturnwait") == 0) {
-		McRFPy_API::input_mode = "computerturn";
-	}
-	else if (McRFPy_API::animations.size() == 0 && McRFPy_API::input_mode.compare("computerturnrunning") == 0) {
-		McRFPy_API::input_mode = "playerturnstart";
-	}
-    McRFPy_API::entities.update();
-
-    // check if left click is still down & mouse has moved
-    // continue the drag motion
-    if (dragging && drag_grid) {
-        //std::cout << "Compute dragging" << std::endl;
-        auto mousepos = sf::Mouse::getPosition(game->getWindow());
-        auto dx = mouseprev.x - mousepos.x,
-             dy = mouseprev.y - mousepos.y;
-        if (dx != 0 || dy != 0) { McRFPy_API::do_camfollow = false; }
-        drag_grid->center_x += (dx / drag_grid->zoom);
-        drag_grid->center_y += (dy / drag_grid->zoom);
-        mouseprev = mousepos;
-    }
-
-    animate();
-    McRFPy_API::camFollow();
-    if (McRFPy_API::input_mode.compare(std::string("computerturn")) == 0) McRFPy_API::computerTurn();
-    if (McRFPy_API::input_mode.compare(std::string("playerturnstart")) == 0) McRFPy_API::playerTurn();
-}
-
-void PythonScene::doLClick(sf::Vector2i mousepos) {
-    // UI buttons get first chance
-    for (auto pair : McRFPy_API::menus) {
-        if (!pair.second->visible) continue;
-        for (auto b : pair.second->buttons) {
-			//std::cout << "Box: " << pair.second->box.getPosition().x << ", " 
-			//<< pair.second->box.getPosition().y << "; Button:" << b.rect.getPosition().x <<
-			//", "  << b.rect.getPosition().y << "; Mouse: " << mousepos.x << ", " <<
-			//mousepos.y << std::endl;
-			
-			// JANK: provide the button a relative coordinate.
-            if (b.contains(pair.second->box.getPosition(), mousepos)) {
-                McRFPy_API::doAction(b.getAction());
-                return;
-            }
-        }
-    }
-    // left clicking a grid to select a square
-    for (auto pair : McRFPy_API::grids) {
-        if (!pair.second->visible) continue;
-        if (pair.second->contains(mousepos)) {
-            // grid was clicked
-            return;
-        }
-    }
-}
-
-void PythonScene::doRClick(sf::Vector2i mousepos) {
-    // just grids for right click
-    for (auto pair : McRFPy_API::grids) {
-        if (!pair.second->visible) continue;
-        if (pair.second->contains(mousepos)) {
-            // grid was clicked
-            return;
-        }
-    }
-}
-
-void PythonScene::doZoom(sf::Vector2i mousepos, int value) {
-    // just grids for right click
-    for (auto pair : McRFPy_API::grids) {
-        if (!pair.second->visible) continue;
-        if (pair.second->contains(mousepos)) {
-            // grid was zoomed
-            float new_zoom = pair.second->zoom + (value * 0.25);
-            if (new_zoom >= 0.5 && new_zoom <= 5.0) {
-                pair.second->zoom = new_zoom;
-            }
-        }
-    }
-}
-
-void PythonScene::doAction(std::string name, std::string type) {
-    auto mousepos = sf::Mouse::getPosition(game->getWindow());
-    //std::cout << "name: " << name << ", type: " << type << std::endl;
-    if (ACTIONPY) {
-        McRFPy_API::doAction(name.substr(0, name.size() - 3));
-    }
-    else if (ACTIONONCE("click")) {
-        // left click start
-        //std::cout << "LClick started at (" << mousepos.x << ", " << mousepos.y << ")" << std::endl;
-        dragstart = mousepos;
-        mouseprev = mousepos;
-        dragging = true;
-        
-        // determine the grid that contains the cursor
-        for (auto pair : McRFPy_API::grids) {
-            if (!pair.second->visible) continue;
-            if (pair.second->contains(mousepos)) {
-                // grid was clicked
-                drag_grid = pair.second;
-            }
-        }
-    }
-    else if (ACTIONAFTER("click")) {
-        // left click end
-        //std::cout << "LClick ended at (" << mousepos.x << ", " << mousepos.y << ")" << std::endl;
-        // if click ended without starting a drag event, try lclick?
-        if (dragstart == mousepos) {
-            // mouse did not move, do click
-            //std::cout << "(did not move)" << std::endl;
-            doLClick(mousepos);
-        }
-        dragging = false;
-        drag_grid = NULL;
-    }
-    else if (ACTIONONCE("rclick")) {
-        // not going to test for right click drag - just rclick
-        doRClick(mousepos);
-    }
-    else if (ACTIONONCE("wheel_up")) {
-        // try zoom in
-        doZoom(mousepos, 1);
-    }
-    else if (ACTIONONCE("wheel_down")) {
-        // try zoom out
-        doZoom(mousepos, -1);
-    }
-    else if (ACTIONONCE("up"))        { McRFPy_API::player_input(+0, -1); }
-    else if (ACTIONONCE("upright"))   { McRFPy_API::player_input(+1, -1); }
-    else if (ACTIONONCE("right"))     { McRFPy_API::player_input(+1, +0); }
-    else if (ACTIONONCE("downright")) { McRFPy_API::player_input(+1, +1); }
-    else if (ACTIONONCE("down"))      { McRFPy_API::player_input(+0, +1); }
-    else if (ACTIONONCE("downleft"))  { McRFPy_API::player_input(-1, +1); }
-    else if (ACTIONONCE("left"))      { McRFPy_API::player_input(-1, +0); }
-    else if (ACTIONONCE("upleft"))    { McRFPy_API::player_input(-1, -1); }
-    else if (ACTIONONCE("wait"))      { McRFPy_API::player_input(+0, +0); }
-}
-
-bool PythonScene::registerActionInjected(int code, std::string name) {
-    std::cout << "Registering injected action (PythonScene): " << code << " (" << ActionCode::KEY + code << ")\n";
-    registerAction(ActionCode::KEY + code, name);
-    //return false;
-    return true;
-}
-
-bool PythonScene::unregisterActionInjected(int code, std::string name) {
-    return false;
-}
-
-void PythonScene::sRender() {
-    game->getWindow().clear();
-
-    for (auto pair: McRFPy_API::grids) {
-        if (!pair.second->visible) continue;
-        pair.second->render(game->getWindow());
-    }
-
-    for (auto pair: McRFPy_API::menus) {
-        if (!pair.second->visible) continue;
-        pair.second->render(game->getWindow());
-    }
-
-    game->getWindow().display();
-}

src/PythonScene.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include "Common.h"
-#include "Scene.h"
-#include "GameEngine.h"
-#include "Grid.h"
-//#include "Animation.h"
-//#include <list>
-
-class PythonScene: public Scene
-{
-    sf::Vector2i dragstart, mouseprev;
-    bool dragging;
-    Grid* drag_grid;
-    void doLClick(sf::Vector2i);
-    void doRClick(sf::Vector2i);
-    void doZoom(sf::Vector2i, int);
-    //std::list<Animation*> animations;
-    void animate();
-    std::map<std::string, bool> actionInjected;
-    
-public:
-    PythonScene(GameEngine*, std::string);
-    void update() override final;
-    void doAction(std::string, std::string) override final;
-    void sRender() override final;
-    bool registerActionInjected(int, std::string) override;
-    bool unregisterActionInjected(int, std::string) override;
-};

src/Resources.cpp

@@ -1,7 +1,8 @@
 #include "Resources.h"
-#include <list>
-#include "UI.h"
+//#include <list>
+//#include "UI.h"
 // Resources class members memory allocation
 
 sf::Font Resources::font;
-GameEngine* Resources::game;
+GameEngine* Resources::game;
+std::string Resources::caption_buffer;

src/Resources.h

@@ -1,7 +1,7 @@
 #pragma once
 #include "Common.h"
-#include <list>
-#include "UI.h"
+//#include <list>
+//#include "UI.h"
 
 class GameEngine; // forward declared
 
@@ -10,4 +10,5 @@ class Resources
 public:
     static sf::Font font;
     static GameEngine* game;
+    static std::string caption_buffer;
 };

src/Scene.cpp

@@ -4,6 +4,7 @@
 //Scene::Scene() { game = 0; std::cout << "WARN: default Scene constructor called. (game = " << game << ")" << std::endl;};
 Scene::Scene(GameEngine* g)
 {
+    key_callable = std::make_unique<PyKeyCallable>();
     game = g; 
     ui_elements = std::make_shared<std::vector<std::shared_ptr<UIDrawable>>>();
 }
@@ -39,3 +40,27 @@ bool Scene::unregisterActionInjected(int code, std::string name)
 {
     return false;
 }
+
+void Scene::key_register(PyObject* callable)
+{
+    /*
+    if (key_callable)
+    {
+        // decrement reference before overwriting
+        Py_DECREF(key_callable);
+    }
+    key_callable = callable;
+    Py_INCREF(key_callable);
+    */
+    key_callable = std::make_unique<PyKeyCallable>(callable);
+}
+
+void Scene::key_unregister()
+{
+    /*
+    if (key_callable == NULL) return;
+    Py_DECREF(key_callable);
+    key_callable = NULL;
+    */
+    key_callable.reset();
+}

src/Scene.h

@@ -9,6 +9,7 @@
 #include "Common.h"
 #include <list>
 #include "UI.h"
+#include "PyCallable.h"
 //#include "GameEngine.h"
 
 class GameEngine; // forward declare
@@ -30,7 +31,7 @@ public:
     //Scene();
     Scene(GameEngine*);
     virtual void update() = 0;
-    virtual void sRender() = 0;
+    virtual void render() = 0;
     virtual void doAction(std::string, std::string) = 0;
     bool hasAction(std::string);
     bool hasAction(int);
@@ -41,4 +42,8 @@ public:
     
     std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> ui_elements;
 
+    //PyObject* key_callable;
+    std::unique_ptr<PyKeyCallable> key_callable;
+    void key_register(PyObject*);
+    void key_unregister();
 };

src/Timer.cpp

@@ -0,0 +1,31 @@
+#include "Timer.h"
+
+Timer::Timer(PyObject* _target, int _interval, int now)
+: target(_target), interval(_interval), last_ran(now)
+{}
+
+Timer::Timer()
+: target(Py_None), interval(0), last_ran(0)
+{}
+
+bool Timer::test(int now)
+{
+    if (!target || target == Py_None) return false;
+    if (now > last_ran + interval)
+    {
+        last_ran = now;
+        PyObject* args = Py_BuildValue("(i)", now);
+        PyObject* retval = PyObject_Call(target, args, NULL);
+        if (!retval)
+        {   
+            std::cout << "timer has raised an exception. It's going to STDERR and being dropped:" << std::endl;
+            PyErr_Print();
+            PyErr_Clear();
+        } else if (retval != Py_None)
+        {   
+            std::cout << "timer returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+        }
+        return true;
+    }
+    return false;
+}

src/Timer.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+class GameEngine; // forward declare
+
+class Timer
+{
+public:
+    PyObject* target;
+    int interval;
+    int last_ran;
+    Timer(); // for map to build
+    Timer(PyObject*, int, int);
+    bool test(int);
+};

src/UI.cpp

@@ -1,237 +0,0 @@
-#include "UI.h"
-#include "Resources.h"
-#include "GameEngine.h"
-
-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>>>();
-    /*
-    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)
-{
-    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);
-}
-
-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;
-}
-
-PyObject* DEFUNCT_py_instance(std::shared_ptr<UIDrawable> source)
-{
-    // takes a UI drawable, calls its derived_type virtual function, and builds a Python object based on the return value.
-    using namespace mcrfpydef;
-
-    PyObject* newobj = NULL; 
-    std::cout << "py_instance called\n";
-    switch (source->derived_type())
-    {
-        case PyObjectsEnum::UIFRAME:
-        {
-            std::cout << "UIFRAME case\n" << std::flush;
-            PyTypeObject* UIFrameType = &PyUIFrameType;
-            //std::cout << "tp_alloc\n" << std::flush;
-            //PyObject* _o = UIFrameType->tp_alloc(UIFrameType, 0);
-            //std::cout << "reinterpret_cast\n" << std::flush;
-            //auto o = reinterpret_cast<PyUICollectionObject*>(_o);
-            //PyUIFrameObject* o = (PyUIFrameObject*)PyObject_New(PyUIFrameObject, UIFrameType);
-            
-            PyUIFrameObject* o = (PyUIFrameObject*)(UIFrameType->tp_alloc(UIFrameType, 0));
-            //PyUIFrameObject* o = PyObject_New(PyUIFrameObject, UIFrameType);
-
-            /*
-            // backtracking the problem: instantiate a PyColor of (255, 0, 0) for testing
-            PyTypeObject* colorType = &PyColorType;
-            PyObject* pyColor = colorType->tp_alloc(colorType, 0);
-            if (pyColor == NULL)
-            {
-                std::cout << "failure to allocate mcrfpy.Color / PyColorType" << std::endl;
-                return NULL;
-            }
-            PyColorObject* pyColorObj = reinterpret_cast<PyColorObject*>(pyColor);
-            pyColorObj->data = std::make_shared<sf::Color>();
-            pyColorObj->data-> r = 255;
-            return (PyObject*)pyColorObj;
-            */
-
-            
-            std::cout << "pointer check: " << o << "\n" << std::flush;
-            if (o)
-            {
-                std::cout << "Casting data...\n" << std::flush;
-                auto p = std::static_pointer_cast<UIFrame>(source);
-                std::cout << "casted. Assigning...\n" << std::flush;
-                //o->data = std::make_shared<UIFrame>();
-
-                o->data = p;
-                //std::cout << "assigned.\n" << std::flush;
-                auto usource = o->data; //(UIFrame*)source.get();
-                std::cout << "Loaded data into object. " << usource->box.getPosition().x << " " << usource->box.getPosition().y << " " <<
-                    usource->box.getSize().x << " " << usource->box.getSize().y << std::endl;
-            }
-            else
-            {
-                std::cout << "Allocation failed.\n" << std::flush;
-            }
-            newobj = (PyObject*)o;
-            break;
-            
-        }
-        case PyObjectsEnum::UICAPTION:
-        {
-            std::cout << "UICAPTION case\n";
-            PyErr_SetString(PyExc_NotImplementedError, "UICaption class not implemented in Python yet.");
-            /* not yet implemented
-            PyUICaptionObject* o = (PyUICaptionObject*)PyUICaptionType.tp_alloc(&PyUICaptionType, 0);
-            if (o)
-                o->data = std::static_pointer_cast<UICaption>(source);
-            */
-            break;
-        }
-        case PyObjectsEnum::UISPRITE:
-        {
-            std::cout << "UISPRITE case\n";
-            PyErr_SetString(PyExc_NotImplementedError, "UISprite class not implemented in Python yet.");
-            /*
-            PyUISpriteObject* o = (PyUISpriteObject*)PyUISpriteType.tp_alloc(&PyUISpriteType, 0);
-            if (o)
-                o->data = std::static_pointer_cast<UISprite>(source);
-            */
-            break;
-        }
-        default:
-            return NULL;
-            break;
-    }
-
-    return newobj;
-}

src/UIBase.h

@@ -0,0 +1,32 @@
+#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

@@ -0,0 +1,283 @@
+#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

@@ -0,0 +1,62 @@
+#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

@@ -0,0 +1,203 @@
+#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

@@ -0,0 +1,88 @@
+#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

@@ -0,0 +1,81 @@
+#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

@@ -0,0 +1,176 @@
+#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

@@ -0,0 +1,177 @@
+#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

@@ -0,0 +1,75 @@
+#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

@@ -0,0 +1,265 @@
+#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

@@ -0,0 +1,77 @@
+#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

@@ -0,0 +1,639 @@
+#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

@@ -0,0 +1,184 @@
+#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

@@ -0,0 +1,158 @@
+#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

@@ -0,0 +1,92 @@
+#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/UIMenu.cpp

@@ -1,83 +0,0 @@
-#include "UIMenu.h"
-#include "Common.h"
-#include "Resources.h"
-
-UIMenu::UIMenu(sf::Font & _font)
-: font(_font)
-{
-    //font = _font;
-    box.setSize(sf::Vector2f(300, 400));
-    box.setPosition(sf::Vector2f(300, 250));
-    box.setFillColor(sf::Color(0,0,255));
-}
-
-UIMenu::UIMenu()
-: font(Resources::font)
-{
-    box.setSize(sf::Vector2f(300, 400));
-    box.setPosition(sf::Vector2f(300, 250));
-    box.setFillColor(sf::Color(0,0,255));   
-}
-
-void UIMenu::render(sf::RenderWindow & window)
-{
-    window.draw(box);
-    for (auto& s: sprites) {
-        auto _s = s.drawable();
-        //std::cout << "Sprite has values " << s.x << ", " << s.y << std::endl;
-        //std::cout << "Drawable generated @ " << _s.getPosition().x << ", " << _s.getPosition().y << std::endl;
-        _s.move(box.getPosition());
-        //std::cout << "Moved by  " << box.getPosition().x << ", " << box.getPosition().y << std::endl;
-        //std::cout << "Render UIMenu Sprite @ " << _s.getPosition().x << ", " << _s.getPosition().y << std::endl;
-        window.draw(_s);
-    }
-    for (auto& c : captions) {
-        //auto s = std::string(c.getString());
-        //std::cout << s << std::flush << std::endl;
-        c.move(box.getPosition());
-        window.draw(c);
-        c.move(-box.getPosition());
-    }
-    for (auto& b : buttons) { 
-		//b.render(window); 
-		b.setPosition(box.getPosition() + b.rect.getPosition());
-		//b.caption.setPosition(box.getPosition() + b.caption.getPosition());
-		b.render(window);
-		b.setPosition(b.rect.getPosition() - box.getPosition());
-		//b.caption.setPosition(b.caption.getPosition() - box.getPosition());
-	}
-}
-
-void UIMenu::refresh()
-{
-
-}
-
-void UIMenu::add_caption(const char* text, int tsize, sf::Color color)
-{
-    auto c = sf::Text();
-    //auto bpos = box.getPosition();
-
-    c.setFillColor(color);
-    c.setPosition(10, next_text);
-    next_text += 50;
-    c.setCharacterSize(tsize);
-    c.setString(text);
-    c.setFont(font);
-    captions.push_back(c);
-
-}
-
-void UIMenu::add_button(Button b)
-{
-    b.setPosition(sf::Vector2f(box.getSize().x / 2.0f, next_button));
-    next_button += 50;
-    buttons.push_back(b);
-}
-
-void UIMenu::add_sprite(IndexSprite s)
-{
-	//std::cout << "Adding sprite to UIMenu x,y " << s.x << ", " << s.y << std::endl;
-    sprites.push_back(s);
-}
-

src/UIMenu.h

@@ -1,38 +0,0 @@
-#pragma once
-
-#include "Common.h"
-#include "Button.h"
-#include "IndexSprite.h"
-
-class UIMenu
-{
-public:
-    //UIMenu() {};
-    sf::Font & font;
-    UIMenu(sf::Font & _font);
-    UIMenu();
-    std::vector<sf::Text> captions;
-    std::vector<Button> buttons;
-    std::vector<IndexSprite> sprites;
-    
-    /* idea: */ //std::vector<UIDrawable> children; // on the UIBox class?
-    
-    sf::RectangleShape box;
-    bool visible = false;
-    int next_text = 10;
-    int next_button = 10;
-
-    void render(sf::RenderWindow & window);
-    void refresh();
-    void add_caption(const char* text, int size, sf::Color color);
-    void add_button(Button b);
-    void add_sprite(IndexSprite s);
-
-
-protected:
-
-private:
-
-
-
-};

src/UISprite.cpp

@@ -0,0 +1,215 @@
+#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

@@ -0,0 +1,90 @@
+#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

@@ -4,8 +4,10 @@
 
 UITestScene::UITestScene(GameEngine* g) : Scene(g)
 {
+    registerAction(ActionCode::KEY + sf::Keyboard::Grave, "debug_menu");
+
     text.setFont(game->getFont());
-    text.setString("Test Scene for UI elements");
+    text.setString("UITest: surprised to be here? game.py raised an exception.");
     text.setCharacterSize(24);
 
 
@@ -59,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.setSmooth(false);
-    auto* indextex = new IndexTexture(t, 16, 12, 11);
-    Resources::game->textures.push_back(*indextex);
-
+    //t.loadFromFile("./assets/kenney_tinydungeon.png");
+    //t.setSmooth(false);
+    //auto* indextex = new IndexTexture(t, 16, 12, 11);
+    //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>();
+    auto e3 = std::make_shared<UISprite>(ptex, 84, sf::Vector2f(10, 10), 4.0);
 
     // Make UISprite more like IndexSprite: this is bad
     //e3->x = 10; e3->y = 10;
@@ -77,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->sprite.setTexture(e3->itex->texture);
-    e3->sprite_index = 84;
-    e3->sprite.setTextureRect(e3->itex->spriteCoordinates(e3->sprite_index));
-    e3->setPosition(10, 10);
-    e3->setScale(4.0f);
+    //e3->itex = &Resources::game->textures[0];
+    //e3->sprite.setTexture(e3->itex->texture);
+    //e3->sprite_index = 84;
+    //e3->sprite.setTextureRect(e3->itex->spriteCoordinates(e3->sprite_index));
+    //e3->setPosition(10, 10);
+    //e3->setScale(4.0f);
 
     e1aa->children->push_back(e3);
 
 
 
     auto e4 = std::make_shared<UISprite>(
-            indextex, //&Resources::game->textures[0],
+            ptex, //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 << " " <<
@@ -101,6 +103,33 @@ UITestScene::UITestScene(GameEngine* g) : Scene(g)
     if (ui)
     std::cout << "pointer to ui_elements now shows size=" << ui->size() << std::endl;
     */
+
+    // 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));
+    e5->zoom=2.0;
+    e5->points[0].color =  sf::Color(255, 0, 0);
+    e5->points[1].tilesprite = 1;
+    e5->points[5].color =  sf::Color(0, 255, 0);
+    e5->points[6].tilesprite = 2;
+    e5->points[10].color = sf::Color(0, 0, 255);
+    e5->points[11].tilesprite = 3;
+    e5->points[15].color = sf::Color(255, 255, 255);
+
+    ui_elements->push_back(e5);
+
+    //UIEntity test:
+    // asdf
+    // TODO - reimplement UISprite style rendering within UIEntity class. Entities don't have a screen pixel position, they have a grid position, and grid sets zoom when rendering them.
+    auto e5a = std::make_shared<UIEntity>(*e5); // this basic constructor sucks: sprite position + zoom are irrelevant for UIEntity.
+    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->position = sf::Vector2f(1, 0);
+
+    e5->entities->push_back(e5a);
+
 }
 
 void UITestScene::update()
@@ -114,6 +143,9 @@ void UITestScene::doAction(std::string name, std::string type)
     //if (name.compare("start_game") == 0 and type.compare("start") == 0)
     if(ACTION("start_game", "start"))
         game->changeScene("py");
+    else if ACTIONONCE("debug_menu") {
+        McRFPy_API::REPL();
+    }
     /*
     else if(ACTIONONCE("up"))
         game->getWindow().setSize(sf::Vector2u(1280, 800));
@@ -122,7 +154,7 @@ void UITestScene::doAction(std::string name, std::string type)
     */
 }
 
-void UITestScene::sRender()
+void UITestScene::render()
 {
     game->getWindow().clear();
     game->getWindow().draw(text);
@@ -145,5 +177,5 @@ void UITestScene::sRender()
     
     game->getWindow().display();
     
-    McRFPy_API::REPL();
+    //McRFPy_API::REPL();
 }

src/UITestScene.h

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

src/scripts/Grid.py

@@ -1,50 +0,0 @@
-class GridPoint:
-    def __init__(self, color, walkable, tilesprite, transparent, visible, discovered, color_overlay, tile_overlay, uisprite):
-        self.color = color
-        self.walkable = walkable
-        self.tilesprite = tilesprite
-        self.transparent = transparent
-        self.visible = visible
-        self.discovered = discovered
-        self.color_overlay = color_overlay
-        self.tile_overlay = tile_overlay
-        self.uisprite = uisprite
-
-    def __repr__(self):
-        return f"<GridPoint {self.color}, {self.tilesprite}/{self.uisprite} {'W' if self.walkable else '-'}{'T' if self.transparent else '-'}{'V' if self.visible else '-'}{'D' if self.discovered else '-'} {self.color_overlay}/{self.tile_overlay}>"
-
-class Grid:
-    def __init__(self, title, gx, gy, gs, x, y, w, h, visible=False):
-        self.title = title
-        self.grid_x = gx
-        self.grid_y = gy
-        self.grid_size = gs
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.visible = visible
-
-        self.points = []
-        self.entities = []
-        
-    def at(self, x, y):
-        if not (x > 0 and y > 0 and x < self.grid_x and y < self.grid_y): return None
-        return self.points[y * self.grid_y + x]
-
-    def __repr__(self):
-        return f"<Grid {self.grid_x}x{self.grid_y}, grid_size={self.grid_size}, (({self.x},{self.y}), ({self.w}, {self.h})), visible={self.visible}>"
-
-
-# CGrid(Grid* _g, int _ti, int _si, int _x, int _y, bool _v)
-class Entity:
-    def __init__(self, parent, tex_index, sprite_index, x, y, visible=True):
-        self.parent = parent
-        self.tex_index = tex_index
-        self.sprite_index = sprite_index
-        self.x = x
-        self.y = y
-        self.visible = visible
-        
-    def __repr__(self):
-        return f"<Entity on grid {repr(self.parent)}@({self.x},{self.y}), TI={self.tex_index}, SI={self.sprite_index}, visible={self.visible}>"

src/scripts/MusicScene.py

@@ -1,79 +0,0 @@
-import mcrfpy
-BLACK = (0, 0, 0)
-WHITE = (255, 255, 255)
-RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
-DARKRED, DARKGREEN, DARKBLUE = (192, 0, 0), (0, 192, 0), (0, 0, 192)
-class MusicScene:
-    def __init__(self, ui_name = "demobox1", grid_name = "demogrid"):
-        # Texture & Sound Loading
-        print("Load textures")
-        mcrfpy.createTexture("./assets/test_portraits.png", 32, 8, 8) #0 - portraits
-        mcrfpy.createTexture("./assets/alives_other.png", 16, 64, 64) #1 - TinyWorld NPCs
-        mcrfpy.createTexture("./assets/alives_other.png", 32, 32, 32) #2 - TinyWorld NPCs - 2x2 sprite
-    #     	{"createSoundBuffer", McRFPy_API::_createSoundBuffer, METH_VARARGS, "(filename)"},
-	#{"loadMusic", McRFPy_API::_loadMusic, METH_VARARGS, "(filename)"},
-	#{"setMusicVolume", McRFPy_API::_setMusicVolume, METH_VARARGS, "(int)"},
-	#{"setSoundVolume", McRFPy_API::_setSoundVolume, METH_VARARGS, "(int)"},
-	#{"playSound", McRFPy_API::_playSound, METH_VARARGS, "(int)"},
-	#{"getMusicVolume", McRFPy_API::_getMusicVolume, METH_VARARGS, ""},
-	#{"getSoundVolume", McRFPy_API::_getSoundVolume, METH_VARARGS, ""},
-    
-        mcrfpy.loadMusic("./assets/ultima.ogg")
-        mcrfpy.createSoundBuffer("./assets/boom.wav")
-        self.ui_name = ui_name
-        self.grid_name = grid_name
-
-        print("Create UI")
-        # Create dialog UI
-        mcrfpy.createMenu(ui_name, 20, 540, 500, 200)
-        mcrfpy.createCaption(ui_name, f"Music Volume: {mcrfpy.getMusicVolume()}", 24, RED)
-        mcrfpy.createCaption(ui_name, f"SFX Volume: {mcrfpy.getSoundVolume()}", 24, RED)
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKBLUE, (0, 0, 0), "clicky", "testaction")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKRED, (0, 0, 0), "Music+", "mvol+")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKGREEN, (0, 0, 0), "Music-", "mvol-")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, GREEN, "SFX+", "svol+")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, RED, "SFX-", "svol-")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKRED, (0, 0, 0), "REPL", "startrepl")
-        mcrfpy.createSprite(ui_name, 1, 0, 20, 40, 3.0)
-        
-        print("Create UI 2")
-        entitymenu = "entitytestmenu"
-        
-        mcrfpy.createMenu(entitymenu, 840, 20, 20, 500)
-        mcrfpy.createButton(entitymenu, 0, 10, 150, 40, DARKBLUE, BLACK, "PlayM", "playm")
-        mcrfpy.createButton(entitymenu, 0, 60, 150, 40, DARKBLUE, BLACK, "StopM", "stopm")
-        mcrfpy.createButton(entitymenu, 0, 110, 150, 40, DARKBLUE, BLACK, "SFX", "boom")
-        print("Make UIs visible")
-        self.menus = mcrfpy.listMenus()
-        self.menus[0].visible = True
-        self.menus[1].w = 170
-        self.menus[1].visible = True
-        mcrfpy.modMenu(self.menus[0])
-        mcrfpy.modMenu(self.menus[1])
-        self.mvol = mcrfpy.getMusicVolume()
-        self.svol = mcrfpy.getSoundVolume()
-        mcrfpy.registerPyAction("mvol+", lambda: self.setmvol(self.mvol+10))
-        mcrfpy.registerPyAction("mvol-", lambda: self.setmvol(self.mvol-10))
-        mcrfpy.registerPyAction("svol+", lambda: self.setsvol(self.svol+10))
-        mcrfpy.registerPyAction("svol-", lambda: self.setsvol(self.svol-10))
-        mcrfpy.registerPyAction("playm", lambda: None)
-        mcrfpy.registerPyAction("stopm", lambda: None)
-        mcrfpy.registerPyAction("boom", lambda: mcrfpy.playSound(0))
-        
-    def setmvol(self, v):
-        mcrfpy.setMusicVolume(int(v))
-        self.menus[0].captions[0].text = f"Music Volume: {mcrfpy.getMusicVolume():.1f}"
-        mcrfpy.modMenu(self.menus[0])
-        self.mvol = mcrfpy.getMusicVolume()
-        
-    def setsvol(self, v):
-        mcrfpy.setSoundVolume(int(v))
-        self.menus[0].captions[1].text = f"Sound Volume: {mcrfpy.getSoundVolume():.1f}"
-        mcrfpy.modMenu(self.menus[0])
-        self.svol = mcrfpy.getSoundVolume()
-
-scene = None
-def start():
-    global scene
-    scene = MusicScene()
-

src/scripts/TestScene.py

@@ -1,575 +0,0 @@
-import UIMenu
-import Grid
-import mcrfpy
-from random import randint, choice
-from pprint import pprint
-#print("TestScene imported")
-BLACK = (0, 0, 0)
-WHITE = (255, 255, 255)
-RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
-DARKRED, DARKGREEN, DARKBLUE = (192, 0, 0), (0, 192, 0), (0, 0, 192)
-
-animations_in_progress = 0
-
-# don't load grid over and over, use the global scene
-scene = None
-
-class TestEntity:
-    def __init__(self, grid, label, tex_index, basesprite, x, y, texture_width=64, walk_frames=5, attack_frames=6, do_fov=False):
-        self.grid = grid
-        self.basesprite = basesprite
-        self.texture_width = texture_width
-        self.walk_frames = walk_frames
-        self.attack_frames = attack_frames
-        self.x = x
-        self.y = y
-        self.facing_direction = 0
-        self.do_fov = do_fov
-        self.label = label
-        self.inventory = []
-        #print(f"Calling C++ with: {repr((self.grid, label, tex_index, self.basesprite, x, y, self))}")
-        grids = mcrfpy.listGrids()
-        for g in grids:
-            if g.title == self.grid:
-                self.entity_index = len(g.entities)
-        mcrfpy.createEntity(self.grid, label, tex_index, self.basesprite, x, y, self)
-        
-    def ai_act(self):
-        return # no AI motion
-        #if self.label == "player": return
-        self.move(randint(-1, 1), randint(-1, 1))
-        scene.actors += 1
-        
-    def player_act(self):
-        #print("I'M INTERVENING")
-        mcrfpy.unlockPlayerInput()
-        scene.updatehints()
-        
-    def die(self):
-        #self.x = -2
-        #self.y = -2
-        self.move(-1000,-1000)
-        self.animate(0,animove=(-1000,-1000))
-        self.x = -1000
-        self.y = -1000
-        self.label = "dead"
-        
-    def interact(self, initiator, callback):
-        print(f"Interacted with {self.label}. ", end='')
-        if self.label == 'item':
-            print("'taking' item.")
-            callback()
-            self.die()
-        else:
-            print("blocking movement.")
-    
-    def move(self, dx, dy, force=False):
-        # select animation direction
-        # prefer left or right for diagonals.
-        #grids = mcrfpy.listGrids()
-        for g in scene.grids:
-            if g.title == self.grid:
-                if not force and g.at(self.x + dx, self.y + dy) is None or not g.at(self.x + dx, self.y + dy).walkable:
-                    #print("Blocked at target location.")
-                    return
-                if not force: # entities can be stepped on when force=True (like collecting items!)
-                    for entity in scene.tes:
-                        if (entity.x, entity.y) == (self.x + dx, self.y + dy):
-                            print(f"Blocked by entity {entity.label} at ({entity.x}, {entity.y})")
-                            return entity.interact(self, lambda: self.move(dx, dy, force=True))
-        if self.label == "player": 
-            mcrfpy.lockPlayerInput()
-            scene.updatehints()
-        if (dx == 0 and dy == 0):
-            direction = self.facing_direction # TODO, jump straight to computer turn
-        elif (dx):
-            direction = 2 if dx == +1 else 3
-        else:
-            direction = 0 if dy == +1 else 1
-        self.animate(direction, move=True, animove=(self.x + dx, self.y+dy))
-        self.facing_direction = direction
-        if (self.do_fov): mcrfpy.refreshFov()
-
-        
-    def animate(self, direction, attacking=False, move=False, animove=None):
-        start_sprite = self.basesprite + (self.texture_width * (direction + (4 if attacking else 0)))
-        animation_frames = [start_sprite + i for i in range((self.attack_frames if attacking else self.walk_frames))]
-        mcrfpy.createAnimation(
-            0.15, # duration, seconds
-            self.grid, # parent: a UIMenu or Grid key
-            "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-            self.entity_index, # target id: integer index for menu or grid objs; None for grid/menu
-            "sprite", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-            self.animation_done, #callback: callable once animation is complete
-            False, #loop: repeat indefinitely
-            animation_frames # values: iterable of frames for 'sprite', lerp target for others
-        )
-        #global animations_in_progress
-        #animations_in_progress += 1
-        if move:
-            pos = [self.x, self.y]
-            if (direction == 0): pos[1] += 1
-            elif (direction == 1): pos[1] -= 1
-            elif (direction == 2): pos[0] += 1
-            elif (direction == 3): pos[0] -= 1
-            if not animove: 
-                self.x, self.y = pos
-                animove = pos
-            else: 
-                pos = animove
-                self.x, self.y = animove
-            #scene.move_entity(self.grid, self.entity_index, pos)
-            #for g in mcrfpy.listGrids():
-            for g in scene.grids:
-                if g.title == self.grid:
-                    g.entities[self.entity_index].x = pos[0]
-                    g.entities[self.entity_index].y = pos[1]
-                    mcrfpy.modGrid(g, True)
-        if animove:
-            mcrfpy.createAnimation(
-                0.25, # duration, seconds
-                self.grid, # parent: a UIMenu or Grid key
-                "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-                self.entity_index, # target id: integer index for menu or grid objs; None for grid/menu
-                "position", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-                self.animation_done, #callback: callable once animation is complete
-                False, #loop: repeat indefinitely
-                animove # values: iterable of frames for 'sprite', lerp target for others
-            )
-            #animations_in_progress += 1
-
-        
-    def animation_done(self):
-        #global animations_in_progress
-        #animations_in_progress -= 1
-        scene.actors -= 1
-        #print(f"{self} done animating - {scene.actors} remaining")
-        if scene.actors <= 0:
-            scene.actors = 0
-            mcrfpy.unlockPlayerInput()
-            scene.updatehints()
-
-class TestItemEntity(TestEntity):
-    def __init__(self, grid, label, tex_index, basesprite, x, y, texture_width=64, walk_frames=5, attack_frames=6, do_fov=False, item="Nothing"):
-        super().__init__(grid, label, tex_index, basesprite, x, y, texture_width, walk_frames, attack_frames, do_fov)
-        self.item = item
-    
-    def interact(self, initiator, callback):
-        if self.label == 'dead': return super().interact(initiator, callback)
-        print(f"Interacted with {self.label}, an item. Adding {self.item} to {initiator.label}'s inventory")
-        initiator.inventory.append(self.item)
-        callback()
-        scene.itemguis()
-        self.die()
-        
-class TestDoorEntity(TestEntity):
-    def __init__(self, grid, label, tex_index, basesprite, x, y, texture_width=64, walk_frames=5, attack_frames=6, do_fov=False, key="Nothing"):
-        super().__init__(grid, label, tex_index, basesprite, x, y, texture_width, walk_frames, attack_frames, do_fov)
-        self.key = key
-        
-    def interact(self, initiator, callback):
-        if self.label == 'dead': return super().interact(initiator, callback)
-        print(f"Interacted with {self.label}, a Door. ", end='')
-        if self.key in initiator.inventory:
-            initiator.inventory.remove(self.key)
-            print("Taking key & passing.")
-            callback()
-            scene.itemguis()
-            self.die()
-        else:
-            print("The door is locked.")
-
-class TestScene:
-    def __init__(self, ui_name = "demobox1", grid_name = "demogrid"):
-        # Texture & Sound Loading
-        self.actors = 0
-        #print("Load textures")
-        mcrfpy.createTexture("./assets/test_portraits.png", 32, 8, 8) #0 - portraits
-        mcrfpy.createTexture("./assets/alives_other.png", 16, 64, 64) #1 - TinyWorld NPCs
-        mcrfpy.createTexture("./assets/alives_other.png", 32, 32, 32) #2 - TinyWorld NPCs - 2x2 sprite
-        mcrfpy.createTexture("./assets/custom_player.png", 16, 5, 13) #3 - player
-        mcrfpy.createTexture("./assets/Sprite-0001.png", 80, 10, 10) #4 - LGJ2023 keycard + other icons
-        mcrfpy.createTexture("./assets/tiny_keycards.png", 16, 8, 8) #5 - tiny keycards (ground items)
-        self.ui_name = ui_name
-        self.grid_name = grid_name
-
-        # Menu index = 0
-        #print("Create UI")
-        # Create dialog UI
-        mcrfpy.createMenu(ui_name, 20, 540, 500, 200)
-        #mcrfpy.createCaption(ui_name, "Hello There", 18, BLACK)
-        mcrfpy.createCaption(ui_name, "", 24, RED)
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKBLUE, (0, 0, 0), "clicky", "testaction")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKRED, (0, 0, 0), "REPL", "startrepl")
-        ##mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKGREEN, (0, 0, 0), "map gen", "gridgen")
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKGREEN, (0, 0, 0), "mapL", "gridgen2")
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKBLUE, (192, 0, 0), "a_menu", "animtest")
-        #mcrfpy.createButton(ui_name, 250, 20, 100, 50, DARKRED, GREEN, "a_spr", "animtest2")
-        #mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, GREEN, "Next sp", "nextsp")
-        #mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, RED, "Prev sp", "prevsp")
-        #mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, DARKGREEN, "+16 sp", "skipsp")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKGREEN, (0, 0, 0), "Next", "nextsp")
-        mcrfpy.createButton(ui_name, 250, 0, 130, 40, DARKBLUE, (0, 0, 0), "Prev", "prevsp")
-        mcrfpy.createSprite(ui_name, 4, 1, 10, 10, 2.0)
-        
-        # Menu index = 1
-        #print("Create UI 2")
-        entitymenu = "entitytestmenu"
-        mcrfpy.createMenu(entitymenu, 840, 20, 20, 500)
-        mcrfpy.createButton(entitymenu, 0, 10, 150, 40, DARKBLUE, BLACK, "Up", "test_up")
-        mcrfpy.createButton(entitymenu, 0, 60, 150, 40, DARKBLUE, BLACK, "Down", "test_down")
-        mcrfpy.createButton(entitymenu, 0, 110, 150, 40, DARKBLUE, BLACK, "Left", "test_left")
-        mcrfpy.createButton(entitymenu, 0, 160, 150, 40, DARKBLUE, BLACK, "Right", "test_right")
-        mcrfpy.createButton(entitymenu, 0, 210, 150, 40, DARKBLUE, BLACK, "Attack", "test_attack")
-        mcrfpy.createButton(entitymenu, 0, 210, 150, 40, DARKBLUE, RED, "TE", "testent")
-        
-        # Menu index = 2
-        mcrfpy.createMenu(   "gridtitlemenu", 0, -10, 0, 0)
-        mcrfpy.createCaption("gridtitlemenu", "<grid name>", 18, WHITE)
-        #mcrfpy.createCaption("gridtitlemenu", "<camstate>", 16, WHITE)
-        
-        # Menu index = 3
-        mcrfpy.createMenu(   "hintsmenu", 0, 505, 0, 0)
-        mcrfpy.createCaption("hintsmenu", "<hintline>", 16, WHITE)
-        
-        # Menu index = 4
-        # menu names must be created in alphabetical order (?!) - thanks, C++ hash map
-        mcrfpy.createMenu(   "i",            600, 20, 0, 0)
-        #mcrfpy.createMenu(   "camstatemenu", 600, 20, 0, 0)
-        mcrfpy.createCaption("i", "<camstate>", 16, WHITE)
-        
-        # Menu index = 5
-        mcrfpy.createMenu( "j", 600, 500, 0, 0)
-        mcrfpy.createButton( "j", 0, 0, 80, 40, DARKBLUE, WHITE, "Recenter", "activatecamfollow")
-        
-        # Menu index = 6, 7, 8, 9, 10: keycard sprites
-        mcrfpy.createMenu("k", 540, 540, 80, 80) #6
-        mcrfpy.createSprite("k", 4, 0, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("l", 540 + (80 * 1), 540, 80, 80) #7
-        mcrfpy.createSprite("l", 4, 1, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("m", 540 + (80 * 2), 540, 80, 80) #8
-        mcrfpy.createSprite("m", 4, 2, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("n", 540 + (80 * 3), 540, 80, 80) #9
-        mcrfpy.createSprite("n", 4, 3, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("o", 540 + (80 * 4), 540, 80, 80) #10
-        mcrfpy.createSprite("o", 4, 4, 10, 10, 1.0)
-        
-        mcrfpy.createMenu("p", 20, 20, 40, 40) #11
-        #mcrfpy.createButton("p", 0, 0, 130, 40, DARKGREEN, (0, 0, 0), "Register", "keyregistration")
-        mcrfpy.createButton("p", 0, 0, 130, 40, DARKGREEN, (0, 0, 0), "Register", "startrepl")
-        mcrfpy.registerPyAction("keyregistration", keyregistration)
-        #print("Make UIs visible")
-        self.menus = mcrfpy.listMenus()
-        self.menus[0].visible = True
-        self.menus[1].w = 170
-        self.menus[1].visible = True
-        self.menus[2].visible = True
-        
-        for mn in range(2, 6):
-            self.menus[mn].bgcolor = BLACK
-            self.menus[mn].visible = True
-            mcrfpy.modMenu(self.menus[mn])
-        
-        for mn in range(6, 11):
-            self.menus[mn].bgcolor = BLACK
-            self.menus[mn].visible = False
-            mcrfpy.modMenu(self.menus[mn])
-        
-        self.menus[11].visible=True
-        mcrfpy.modMenu(self.menus[11])
-                                            
-        #self.menus[2].bgcolor = BLACK
-        #self.menus[3].visible = True
-        #self.menus[3].bgcolor = BLACK
-        #self.menus[4].visible = True
-        #self.menus[4].bgcolor = BLACK
-        #self.menus[5].visible = True
-        #mcrfpy.modMenu(self.menus[0])
-        #mcrfpy.modMenu(self.menus[1])
-        #mcrfpy.modMenu(self.menus[2])
-        #mcrfpy.modMenu(self.menus[3])
-        #mcrfpy.modMenu(self.menus[4])
-        #mcrfpy.modMenu(self.menus[5])
-        #pprint(mcrfpy.listMenus())
-        #print(f"UI 1 gave back this sprite: {self.menus[0].sprites}")
-
-        #print("Create grid")
-        # create grid (title, gx, gy, gs, x, y, w, h)
-        mcrfpy.createGrid(grid_name, 100, 100, 16, 20, 20, 800, 500)
-        self.grids = mcrfpy.listGrids()
-        #print(self.grids)
-        
-        #print("Create entities")
-        #mcrfpy.createEntity("demogrid", "dragon", 2, 545, 10, 10, lambda: None)
-        #mcrfpy.createEntity("demogrid", "tinyenemy", 1, 1538, 3, 6, lambda: None)
-        
-        #print("Create fancy entity")
-        self.player = TestEntity("demogrid", "player", 3, 20, 17, 3, 5, walk_frames=4, attack_frames=5, do_fov=True)
-        self.tes = [
-            TestEntity("demogrid", "classtest", 1, 1538, 5, 7, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1545, 7, 9, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1552, 9, 11, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1566, 11, 13, 64, walk_frames=4, attack_frames=6),
-            #TestEntity("demogrid", "item", 1, 1573, 13, 15, 64, walk_frames=4, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 1583, 15, 17, 64, walk_frames=4, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 130, 9, 7, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 136, 11, 9, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 143, 13, 11, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 158, 15, 13, 64, walk_frames=5, attack_frames=6),
-            TestEntity("demogrid", "classtest", 1, 165, 17, 15, 64, walk_frames=5, attack_frames=6),
-            self.player,
-            
-            TestItemEntity("demogrid", "GreenKeyCard", 5, 0, 19, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Green Keycard"),
-            TestItemEntity("demogrid", "BlueKeyCard", 5, 1, 21, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Blue Keycard"),
-            TestItemEntity("demogrid", "RedKeyCard", 5, 2, 23, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Red Keycard"),
-            TestItemEntity("demogrid", "OrangeKeyCard", 5, 3, 25, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Orange Keycard"),
-            TestItemEntity("demogrid", "DevilKeyCard", 5, 4, 27, 3, texture_width=64,
-                           walk_frames=5, attack_frames=6, do_fov=False, item="Devil Keycard"),
-            
-             TestDoorEntity("demogrid", "GreenKeyDoor",  5, 8,   19, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Green Keycard"),
-             TestDoorEntity("demogrid", "BlueKeyDoor",   5, 9,   21, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Blue Keycard"),
-             TestDoorEntity("demogrid", "RedKeyDoor",    5, 10,  23, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Red Keycard"),
-             TestDoorEntity("demogrid", "OrangeKeyDoor", 5, 11,  25, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Orange Keycard"),
-             TestDoorEntity("demogrid", "DevilKeyDoor",  5, 12,  27, 5, texture_width=64,
-                            walk_frames=5, attack_frames=6, do_fov=False, key="Devil Keycard")
-            ]
-        self.grids = mcrfpy.listGrids()
-        
-        self.entity_direction = 0
-        mcrfpy.registerPyAction("test_down",   lambda: [te.animate(0, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_up",     lambda: [te.animate(1, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_right",  lambda: [te.animate(2, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_left",   lambda: [te.animate(3, False, True) for te in self.tes])
-        mcrfpy.registerPyAction("test_attack", lambda: [te.animate(0, True) for te in self.tes])
-        mcrfpy.registerPyAction("testent",     lambda: [te.animate(2, True) for te in self.tes])
-        mcrfpy.registerPyAction("activatecamfollow", lambda: mcrfpy.camFollow(True))
-
-        # Button behavior
-        self.clicks = 0
-        self.sprite_index = 0
-        #mcrfpy.registerPyAction("testaction", self.click)
-        mcrfpy.registerPyAction("gridgen", self.gridgen)
-        #mcrfpy.registerPyAction("gridgen2", lambda: self.gridgen())
-        #mcrfpy.registerPyAction("animtest", lambda: self.createAnimation())
-        #mcrfpy.registerPyAction("animtest2", lambda: self.createAnimation2())
-        mcrfpy.registerPyAction("nextsp", lambda: self.changesprite(1))
-        mcrfpy.registerPyAction("prevsp", lambda: self.changesprite(-1))
-        mcrfpy.registerPyAction("skipsp", lambda: self.changesprite(16))
-        mcrfpy.unlockPlayerInput()
-        mcrfpy.setActiveGrid("demogrid")
-        self.gridgen()
-        self.updatehints()
-        mcrfpy.camFollow(True)
-        
-    def itemguis(self):
-        print(self.player.inventory)
-        items = ["Green Keycard", "Blue Keycard", "Red Keycard", "Orange Keycard", "Devil Keycard"]
-        for mn in range(6, 11):
-            self.menus[mn].visible = items[mn-6] in self.player.inventory
-            mcrfpy.modMenu(self.menus[mn])
-
-    def animate_entity(self, direction, attacking=False):
-        if direction is None:
-            direction = self.entity_direction
-        else:
-            self.entity_direction = direction
-        
-        dragon_sprite = 545 + (32 * (direction + (4 if attacking else 0)))
-        dragon_animation = [dragon_sprite + i for i in range((5 if attacking else 4))]
-        mcrfpy.createAnimation(
-            1.0, # duration, seconds
-            "demogrid", # parent: a UIMenu or Grid key
-            "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-            0, # target id: integer index for menu or grid objs; None for grid/menu
-            "sprite", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-            lambda: self.animation_done("demobox1"), #callback: callable once animation is complete
-            False, #loop: repeat indefinitely
-            dragon_animation # values: iterable of frames for 'sprite', lerp target for others
-        )
-        
-        orc_sprite = 1538 + (64 * (direction + (4 if attacking else 0)))
-        orc_animation = [orc_sprite + i for i in range((5 if attacking else 4))]
-        mcrfpy.createAnimation(
-            1.0, # duration, seconds
-            "demogrid", # parent: a UIMenu or Grid key
-            "entity", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-             1, # target id: integer index for menu or grid objs; None for grid/menu
-             "sprite", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-             lambda: self.animation_done("demobox1"), #callback: callable once animation is complete
-             False, #loop: repeat indefinitely
-             orc_animation # values: iterable of frames for 'sprite', lerp target for others
-        )
-        
-    #def move_entity(self, targetgrid, entity_index, position):
-    #    for i, g in enumerate(self.grids):
-    #        if g.title == targetgrid:
-    #            g.entities[entity_index].x = position[0]
-    #            g.entities[entity_index].y = position[1]
-    #            #pts = g.points
-    #            g.visible = True
-    #            mcrfpy.modGrid(g)
-    #            self.grids = mcrfpy.listGrids()
-    #            #self.grids[i].points = pts
-    #            return
-        
-        
-    def changesprite(self, n):
-        self.sprite_index += n
-        self.menus[0].captions[0].text = f"Sprite #{self.sprite_index}"
-        self.menus[0].sprites[0].sprite_index = self.sprite_index
-        mcrfpy.modMenu(self.menus[0])
-        
-    def click(self):
-        self.clicks += 1
-        self.menus[0].captions[0].text = f"Clicks: {self.clicks}"
-        self.menus[0].sprites[0].sprite_index = randint(0, 3)
-        mcrfpy.modMenu(self.menus[0])
-        
-    def updatehints(self):
-        self.menus[2].captions[0].text=mcrfpy.activeGrid()
-        mcrfpy.modMenu(self.menus[2])
-        
-        self.menus[3].captions[0].text=mcrfpy.inputMode()
-        mcrfpy.modMenu(self.menus[3])
-        #self.menus[4].captions[0].text=f"follow: {mcrfpy.camFollow()}"
-        
-        self.menus[4].captions[0].text="following" if mcrfpy.camFollow() else "free"
-        mcrfpy.modMenu(self.menus[4])
-        
-        self.menus[5].visible = not mcrfpy.camFollow()
-        mcrfpy.modMenu(self.menus[5])
-        
-
-    def gridgen(self):
-        
-        #print(f"[Python] modifying {len(self.grids[0].points)} grid points")
-        for p in self.grids[0].points:
-            #p.color = (randint(0, 255), randint(64, 192), 0)
-            p.color = (0,0,0)
-            p.walkable = False
-            p.transparent = False
-            
-        room_centers = [(randint(0, self.grids[0].grid_x-1), randint(0, self.grids[0].grid_y-1)) for i in range(20)] + [(17, 3), (20,10) + (20,5)]
-        #room_centers.append((3, 5))
-        for r in room_centers:
-            # random hallway
-            target = choice(room_centers)
-            length1 = abs(target[0] - r[0])
-            
-            xbase = min(target[0], r[0])
-            for x in range(length1):
-                gpoint = self.grids[0].at(x, r[1])
-                if gpoint is None: continue
-                gpoint.walkable = True
-                gpoint.transparent = True
-                gpoint.color = (192, 192, 192)
-            
-            length2 = abs(target[1] - r[1])
-            ybase = min(target[1], r[1])
-            for y in range(length2):
-                gpoint = self.grids[0].at(r[0], y)
-                if gpoint is None: continue
-                gpoint.walkable = True
-                gpoint.transparent = True
-                gpoint.color = (192, 192, 192)
-                
-        for r in room_centers:
-            #print(r)
-            room_color = (randint(16, 24)*8, randint(16, 24)*8, randint(16, 24)*8)
-            #self.grids[0].at(r[0], r[1]).walkable = True
-            #self.grids[0].at(r[0], r[1]).color = room_color
-            halfx, halfy = randint(2, 11), randint(2,11)
-            for p_x in range(r[0] - halfx, r[0] + halfx):
-                for p_y in range(r[1] - halfy, r[1] + halfy):
-                    gpoint = self.grids[0].at(p_x, p_y)
-                    if gpoint is None: continue
-                    gpoint.walkable = True
-                    gpoint.transparent = True
-                    gpoint.color = room_color
-            #print()
-                    
-        #print("[Python] Modifying:")
-        self.grids[0].at(10, 10).color = (255, 255, 255)
-        self.grids[0].at(10, 10).walkable = False
-        self.grids[0].visible = True
-        mcrfpy.modGrid(self.grids[0])
-        #self.grids = mcrfpy.listGrids()
-        #print(f"Sent grid: {repr(self.grids[0])}")
-        #print(f"Received grid: {repr(mcrfpy.listGrids()[0])}")
-        
-    def animation_done(self, s):
-        print(f"The `{s}` animation completed.")
-        #self.menus = mcrfpy.listMenus()
-        
-    # if (!PyArg_ParseTuple(args, "fsssiOOO", &duration, &parent, &target_type, &target_id, &field, &callback, &loop_obj, &values_obj)) return NULL;
-    def createAnimation(self):
-        print(self.menus)
-        self.menus = mcrfpy.listMenus()
-        self.menus[0].w = 500
-        self.menus[0].h = 200
-        print(self.menus)
-        mcrfpy.modMenu(self.menus[0])
-        print(self.menus)
-        mcrfpy.createAnimation(
-            3.0, # duration, seconds
-            "demobox1", # parent: a UIMenu or Grid key
-            "menu", # target type: 'menu', 'grid', 'caption', 'button', 'sprite', or 'entity'
-            0, # target id: integer index for menu or grid objs; None for grid/menu
-            "size", # field: 'position', 'size', 'bgcolor', 'textcolor', or 'sprite'
-            lambda: self.animation_done("demobox1"), #callback: callable once animation is complete
-            False, #loop: repeat indefinitely
-            [150, 100] # values: iterable of frames for 'sprite', lerp target for others
-        )
-        
-    def createAnimation2(self):
-        mcrfpy.createAnimation(
-            5,
-            "demobox1",
-            "sprite",
-            0,
-            "sprite",
-            lambda: self.animation_done("sprite change"),
-            False,
-            [0, 1, 2, 1, 2, 0]
-        )
-
-def keytest():
-    print("Key tested.")
-
-def keyregistration():
-    print("Registering 'keytest'")
-    mcrfpy.registerPyAction("keytest", keytest)
-    print("Registering input")
-    print(mcrfpy.registerInputAction(15, "keytest")) # 15 = P
-    
-    mcrfpy.registerPyAction("player_move_up", lambda: scene.player.move(0, -1))
-    mcrfpy.registerPyAction("player_move_left", lambda: scene.player.move(-1, 0))
-    mcrfpy.registerPyAction("player_move_down", lambda: scene.player.move(0, 1))
-    mcrfpy.registerPyAction("player_move_right", lambda: scene.player.move(1, 0))
-    
-    mcrfpy.registerInputAction(ord('w') - ord('a'), "player_move_up")
-    mcrfpy.registerInputAction(ord('a') - ord('a'), "player_move_left")
-    mcrfpy.registerInputAction(ord('s') - ord('a'), "player_move_down")
-    mcrfpy.registerInputAction(ord('d') - ord('a'), "player_move_right")
-    
-
-def start():
-    global scene
-    #print("TestScene.start called")
-    scene = TestScene()
-    mcrfpy.refreshFov()
-    
-    
-    scene.updatehints()

src/scripts/UIMenu.py

@@ -1,48 +0,0 @@
-class Caption:
-    def __init__(self, text, textsize, color):
-        self.text = text
-        self.textsize = textsize
-        self.color = color
-
-    def __repr__(self):
-        return f"<Caption text={self.text}, textsize={self.textsize}, color={self.color}>"
-
-class Button:
-    def __init__(self, x, y, w, h, bgcolor, textcolor, text, actioncode):
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.bgcolor = bgcolor
-        self.textcolor = textcolor
-        self.text = text
-        self.actioncode = actioncode
-
-    def __repr__(self):
-        return f"<Button ({self.x}, {self.y}, {self.w}, {self.h}), bgcolor={self.bgcolor}, textcolor={self.textcolor}, actioncode={self.actioncode}>"
-
-class Sprite:
-    def __init__(self, tex_index, sprite_index, x, y):
-        self.tex_index = tex_index
-        self.sprite_index = sprite_index
-        self.x = x
-        self.y = y
-
-    def __repr__(self):
-        return f"<Sprite tex_index={self.tex_index}, self.sprite_index={self.sprite_index}, x={self.x}, y={self.y}>"
-
-class UIMenu:
-    def __init__(self, title, x, y, w, h, bgcolor, visible=False):
-        self.title = title
-        self.x = x
-        self.y = y
-        self.w = w
-        self.h = h
-        self.bgcolor = bgcolor
-        self.visible = visible
-        self.captions = []
-        self.buttons = []
-        self.sprites = []
-
-    def __repr__(self):
-        return f"<UIMenu title={repr(self.title)}, x={self.x}, y={self.y}, w={self.w}, h={self.h}, bgcolor={self.bgcolor}, visible={self.visible}, {len(self.captions)} captions, {len(self.buttons)} buttons, {len(self.sprites)} sprites>"

src/scripts/cos_play.py

@@ -0,0 +1,300 @@
+import mcrfpy
+mcrfpy.createScene("play")
+ui = mcrfpy.sceneUI("play")
+t = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 16) # 12, 11)
+font = mcrfpy.Font("assets/JetbrainsMono.ttf")
+
+frame_color = (64, 64, 128)
+
+grid = mcrfpy.Grid(20, 15, t, 10, 10, 800, 595)
+grid.zoom = 2.0
+entity_frame = mcrfpy.Frame(815, 10, 194, 595, fill_color = frame_color)
+inventory_frame = mcrfpy.Frame(10, 610, 800, 143, fill_color = frame_color)
+stats_frame = mcrfpy.Frame(815, 610, 194, 143, fill_color = frame_color)
+
+begin_btn = mcrfpy.Frame(350,250,100,100, fill_color = (255,0,0))
+begin_btn.children.append(mcrfpy.Caption(5, 5, "Begin", font))
+def cos_keys(key, state):
+    if key == 'M' and state == 'start':
+        mapgen()
+    elif state == "end": return
+    elif key == "W":
+        player.move("N")
+    elif key == "A":
+        player.move("W")
+    elif key == "S":
+        player.move("S")
+    elif key == "D":
+        player.move("E")
+
+
+def cos_init(*args):
+    if args[3] != "start": return
+    mcrfpy.keypressScene(cos_keys)
+    ui.remove(4)
+    
+begin_btn.click = cos_init
+
+[ui.append(e) for e in (grid, entity_frame, inventory_frame, stats_frame, begin_btn)]
+
+import random
+def rcolor():
+    return tuple([random.randint(0, 255) for i in range(3)]) # TODO list won't work with GridPoint.color, so had to cast to tuple
+
+x_max, y_max = grid.grid_size
+for x in range(x_max):
+    for y in range(y_max):
+        grid.at((x,y)).color = rcolor()
+
+from math import pi, cos, sin
+def mapgen(room_size_max = 7, room_size_min = 3, room_count = 4):
+    # reset map
+    for x in range(x_max):
+        for y in range(y_max):
+            grid.at((x, y)).walkable = False
+            grid.at((x, y)).transparent= False
+            grid.at((x,y)).tilesprite = random.choices([40, 28], weights=[.8, .2])[0]
+    global cos_entities
+    for e in cos_entities:
+        e.e.position = (999,999) # TODO
+        e.die()
+    cos_entities = []
+
+    #Dungeon generation
+    centers = []
+    attempts = 0
+    while len(centers) < room_count:
+    # Leaving this attempt here for later comparison. These rooms sucked.
+    # overlapping, uninteresting hallways, crowded into the corners sometimes, etc.
+        attempts += 1
+        if attempts > room_count * 15: break
+    #    room_left = random.randint(1, x_max)
+    #    room_top = random.randint(1, y_max)
+
+    # Take 2 - circular distribution of rooms
+        angle_mid = (len(centers) / room_count) * 2 * pi + 0.785
+        angle = random.uniform(angle_mid - 0.25, angle_mid + 0.25)
+        radius = random.uniform(3, 14)
+        room_left = int(radius * cos(angle)) + int(x_max/2)
+        if room_left <= 1: room_left = 1
+        if room_left > x_max - 1: room_left = x_max - 2
+        room_top = int(radius * sin(angle)) + int(y_max/2)
+        if room_top <= 1: room_top = 1
+        if room_top > y_max - 1: room_top = y_max - 2
+        room_w = random.randint(room_size_min, room_size_max)
+        if room_w + room_left >= x_max: room_w = x_max - room_left - 2
+        room_h = random.randint(room_size_min, room_size_max)
+        if room_h + room_top >= y_max: room_h = y_max - room_top - 2
+        #print(room_left, room_top, room_left + room_w, room_top + room_h)
+        if any( # centers contained in this randomly generated room
+            [c[0] >= room_left and c[0] <= room_left + room_w and c[1] >= room_top and c[1] <= room_top + room_h for c in centers]
+            ):
+            continue # re-randomize the room position
+        centers.append(
+                (int(room_left + (room_w/2)), int(room_top + (room_h/2)))
+                )
+
+        for x in range(room_w):
+            for y in range(room_h):
+                grid.at((room_left+x, room_top+y)).walkable=True
+                grid.at((room_left+x, room_top+y)).transparent=True
+                grid.at((room_left+x, room_top+y)).tilesprite = random.choice([48, 49, 50, 51, 52, 53])
+
+        # generate a boulder
+        if (room_w > 2 and room_h > 2):
+            room_boulder_x, room_boulder_y = random.randint(room_left+1, room_left+room_w-1), random.randint(room_top+1, room_top+room_h-1)
+            cos_entities.append(BoulderEntity(room_boulder_x, room_boulder_y))
+
+    print(f"{room_count} rooms generated after {attempts} attempts.")
+    #print(centers)
+    # hallways
+    pairs = []
+    for c1 in centers:
+        for c2 in centers:
+            if c1 == c2: continue
+            if (c2, c1) in pairs or (c1, c2) in pairs: continue
+            left = min(c1[0], c2[0])
+            right = max(c1[0], c2[0])
+            top = min(c1[1], c2[1])
+            bottom = max(c1[1], c2[1])
+
+            corners = [(left, top), (left, bottom), (right, top), (right, bottom)]
+            corners.remove(c1)
+            corners.remove(c2)
+            random.shuffle(corners)
+            target, other = corners
+            for x in range(target[0], other[0], -1 if target[0] > other[0] else 1):
+                was_walkable = grid.at((x, target[1])).walkable
+                grid.at((x, target[1])).walkable=True
+                grid.at((x, target[1])).transparent=True
+                if not was_walkable:
+                    grid.at((x, target[1])).tilesprite = random.choices([0, 12, 24], weights=[.6, .3, .1])[0]
+            for y in range(target[1], other[1], -1 if target[1] > other[1] else 1):
+                was_walkable = grid.at((target[0], y)).walkable
+                grid.at((target[0], y)).walkable=True
+                grid.at((target[0], y)).transparent=True
+                if not was_walkable:
+                    grid.at((target[0], y)).tilesprite = random.choices([0, 12, 24], weights=[0.4, 0.3, 0.3])[0]
+            pairs.append((c1, c2))
+
+
+    # spawn exit and button
+    spawn_points = []
+    for x in range(x_max):
+        for y in range(y_max):
+            if grid.at((x, y)).walkable:
+                spawn_points.append((x, y))
+    random.shuffle(spawn_points)
+    door_spawn, button_spawn = spawn_points[:2]
+    cos_entities.append(ExitEntity(*door_spawn, *button_spawn))
+
+    # respawn player
+    global player
+    if player:
+        player.position = (999,999) # TODO - die() is broken and I don't know why 
+    player = PlayerEntity()
+
+
+    #for x in range(x_max):
+    #    for y in range(y_max):
+    #        if grid.at((x, y)).walkable:
+    #            #grid.at((x,y)).tilesprite = random.choice([48, 49, 50, 51, 52, 53])
+    #            pass
+    #        else:
+    #            #grid.at((x,y)).tilesprite = random.choices([40, 28], weights=[.8, .2])[0]
+
+#131 - last sprite
+#123, 124 - brown, grey rats
+#121 - ghost
+#114, 115, 116 - green, red, blue potion
+#102 - shield
+#98 - low armor guy, #97 - high armor guy
+#89 - chest, #91 - empty chest
+#84 - wizard
+#82 - barrel
+#66 - boulder
+#64, 65 - graves
+#48 - 53: ground (not going to figure out how they fit together tonight)
+#42 - button-looking ground
+#40 - basic solid wall
+#36, 37, 38 - wall (left, middle, right)
+#28 solid wall but with a grate
+#21 - wide open door, 33 medium open, 45 closed door
+#0 - basic dirt
+class MyEntity:
+    def __init__(self, x=0, y=0, sprite_num=86):
+        self.e = mcrfpy.Entity(x, y, t, sprite_num)
+        grid.entities.append(self.e)
+    def die(self):
+        for i in range(len(grid.entities)):
+            e = grid.entities[i]
+            if e == self.e:
+                grid.entities.remove(i)
+                break
+    def bump(self, other, dx, dy):
+        raise NotImplementedError
+
+    def try_move(self, dx, dy):
+        tx, ty = int(self.e.position[0] + dx), int(self.e.position[1] + dy)
+        for e in cos_entities:
+            if e.e.position == (tx, ty):
+                #print(f"bumping {e}")
+                return e.bump(self, dx, dy)
+        if tx < 0 or tx >= x_max:
+            #print("out of bounds horizontally")
+            return False
+        if ty < 0 or ty >= y_max:
+            #print("out of bounds vertically")
+            return False
+        if grid.at((tx, ty)).walkable == True:
+            #print("Motion!")
+            self.e.position = (tx, ty)
+            return True
+        else:
+            #print("Bonk")
+            return False
+
+    def _relative_move(self, dx, dy):
+        tx, ty = int(self.e.position[0] + dx), int(self.e.position[1] + dy)
+        self.e.position = (tx, ty)
+
+
+    def move(self, direction):
+        if direction == "N":
+            self.try_move(0, -1)
+        elif direction == "E":
+            self.try_move(1, 0)
+        elif direction == "S":
+            self.try_move(0, 1)
+        elif direction == "W":
+            self.try_move(-1, 0)
+
+cos_entities = []
+
+class PlayerEntity(MyEntity):
+    def __init__(self):
+        # find spawn point
+        spawn_points = []
+        for x in range(x_max):
+            for y in range(y_max):
+                if grid.at((x, y)).walkable:
+                    spawn_points.append((x, y))
+        random.shuffle(spawn_points)
+        for spawn in spawn_points:
+            for e in cos_entities:
+                if e.e.position == spawn: break
+            else:
+                break
+
+        #print(f"spawn at {spawn}")
+        super().__init__(spawn[0], spawn[1], sprite_num=84)
+
+class BoulderEntity(MyEntity):
+    def __init__(self, x, y):
+        super().__init__(x, y, 66)
+
+    def bump(self, other, dx, dy):
+        if type(other) == BoulderEntity:
+            #print("Boulders can't push boulders")
+            return False
+        tx, ty = int(self.e.position[0] + dx), int(self.e.position[1] + dy)
+        # Is the boulder blocked the same direction as the bumper? If not, let's both move
+        old_pos = int(self.e.position[0]), int(self.e.position[1])
+        if self.try_move(dx, dy):
+            other.e.position = old_pos
+            return True
+
+class ButtonEntity(MyEntity):
+    def __init__(self, x, y, exit):
+        super().__init__(x, y, 42)
+        self.exit = exit
+
+    def bump(self, other, dx, dy):
+        if type(other) == BoulderEntity:
+            self.exit.unlock()
+        other._relative_move(dx, dy)
+        return True
+
+class ExitEntity(MyEntity):
+    def __init__(self, x, y, bx, by):
+        super().__init__(x, y, 45)
+        self.my_button = ButtonEntity(bx, by, self)
+        self.unlocked = False
+        global cos_entities
+        cos_entities.append(self.my_button)
+
+    def unlock(self):
+        self.e.sprite_number = 21
+        self.unlocked = True
+
+    def lock(self):
+        self.e.sprite_number = 45
+        self.unlocked = True
+
+    def bump(self, other, dx, dy):
+        if type(other) == BoulderEntity:
+            return False
+        if self.unlocked:
+            other._relative_move(dx, dy)
+
+player = None

src/scripts/engine_user.py

@@ -1,10 +0,0 @@
-print("[Python] Attempting import")
-import scriptable
-
-print(f"[Python] calling fibonacci(8): {scriptable.fibonacci(8)}")
-print(f"[Python] calling fibonacci(15): {scriptable.fibonacci(15)}")
-
-import venv
-print("[Python] Importing library installed with pip")
-import numpy
-

src/scripts/game.py

@@ -0,0 +1,60 @@
+import mcrfpy
+font = mcrfpy.Font("assets/JetbrainsMono.ttf")
+texture = mcrfpy.Texture("assets/kenney_tinydungeon.png", 16, 16)
+
+print("[game.py] Default texture:")
+print(mcrfpy.default_texture)
+print(type(mcrfpy.default_texture))
+
+# build test widgets
+
+mcrfpy.createScene("pytest")
+mcrfpy.setScene("pytest")
+ui = mcrfpy.sceneUI("pytest")
+
+# Frame
+f = mcrfpy.Frame(25, 19, 462, 346, fill_color=(255, 92, 92))
+print("Frame alive")
+# fill (LinkedColor / Color):    f.fill_color
+# outline (LinkedColor / Color): f.outline_color
+# pos (LinkedVector / Vector):   f.pos
+# size (LinkedVector / Vector):  f.size
+
+# Caption
+print("Caption attempt w/ fill_color:")
+#c = mcrfpy.Caption(512+25, 19, "Hi.", font)
+#c = mcrfpy.Caption(512+25, 19, "Hi.", font, 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
+s = mcrfpy.Sprite(25, 384+19, texture, 86, 9.0)
+# pos (LinkedVector / Vector):   s.pos
+# texture (Texture):             s.texture
+
+# Grid
+g = mcrfpy.Grid(10, 10, texture, 512+25, 384+19, 462, 346)
+# 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)]
+
+print("built!")
+
+# tests
+

src/scripts/game_old.py

@@ -0,0 +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) #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

src/scripts/test_ui.py

@@ -1,37 +0,0 @@
-import mcrfpy
-mcrfpy.createTexture("./assets/test_portraits.png", 32, 8, 8)
-from random import choice, randint
-
-box_colors = [
-	(0, 0, 192),
-	(0, 192, 0),
-	(192, 0, 0),
-	(192, 192, 0),
-	(0, 192, 192),
-	(192, 0, 192)
-	]
-
-text_colors = [
-	(0, 0, 255),
-	(0, 255, 0),
-	(255, 0, 0),
-	(255, 255, 0),
-	(0, 255, 255),
-	(255, 0, 255)
-	]
-
-test_x = 500
-test_y = 10
-for i in range(40):
-	ui_name = f"test{i}"
-	mcrfpy.createMenu(ui_name, test_x, test_y, 400, 200)
-	mcrfpy.createCaption(ui_name, "Hello There", 18, choice(text_colors))
-	mcrfpy.createButton(ui_name, 250, 20, 100, 50, choice(box_colors), (0, 0, 0), "asdf", "testaction")
-	
-	mcrfpy.createSprite(ui_name, 0, randint(0, 3), 650, 60, 5.0)
-
-	test_x -= 50
-	test_y += 50
-	if (test_x <= 50):
-		test_x = 500
-	#print(test_x)

wikicrayons_colors.txt

@@ -0,0 +1,168 @@
+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

@@ -0,0 +1,949 @@
+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