hotfix: bad documentation links... ...because of trailing slash?!

Author: John McCardle <mccardle.john@gmail.com>
Co-Authored-By: Claude <noreply@anthropic.com>

commit dc47f2474c7b2642d368f9772894aed857527807
    the UIEntity rant

commit 673ca8e1b089ea670257fc04ae1a676ed95a40ed
    I forget when these tests were written, but I want them in the squash merge

commit 70c71565c684fa96e222179271ecb13a156d80ad
    Fix UI object segfault by switching from managed to manual weakref management

    The UI types (Frame, Caption, Sprite, Grid, Entity) were using
    Py_TPFLAGS_MANAGED_WEAKREF while also trying to manually create weakrefs
    for the PythonObjectCache. This is fundamentally incompatible - when
    Python manages weakrefs internally, PyWeakref_NewRef() cannot access the
    weakref list properly, causing segfaults.

    Changed all UI types to use manual weakref management (like PyTimer):
    - Restored weakreflist field in all UI type structures
    - Removed Py_TPFLAGS_MANAGED_WEAKREF from all UI type flags
    - Added tp_weaklistoffset for all UI types in module initialization
    - Initialize weakreflist=NULL in tp_new and init methods
    - Call PyObject_ClearWeakRefs() in dealloc functions

    This allows the PythonObjectCache to continue working correctly,
    maintaining Python object identity for C++ objects across the boundary.

    Fixes segfault when creating UI objects (e.g., Caption, Grid) that was
    preventing tutorial scripts from running.

This is the bulk of the required behavior for Issue #126.
that issure isn't ready for closure yet; several other sub-issues left.
    closes #110
    mention issue #109 - resolves some __init__ related nuisances

commit 3dce3ec539ae99e32d869007bf3f49d03e4e2f89
    Refactor timer system for cleaner architecture and enhanced functionality

    Major improvements to the timer system:
    - Unified all timer logic in the Timer class (C++)
    - Removed PyTimerCallable subclass, now using PyCallable directly
    - Timer objects are now passed to callbacks as first argument
    - Added 'once' parameter for one-shot timers that auto-stop
    - Implemented proper PythonObjectCache integration with weakref support

    API enhancements:
    - New callback signature: callback(timer, runtime) instead of just (runtime)
    - Timer objects expose: name, interval, remaining, paused, active, once properties
    - Methods: pause(), resume(), cancel(), restart()
    - Comprehensive documentation with examples
    - Enhanced repr showing timer state (active/paused/once/remaining time)

    This cleanup follows the UIEntity/PyUIEntity pattern and makes the timer
    system more Pythonic while maintaining backward compatibility through
    the legacy setTimer/delTimer API.

    closes #121

commit 145834cfc31b8dabc4cb3591b9cb4ed99fc8b964
    Implement Python object cache to preserve derived types in collections

    Add a global cache system that maintains weak references to Python objects,
    ensuring that derived Python classes maintain their identity when stored in
    and retrieved from C++ collections.

    Key changes:
    - Add PythonObjectCache singleton with serial number system
    - Each cacheable object (UIDrawable, UIEntity, Timer, Animation) gets unique ID
    - Cache stores weak references to prevent circular reference memory leaks
    - Update all UI type definitions to support weak references (Py_TPFLAGS_MANAGED_WEAKREF)
    - Enable subclassing for all UI types (Py_TPFLAGS_BASETYPE)
    - Collections check cache before creating new Python wrappers
    - Register objects in cache during __init__ methods
    - Clean up cache entries in C++ destructors

    This ensures that Python code like:
    ```python
    class MyFrame(mcrfpy.Frame):
        def __init__(self):
            super().__init__()
            self.custom_data = "preserved"

    frame = MyFrame()
    scene.ui.append(frame)
    retrieved = scene.ui[0]  # Same MyFrame instance with custom_data intact
    ```

    Works correctly, with retrieved maintaining the derived type and custom attributes.

    Closes #112

commit c5e7e8e298
    Update test demos for new Python API and entity system

    - Update all text input demos to use new Entity constructor signature
    - Fix pathfinding showcase to work with new entity position handling
    - Remove entity_waypoints tracking in favor of simplified movement
    - Delete obsolete exhaustive_api_demo.py (superseded by newer demos)
    - Adjust entity creation calls to match Entity((x, y), texture, sprite_index) pattern

commit 6d29652ae7
    Update animation demo suite with crash fixes and improvements

    - Add warnings about AnimationManager segfault bug in sizzle_reel_final.py
    - Create sizzle_reel_final_fixed.py that works around the crash by hiding objects instead of removing them
    - Increase font sizes for better visibility in demos
    - Extend demo durations for better showcase of animations
    - Remove debug prints from animation_sizzle_reel_working.py
    - Minor cleanup and improvements to all animation demos

commit a010e5fa96
    Update game scripts for new Python API

    - Convert entity position access from tuple to x/y properties
    - Update caption size property to font_size
    - Fix grid boundary checks to use grid_size instead of exceptions
    - Clean up demo timer on menu exit to prevent callbacks

    These changes adapt the game scripts to work with the new standardized
    Python API constructors and property names.

commit 9c8d6c4591
    Fix click event z-order handling in PyScene

    Changed click detection to properly respect z-index by:
    - Sorting ui_elements in-place when needed (same as render order)
    - Using reverse iterators to check highest z-index elements first
    - This ensures top-most elements receive clicks before lower ones

commit dcd1b0ca33
    Add roguelike tutorial implementation files

    Implement Parts 0-2 of the classic roguelike tutorial adapted for McRogueFace:
    - Part 0: Basic grid setup and tile rendering
    - Part 1: Drawing '@' symbol and basic movement
    - Part 1b: Variant with sprite-based player
    - Part 2: Entity system and NPC implementation with three movement variants:
      - part_2.py: Standard implementation
      - part_2-naive.py: Naive movement approach
      - part_2-onemovequeued.py: Queued movement system

    Includes tutorial assets:
    - tutorial2.png: Tileset for dungeon tiles
    - tutorial_hero.png: Player sprite sheet

commit 6813fb5129
    Standardize Python API constructors and remove PyArgHelpers

    - Remove PyArgHelpers.h and all macro-based argument parsing
    - Convert all UI class constructors to use PyArg_ParseTupleAndKeywords
    - Standardize constructor signatures across UICaption, UIEntity, UIFrame, UIGrid, and UISprite
    - Replace PYARGHELPER_SINGLE/MULTI macros with explicit argument parsing
    - Improve error messages and argument validation
    - Maintain backward compatibility with existing Python code

    This change improves code maintainability and consistency across the Python API.

commit 6f67fbb51e
    Fix animation callback crashes from iterator invalidation (#119)

    Resolved segfaults caused by creating new animations from within
    animation callbacks. The issue was iterator invalidation in
    AnimationManager::update() when callbacks modified the active
    animations vector.

    Changes:
    - Add deferred animation queue to AnimationManager
    - New animations created during update are queued and added after
    - Set isUpdating flag to track when in update loop
    - Properly handle Animation destructor during callback execution
    - Add clearCallback() method for safe cleanup scenarios

    This fixes the "free(): invalid pointer" and "malloc(): unaligned
    fastbin chunk detected" errors that occurred with rapid animation
    creation in callbacks.

commit eb88c7b3aa
    Add animation completion callbacks (#119)

    Implement callbacks that fire when animations complete, enabling direct
    causality between animation end and game state changes. This eliminates
    race conditions from parallel timer workarounds.

    - Add optional callback parameter to Animation constructor
    - Callbacks execute synchronously when animation completes
    - Proper Python reference counting with GIL safety
    - Callbacks receive (anim, target) parameters (currently None)
    - Exception handling prevents crashes from Python errors

    Example usage:
    ```python
    def on_complete(anim, target):
        player_moving = False

    anim = mcrfpy.Animation("x", 300.0, 1.0, "easeOut", callback=on_complete)
    anim.start(player)
    ```

    closes #119

commit 9fb428dd01
    Update ROADMAP with GitHub issue numbers (#111-#125)

    Added issue numbers from GitHub tracker to roadmap items:
    - #111: Grid Click Events Broken in Headless
    - #112: Object Splitting Bug (Python type preservation)
    - #113: Batch Operations for Grid
    - #114: CellView API
    - #115: SpatialHash Implementation
    - #116: Dirty Flag System
    - #117: Memory Pool for Entities
    - #118: Scene as Drawable
    - #119: Animation Completion Callbacks
    - #120: Animation Property Locking
    - #121: Timer Object System
    - #122: Parent-Child UI System
    - #123: Grid Subgrid System
    - #124: Grid Point Animation
    - #125: GitHub Issues Automation

    Also updated existing references:
    - #101/#110: Constructor standardization
    - #109: Vector class indexing

    Note: Tutorial-specific items and Python-implementable features
    (input queue, collision reservation) are not tracked as engine issues.

commit 062e4dadc4
    Fix animation segfaults with RAII weak_ptr implementation

    Resolved two critical segmentation faults in AnimationManager:
    1. Race condition when creating multiple animations in timer callbacks
    2. Exit crash when animations outlive their target objects

    Changes:
    - Replace raw pointers with std::weak_ptr for automatic target invalidation
    - Add Animation::complete() to jump animations to final value
    - Add Animation::hasValidTarget() to check if target still exists
    - Update AnimationManager to auto-remove invalid animations
    - Add AnimationManager::clear() call to GameEngine::cleanup()
    - Update Python bindings to pass shared_ptr instead of raw pointers

    This ensures animations can never reference destroyed objects, following
    proper RAII principles. Tested with sizzle_reel_final.py and stress
    tests creating/destroying hundreds of animated objects.

commit 98fc49a978
    Directory structure cleanup and organization overhaul

.gitignore

@@ -9,4 +9,25 @@ obj
 build
 lib
 obj
+__pycache__
 
+.cache/
+7DRL2025 Release/
+CMakeFiles/
+Makefile
+*.md
+*.zip
+__lib/
+_oldscripts/
+assets/
+cellular_automata_fire/
+*.txt
+deps/
+fetch_issues_txt.py
+forest_fire_CA.py
+mcrogueface.github.io
+scripts/
+test_*
+
+tcod_reference
+.archive

CMakeLists.txt

@@ -22,11 +22,6 @@ file(GLOB_RECURSE SOURCES "src/*.cpp")
 
 # Create a list of libraries to link against
 set(LINK_LIBS 
-    m 
-    dl 
-    util 
-    pthread 
-    python3.12 
     sfml-graphics 
     sfml-window 
     sfml-system 
@@ -35,22 +30,33 @@ set(LINK_LIBS
 
 # On Windows, add any additional libs and include directories
 if(WIN32)
+    # Windows-specific Python library name (no dots)
+    list(APPEND LINK_LIBS python312)
     # Add the necessary Windows-specific libraries and include directories
     # 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()
+    # Unix/Linux specific libraries
+    list(APPEND LINK_LIBS python3.12 m dl util pthread)
     include_directories(${CMAKE_SOURCE_DIR}/deps/platform/linux)
 endif()
 
 # Add the directory where the linker should look for the libraries
 #link_directories(${CMAKE_SOURCE_DIR}/deps_linux)
-link_directories(${CMAKE_SOURCE_DIR}/lib)
+link_directories(${CMAKE_SOURCE_DIR}/__lib)
 
 # Define the executable target before linking libraries
 add_executable(mcrogueface ${SOURCES})
 
+# On Windows, set subsystem to WINDOWS to hide console
+if(WIN32)
+    set_target_properties(mcrogueface PROPERTIES
+        WIN32_EXECUTABLE TRUE
+        LINK_FLAGS "/SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")
+endif()
+
 # Now the linker will find the libraries in the specified directory
 target_link_libraries(mcrogueface ${LINK_LIBS})
 
@@ -67,9 +73,28 @@ add_custom_command(TARGET mcrogueface POST_BUILD
 # Copy Python standard library to build directory
 add_custom_command(TARGET mcrogueface POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_directory
-    ${CMAKE_SOURCE_DIR}/lib $<TARGET_FILE_DIR:mcrogueface>/lib)
+    ${CMAKE_SOURCE_DIR}/__lib $<TARGET_FILE_DIR:mcrogueface>/lib)
 
-# rpath for including shared libraries
-set_target_properties(mcrogueface PROPERTIES
-                      INSTALL_RPATH "./lib")
+# On Windows, copy DLLs to executable directory
+if(WIN32)
+    # Copy all DLL files from lib to the executable directory
+    add_custom_command(TARGET mcrogueface POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_directory
+        ${CMAKE_SOURCE_DIR}/__lib $<TARGET_FILE_DIR:mcrogueface>
+        COMMAND ${CMAKE_COMMAND} -E echo "Copied DLLs to executable directory")
+        
+    # Alternative: Copy specific DLLs if you want more control
+    # file(GLOB DLLS "${CMAKE_SOURCE_DIR}/__lib/*.dll")
+    # foreach(DLL ${DLLS})
+    #     add_custom_command(TARGET mcrogueface POST_BUILD
+    #         COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    #         ${DLL} $<TARGET_FILE_DIR:mcrogueface>)
+    # endforeach()
+endif()
+
+# rpath for including shared libraries (Linux/Unix only)
+if(NOT WIN32)
+    set_target_properties(mcrogueface PROPERTIES
+                          INSTALL_RPATH "$ORIGIN/./lib")
+endif()
 

GNUmakefile

@@ -0,0 +1,54 @@
+# Convenience Makefile wrapper for McRogueFace
+# This delegates to CMake build in the build directory
+
+.PHONY: all build clean run test dist help
+
+# Default target
+all: build
+
+# Build the project
+build:
+	@./build.sh
+
+# Clean build artifacts  
+clean:
+	@./clean.sh
+
+# Run the game
+run: build
+	@cd build && ./mcrogueface
+
+# Run in Python mode
+python: build
+	@cd build && ./mcrogueface -i
+
+# Test basic functionality
+test: build
+	@echo "Testing McRogueFace..."
+	@cd build && ./mcrogueface -V
+	@cd build && ./mcrogueface -c "print('Test passed')"
+	@cd build && ./mcrogueface --headless -c "import mcrfpy; print('mcrfpy imported successfully')"
+
+# Create distribution archive
+dist: build
+	@echo "Creating distribution archive..."
+	@cd build && zip -r ../McRogueFace-$$(date +%Y%m%d).zip . -x "*.o" "CMakeFiles/*" "Makefile" "*.cmake"
+	@echo "Distribution archive created: McRogueFace-$$(date +%Y%m%d).zip"
+
+# Show help
+help:
+	@echo "McRogueFace Build System"
+	@echo "======================="
+	@echo ""
+	@echo "Available targets:"
+	@echo "  make          - Build the project (default)"
+	@echo "  make build    - Build the project"
+	@echo "  make clean    - Remove all build artifacts"
+	@echo "  make run      - Build and run the game"
+	@echo "  make python   - Build and run in Python interactive mode"
+	@echo "  make test     - Run basic tests"
+	@echo "  make dist     - Create distribution archive"
+	@echo "  make help     - Show this help message"
+	@echo ""
+	@echo "Build output goes to: ./build/"
+	@echo "Distribution archives are created in project root"

README.md

@@ -1,30 +1,127 @@
-# McRogueFace - 2D Game Engine
-
-An experimental prototype game engine built for my own use in 7DRL 2023.
-
+# McRogueFace
 *Blame my wife for the name*
 
-## Tenets:
+A Python-powered 2D game engine for creating roguelike games, built with C++ and SFML.
 
-* C++ first, Python close behind.
-* Entity-Component system based on David Churchill's Memorial University COMP4300 course lectures available on Youtube.
-* Graphics, particles and shaders provided by SFML.
-* Pathfinding, noise generation, and other Roguelike goodness provided by TCOD.
+* Core roguelike logic from libtcod: field of view, pathfinding
+* Animate sprites with multiple frames. Smooth transitions for positions, sizes, zoom, and camera
+* Simple GUI element system allows keyboard and mouse input, composition
+* No compilation or installation necessary. The runtime is a full Python environment; "Zip And Ship"
 
-## Why?
+![ Image ]()
 
-I did the r/RoguelikeDev TCOD tutorial in Python. I loved it, but I did not want to be limited to ASCII. I want to be able to draw pixels on top of my tiles (like lines or circles) and eventually incorporate even more polish.
+**Pre-Alpha Release Demo**: my 7DRL 2025 entry *"Crypt of Sokoban"* - a prototype with buttons, boulders, enemies, and items.
 
-## To-do
+## Quick Start
 
-* ✅ Initial Commit
-* ✅ Integrate scene, action, entity, component system from COMP4300 engine
-* ✅ Windows / Visual Studio project
-* ✅ Draw Sprites
-* ✅ Play Sounds
-* ✅ Draw UI, spawn entity from Python code
-* ❌ Python AI for entities (NPCs on set paths, enemies towards player)
-* ✅ Walking / Collision
-* ❌ "Boards" (stairs / doors / walk off edge of screen)
-* ❌ Cutscenes - interrupt normal controls, text scroll, character portraits
-* ❌ Mouse integration - tooltips, zoom, click to select targets, cursors
+**Download**: 
+
+- The entire McRogueFace visual framework:
+  - **Sprite**: an image file or one sprite from a shared sprite sheet
+  - **Caption**: load a font, display text
+  - **Frame**: A rectangle; put other things on it to move or manage GUIs as modules
+  - **Grid**: A 2D array of tiles with zoom + position control
+  - **Entity**: Lives on a Grid, displays a sprite, and can have a perspective or move along a path
+  - **Animation**: Change any property on any of the above over time
+
+```bash
+# Clone and build
+git clone <wherever you found this repo>
+cd McRogueFace
+make
+
+# Run the example game
+cd build
+./mcrogueface
+```
+
+## Example: Creating a Simple Scene
+
+```python
+import mcrfpy
+
+# Create a new scene
+mcrfpy.createScene("intro")
+
+# Add a text caption
+caption = mcrfpy.Caption((50, 50), "Welcome to McRogueFace!")
+caption.size = 48 
+caption.fill_color = (255, 255, 255)
+
+# Add to scene
+mcrfpy.sceneUI("intro").append(caption)
+
+# Switch to the scene
+mcrfpy.setScene("intro")
+```
+
+## Documentation
+
+### 📚 Full Documentation Site
+
+For comprehensive documentation, tutorials, and API reference, visit:
+**[https://mcrogueface.github.io](https://mcrogueface.github.io)**
+
+The documentation site includes:
+
+- **[Quickstart Guide](https://mcrogueface.github.io/quickstart)** - Get running in 5 minutes
+- **[McRogueFace Does The Entire Roguelike Tutorial](https://mcrogueface.github.io/tutorials)** - Step-by-step game building
+- **[Complete API Reference](https://mcrogueface.github.io/api)** - Every function documented
+- **[Cookbook](https://mcrogueface.github.io/cookbook)** - Ready-to-use code recipes
+- **[C++ Extension Guide](https://mcrogueface.github.io/extending-cpp)** - For C++ developers: Add engine features
+
+## Build Requirements
+
+- C++17 compiler (GCC 7+ or Clang 5+)
+- CMake 3.14+
+- Python 3.12+
+- SFML 2.6
+- Linux or Windows (macOS untested)
+
+## Project Structure
+
+```
+McRogueFace/
+├── assets/        # Sprites, fonts, audio
+├── build/         # Build output directory: zip + ship
+│   ├─ (*)assets/  # (copied location of assets) 
+│   ├─ (*)scripts/ # (copied location of src/scripts)
+│   └─ lib/        # SFML, TCOD libraries,  Python + standard library / modules
+├── deps/          # Python, SFML, and libtcod imports can be tossed in here to build
+│   └─ platform/   # windows, linux subdirectories for OS-specific cpython config
+├── docs/          # generated HTML, markdown docs
+│   └─ stubs/      # .pyi files for editor integration
+├── modules/       # git submodules, to build all of McRogueFace's dependencies from source
+├── src/           # C++ engine source
+│   └─ scripts/    # Python game scripts (copied during build)
+└── tests/         # Automated test suite
+└── tools/         # For the McRogueFace ecosystem: docs generation
+```
+
+If you are building McRogueFace to implement game logic or scene configuration in C++, you'll have to compile the project.
+
+If you are writing a game in Python using McRogueFace, you only need to rename and zip/distribute the `build` directory.
+
+## Philosophy
+
+- **C++ every frame, Python every tick**: All rendering data is handled in C++. Structure your UI and program animations in Python, and they are rendered without Python. All game logic can be written in Python.
+- **No Compiling Required; Zip And Ship**: Implement your game objects with Python, zip up McRogueFace with your "game.py" to ship
+- **Built-in Roguelike Support**: Dungeon generation, pathfinding, and field-of-view via libtcod 
+- **Hands-Off Testing**: PyAutoGUI-inspired event generation framework. All McRogueFace interactions can be performed headlessly via script: for software testing or AI integration
+- **Interactive Development**: Python REPL integration for live game debugging. Use `mcrogueface` like a Python interpreter
+
+## Contributing
+
+PRs will be considered! Please include explicit mention that your contribution is your own work and released under the MIT license in the pull request.
+
+The project has a private roadmap and issue list. Reach out via email or social media if you have bugs or feature requests.
+
+## License
+
+This project is licensed under the MIT License - see LICENSE file for details.
+
+## Acknowledgments
+
+- Developed for 7-Day Roguelike 2023, 2024, 2025 - here's to many more
+- Built with [SFML](https://www.sfml-dev.org/), [libtcod](https://github.com/libtcod/libtcod), and Python
+- Inspired by David Churchill's COMP4300 game engine lectures

build.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# Build script for McRogueFace - compiles everything into ./build directory
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}McRogueFace Build Script${NC}"
+echo "========================="
+
+# Create build directory if it doesn't exist
+if [ ! -d "build" ]; then
+    echo -e "${YELLOW}Creating build directory...${NC}"
+    mkdir build
+fi
+
+# Change to build directory
+cd build
+
+# Run CMake to generate build files
+echo -e "${YELLOW}Running CMake...${NC}"
+cmake .. -DCMAKE_BUILD_TYPE=Release
+
+# Check if CMake succeeded
+if [ $? -ne 0 ]; then
+    echo -e "${RED}CMake configuration failed!${NC}"
+    exit 1
+fi
+
+# Run make with parallel jobs
+echo -e "${YELLOW}Building with make...${NC}"
+make -j$(nproc)
+
+# Check if make succeeded
+if [ $? -ne 0 ]; then
+    echo -e "${RED}Build failed!${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}Build completed successfully!${NC}"
+echo ""
+echo "The build directory contains:"
+ls -la
+
+echo ""
+echo -e "${GREEN}To run McRogueFace:${NC}"
+echo "  cd build"
+echo "  ./mcrogueface"
+echo ""
+echo -e "${GREEN}To create a distribution archive:${NC}"
+echo "  cd build"
+echo "  zip -r ../McRogueFace-$(date +%Y%m%d).zip ."

build_windows.bat

@@ -0,0 +1,36 @@
+@echo off
+REM Windows build script for McRogueFace
+REM Run this over SSH without Visual Studio GUI
+
+echo Building McRogueFace for Windows...
+
+REM Clean previous build
+if exist build_win rmdir /s /q build_win
+mkdir build_win
+cd build_win
+
+REM Generate Visual Studio project files with CMake
+REM Use -G to specify generator, -A for architecture
+REM Visual Studio 2022 = "Visual Studio 17 2022"
+REM Visual Studio 2019 = "Visual Studio 16 2019"
+cmake -G "Visual Studio 17 2022" -A x64 ..
+if errorlevel 1 (
+    echo CMake configuration failed!
+    exit /b 1
+)
+
+REM Build using MSBuild (comes with Visual Studio)
+REM You can also use cmake --build . --config Release
+msbuild McRogueFace.sln /p:Configuration=Release /p:Platform=x64 /m
+if errorlevel 1 (
+    echo Build failed!
+    exit /b 1
+)
+
+echo Build completed successfully!
+echo Executable location: build_win\Release\mcrogueface.exe
+
+REM Alternative: Using cmake to build (works with any generator)
+REM cmake --build . --config Release --parallel
+
+cd ..

build_windows_cmake.bat

@@ -0,0 +1,42 @@
+@echo off
+REM Windows build script using cmake --build (generator-agnostic)
+REM This version works with any CMake generator
+
+echo Building McRogueFace for Windows using CMake...
+
+REM Set build directory
+set BUILD_DIR=build_win
+set CONFIG=Release
+
+REM Clean previous build
+if exist %BUILD_DIR% rmdir /s /q %BUILD_DIR%
+mkdir %BUILD_DIR%
+cd %BUILD_DIR%
+
+REM Configure with CMake
+REM You can change the generator here if needed:
+REM   -G "Visual Studio 17 2022" (VS 2022)
+REM   -G "Visual Studio 16 2019" (VS 2019)
+REM   -G "MinGW Makefiles" (MinGW)
+REM   -G "Ninja" (Ninja build system)
+cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=%CONFIG% ..
+if errorlevel 1 (
+    echo CMake configuration failed!
+    cd ..
+    exit /b 1
+)
+
+REM Build using cmake (works with any generator)
+cmake --build . --config %CONFIG% --parallel
+if errorlevel 1 (
+    echo Build failed!
+    cd ..
+    exit /b 1
+)
+
+echo.
+echo Build completed successfully!
+echo Executable: %BUILD_DIR%\%CONFIG%\mcrogueface.exe
+echo.
+
+cd ..

compile_commands.json

@@ -0,0 +1,112 @@
+[
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/GameEngine.cpp.o -c /home/john/Development/McRogueFace/src/GameEngine.cpp",
+  "file": "/home/john/Development/McRogueFace/src/GameEngine.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/IndexTexture.cpp.o -c /home/john/Development/McRogueFace/src/IndexTexture.cpp",
+  "file": "/home/john/Development/McRogueFace/src/IndexTexture.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/McRFPy_API.cpp.o -c /home/john/Development/McRogueFace/src/McRFPy_API.cpp",
+  "file": "/home/john/Development/McRogueFace/src/McRFPy_API.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/PyCallable.cpp.o -c /home/john/Development/McRogueFace/src/PyCallable.cpp",
+  "file": "/home/john/Development/McRogueFace/src/PyCallable.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/PyColor.cpp.o -c /home/john/Development/McRogueFace/src/PyColor.cpp",
+  "file": "/home/john/Development/McRogueFace/src/PyColor.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/PyFont.cpp.o -c /home/john/Development/McRogueFace/src/PyFont.cpp",
+  "file": "/home/john/Development/McRogueFace/src/PyFont.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/PyScene.cpp.o -c /home/john/Development/McRogueFace/src/PyScene.cpp",
+  "file": "/home/john/Development/McRogueFace/src/PyScene.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/PyTexture.cpp.o -c /home/john/Development/McRogueFace/src/PyTexture.cpp",
+  "file": "/home/john/Development/McRogueFace/src/PyTexture.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/PyVector.cpp.o -c /home/john/Development/McRogueFace/src/PyVector.cpp",
+  "file": "/home/john/Development/McRogueFace/src/PyVector.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/Resources.cpp.o -c /home/john/Development/McRogueFace/src/Resources.cpp",
+  "file": "/home/john/Development/McRogueFace/src/Resources.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/Scene.cpp.o -c /home/john/Development/McRogueFace/src/Scene.cpp",
+  "file": "/home/john/Development/McRogueFace/src/Scene.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/Timer.cpp.o -c /home/john/Development/McRogueFace/src/Timer.cpp",
+  "file": "/home/john/Development/McRogueFace/src/Timer.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UICaption.cpp.o -c /home/john/Development/McRogueFace/src/UICaption.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UICaption.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UICollection.cpp.o -c /home/john/Development/McRogueFace/src/UICollection.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UICollection.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UIDrawable.cpp.o -c /home/john/Development/McRogueFace/src/UIDrawable.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UIDrawable.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UIEntity.cpp.o -c /home/john/Development/McRogueFace/src/UIEntity.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UIEntity.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UIFrame.cpp.o -c /home/john/Development/McRogueFace/src/UIFrame.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UIFrame.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UIGrid.cpp.o -c /home/john/Development/McRogueFace/src/UIGrid.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UIGrid.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UIGridPoint.cpp.o -c /home/john/Development/McRogueFace/src/UIGridPoint.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UIGridPoint.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UISprite.cpp.o -c /home/john/Development/McRogueFace/src/UISprite.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UISprite.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/UITestScene.cpp.o -c /home/john/Development/McRogueFace/src/UITestScene.cpp",
+  "file": "/home/john/Development/McRogueFace/src/UITestScene.cpp"
+},
+{
+  "directory": "/home/john/Development/McRogueFace/build",
+  "command": "/usr/bin/c++  -I/home/john/Development/McRogueFace/deps -I/home/john/Development/McRogueFace/deps/libtcod -I/home/john/Development/McRogueFace/deps/cpython -I/home/john/Development/McRogueFace/deps/Python -I/home/john/Development/McRogueFace/deps/platform/linux -g -std=gnu++2a -o CMakeFiles/mcrogueface.dir/src/main.cpp.o -c /home/john/Development/McRogueFace/src/main.cpp",
+  "file": "/home/john/Development/McRogueFace/src/main.cpp"
+}
+]

docs/stubs/mcrfpy.pyi

@@ -0,0 +1,532 @@
+"""Type stubs for McRogueFace Python API.
+
+Core game engine interface for creating roguelike games with Python.
+"""
+
+from typing import Any, List, Dict, Tuple, Optional, Callable, Union, overload
+
+# Type aliases
+UIElement = Union['Frame', 'Caption', 'Sprite', 'Grid']
+Transition = Union[str, None]
+
+# Classes
+
+class Color:
+    """SFML Color Object for RGBA colors."""
+    
+    r: int
+    g: int
+    b: int
+    a: int
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, r: int, g: int, b: int, a: int = 255) -> None: ...
+    
+    def from_hex(self, hex_string: str) -> 'Color':
+        """Create color from hex string (e.g., '#FF0000' or 'FF0000')."""
+        ...
+    
+    def to_hex(self) -> str:
+        """Convert color to hex string format."""
+        ...
+    
+    def lerp(self, other: 'Color', t: float) -> 'Color':
+        """Linear interpolation between two colors."""
+        ...
+
+class Vector:
+    """SFML Vector Object for 2D coordinates."""
+    
+    x: float
+    y: float
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: float, y: float) -> None: ...
+    
+    def add(self, other: 'Vector') -> 'Vector': ...
+    def subtract(self, other: 'Vector') -> 'Vector': ...
+    def multiply(self, scalar: float) -> 'Vector': ...
+    def divide(self, scalar: float) -> 'Vector': ...
+    def distance(self, other: 'Vector') -> float: ...
+    def normalize(self) -> 'Vector': ...
+    def dot(self, other: 'Vector') -> float: ...
+
+class Texture:
+    """SFML Texture Object for images."""
+    
+    def __init__(self, filename: str) -> None: ...
+    
+    filename: str
+    width: int
+    height: int
+    sprite_count: int
+
+class Font:
+    """SFML Font Object for text rendering."""
+    
+    def __init__(self, filename: str) -> None: ...
+    
+    filename: str
+    family: str
+
+class Drawable:
+    """Base class for all drawable UI elements."""
+    
+    x: float
+    y: float
+    visible: bool
+    z_index: int
+    name: str
+    pos: Vector
+    
+    def get_bounds(self) -> Tuple[float, float, float, float]:
+        """Get bounding box as (x, y, width, height)."""
+        ...
+    
+    def move(self, dx: float, dy: float) -> None:
+        """Move by relative offset (dx, dy)."""
+        ...
+    
+    def resize(self, width: float, height: float) -> None:
+        """Resize to new dimensions (width, height)."""
+        ...
+
+class Frame(Drawable):
+    """Frame(x=0, y=0, w=0, h=0, fill_color=None, outline_color=None, outline=0, click=None, children=None)
+    
+    A rectangular frame UI element that can contain other drawable elements.
+    """
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: float = 0, y: float = 0, w: float = 0, h: float = 0,
+                 fill_color: Optional[Color] = None, outline_color: Optional[Color] = None,
+                 outline: float = 0, click: Optional[Callable] = None,
+                 children: Optional[List[UIElement]] = None) -> None: ...
+    
+    w: float
+    h: float
+    fill_color: Color
+    outline_color: Color
+    outline: float
+    click: Optional[Callable[[float, float, int], None]]
+    children: 'UICollection'
+    clip_children: bool
+
+class Caption(Drawable):
+    """Caption(text='', x=0, y=0, font=None, fill_color=None, outline_color=None, outline=0, click=None)
+    
+    A text display UI element with customizable font and styling.
+    """
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, text: str = '', x: float = 0, y: float = 0,
+                 font: Optional[Font] = None, fill_color: Optional[Color] = None,
+                 outline_color: Optional[Color] = None, outline: float = 0,
+                 click: Optional[Callable] = None) -> None: ...
+    
+    text: str
+    font: Font
+    fill_color: Color
+    outline_color: Color
+    outline: float
+    click: Optional[Callable[[float, float, int], None]]
+    w: float  # Read-only, computed from text
+    h: float  # Read-only, computed from text
+
+class Sprite(Drawable):
+    """Sprite(x=0, y=0, texture=None, sprite_index=0, scale=1.0, click=None)
+    
+    A sprite UI element that displays a texture or portion of a texture atlas.
+    """
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: float = 0, y: float = 0, texture: Optional[Texture] = None,
+                 sprite_index: int = 0, scale: float = 1.0,
+                 click: Optional[Callable] = None) -> None: ...
+    
+    texture: Texture
+    sprite_index: int
+    scale: float
+    click: Optional[Callable[[float, float, int], None]]
+    w: float  # Read-only, computed from texture
+    h: float  # Read-only, computed from texture
+
+class Grid(Drawable):
+    """Grid(x=0, y=0, grid_size=(20, 20), texture=None, tile_width=16, tile_height=16, scale=1.0, click=None)
+    
+    A grid-based tilemap UI element for rendering tile-based levels and game worlds.
+    """
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, x: float = 0, y: float = 0, grid_size: Tuple[int, int] = (20, 20),
+                 texture: Optional[Texture] = None, tile_width: int = 16, tile_height: int = 16,
+                 scale: float = 1.0, click: Optional[Callable] = None) -> None: ...
+    
+    grid_size: Tuple[int, int]
+    tile_width: int
+    tile_height: int
+    texture: Texture
+    scale: float
+    points: List[List['GridPoint']]
+    entities: 'EntityCollection'
+    background_color: Color
+    click: Optional[Callable[[int, int, int], None]]
+    
+    def at(self, x: int, y: int) -> 'GridPoint':
+        """Get grid point at tile coordinates."""
+        ...
+
+class GridPoint:
+    """Grid point representing a single tile."""
+    
+    texture_index: int
+    solid: bool
+    color: Color
+
+class GridPointState:
+    """State information for a grid point."""
+    
+    texture_index: int
+    color: Color
+
+class Entity(Drawable):
+    """Entity(grid_x=0, grid_y=0, texture=None, sprite_index=0, name='')
+    
+    Game entity that lives within a Grid.
+    """
+    
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, grid_x: float = 0, grid_y: float = 0, texture: Optional[Texture] = None,
+                 sprite_index: int = 0, name: str = '') -> None: ...
+    
+    grid_x: float
+    grid_y: float
+    texture: Texture
+    sprite_index: int
+    grid: Optional[Grid]
+    
+    def at(self, grid_x: float, grid_y: float) -> None:
+        """Move entity to grid position."""
+        ...
+    
+    def die(self) -> None:
+        """Remove entity from its grid."""
+        ...
+    
+    def index(self) -> int:
+        """Get index in parent grid's entity collection."""
+        ...
+
+class UICollection:
+    """Collection of UI drawable elements (Frame, Caption, Sprite, Grid)."""
+    
+    def __len__(self) -> int: ...
+    def __getitem__(self, index: int) -> UIElement: ...
+    def __setitem__(self, index: int, value: UIElement) -> None: ...
+    def __delitem__(self, index: int) -> None: ...
+    def __contains__(self, item: UIElement) -> bool: ...
+    def __iter__(self) -> Any: ...
+    def __add__(self, other: 'UICollection') -> 'UICollection': ...
+    def __iadd__(self, other: 'UICollection') -> 'UICollection': ...
+    
+    def append(self, item: UIElement) -> None: ...
+    def extend(self, items: List[UIElement]) -> None: ...
+    def remove(self, item: UIElement) -> None: ...
+    def index(self, item: UIElement) -> int: ...
+    def count(self, item: UIElement) -> int: ...
+
+class EntityCollection:
+    """Collection of Entity objects."""
+    
+    def __len__(self) -> int: ...
+    def __getitem__(self, index: int) -> Entity: ...
+    def __setitem__(self, index: int, value: Entity) -> None: ...
+    def __delitem__(self, index: int) -> None: ...
+    def __contains__(self, item: Entity) -> bool: ...
+    def __iter__(self) -> Any: ...
+    def __add__(self, other: 'EntityCollection') -> 'EntityCollection': ...
+    def __iadd__(self, other: 'EntityCollection') -> 'EntityCollection': ...
+    
+    def append(self, item: Entity) -> None: ...
+    def extend(self, items: List[Entity]) -> None: ...
+    def remove(self, item: Entity) -> None: ...
+    def index(self, item: Entity) -> int: ...
+    def count(self, item: Entity) -> int: ...
+
+class Scene:
+    """Base class for object-oriented scenes."""
+    
+    name: str
+    
+    def __init__(self, name: str) -> None: ...
+    
+    def activate(self) -> None:
+        """Called when scene becomes active."""
+        ...
+    
+    def deactivate(self) -> None:
+        """Called when scene becomes inactive."""
+        ...
+    
+    def get_ui(self) -> UICollection:
+        """Get UI elements collection."""
+        ...
+    
+    def on_keypress(self, key: str, pressed: bool) -> None:
+        """Handle keyboard events."""
+        ...
+    
+    def on_click(self, x: float, y: float, button: int) -> None:
+        """Handle mouse clicks."""
+        ...
+    
+    def on_enter(self) -> None:
+        """Called when entering the scene."""
+        ...
+    
+    def on_exit(self) -> None:
+        """Called when leaving the scene."""
+        ...
+    
+    def on_resize(self, width: int, height: int) -> None:
+        """Handle window resize events."""
+        ...
+    
+    def update(self, dt: float) -> None:
+        """Update scene logic."""
+        ...
+
+class Timer:
+    """Timer object for scheduled callbacks."""
+    
+    name: str
+    interval: int
+    active: bool
+    
+    def __init__(self, name: str, callback: Callable[[float], None], interval: int) -> None: ...
+    
+    def pause(self) -> None:
+        """Pause the timer."""
+        ...
+    
+    def resume(self) -> None:
+        """Resume the timer."""
+        ...
+    
+    def cancel(self) -> None:
+        """Cancel and remove the timer."""
+        ...
+
+class Window:
+    """Window singleton for managing the game window."""
+    
+    resolution: Tuple[int, int]
+    fullscreen: bool
+    vsync: bool
+    title: str
+    fps_limit: int
+    game_resolution: Tuple[int, int]
+    scaling_mode: str
+    
+    @staticmethod
+    def get() -> 'Window':
+        """Get the window singleton instance."""
+        ...
+
+class Animation:
+    """Animation object for animating UI properties."""
+    
+    target: Any
+    property: str
+    duration: float
+    easing: str
+    loop: bool
+    on_complete: Optional[Callable]
+    
+    def __init__(self, target: Any, property: str, start_value: Any, end_value: Any,
+                 duration: float, easing: str = 'linear', loop: bool = False,
+                 on_complete: Optional[Callable] = None) -> None: ...
+    
+    def start(self) -> None:
+        """Start the animation."""
+        ...
+    
+    def update(self, dt: float) -> bool:
+        """Update animation, returns True if still running."""
+        ...
+    
+    def get_current_value(self) -> Any:
+        """Get the current interpolated value."""
+        ...
+
+# Module functions
+
+def createSoundBuffer(filename: str) -> int:
+    """Load a sound effect from a file and return its buffer ID."""
+    ...
+
+def loadMusic(filename: str) -> None:
+    """Load and immediately play background music from a file."""
+    ...
+
+def setMusicVolume(volume: int) -> None:
+    """Set the global music volume (0-100)."""
+    ...
+
+def setSoundVolume(volume: int) -> None:
+    """Set the global sound effects volume (0-100)."""
+    ...
+
+def playSound(buffer_id: int) -> None:
+    """Play a sound effect using a previously loaded buffer."""
+    ...
+
+def getMusicVolume() -> int:
+    """Get the current music volume level (0-100)."""
+    ...
+
+def getSoundVolume() -> int:
+    """Get the current sound effects volume level (0-100)."""
+    ...
+
+def sceneUI(scene: Optional[str] = None) -> UICollection:
+    """Get all UI elements for a scene."""
+    ...
+
+def currentScene() -> str:
+    """Get the name of the currently active scene."""
+    ...
+
+def setScene(scene: str, transition: Optional[str] = None, duration: float = 0.0) -> None:
+    """Switch to a different scene with optional transition effect."""
+    ...
+
+def createScene(name: str) -> None:
+    """Create a new empty scene."""
+    ...
+
+def keypressScene(handler: Callable[[str, bool], None]) -> None:
+    """Set the keyboard event handler for the current scene."""
+    ...
+
+def setTimer(name: str, handler: Callable[[float], None], interval: int) -> None:
+    """Create or update a recurring timer."""
+    ...
+
+def delTimer(name: str) -> None:
+    """Stop and remove a timer."""
+    ...
+
+def exit() -> None:
+    """Cleanly shut down the game engine and exit the application."""
+    ...
+
+def setScale(multiplier: float) -> None:
+    """Scale the game window size (deprecated - use Window.resolution)."""
+    ...
+
+def find(name: str, scene: Optional[str] = None) -> Optional[UIElement]:
+    """Find the first UI element with the specified name."""
+    ...
+
+def findAll(pattern: str, scene: Optional[str] = None) -> List[UIElement]:
+    """Find all UI elements matching a name pattern (supports * wildcards)."""
+    ...
+
+def getMetrics() -> Dict[str, Union[int, float]]:
+    """Get current performance metrics."""
+    ...
+
+# Submodule
+class automation:
+    """Automation API for testing and scripting."""
+    
+    @staticmethod
+    def screenshot(filename: str) -> bool:
+        """Save a screenshot to the specified file."""
+        ...
+    
+    @staticmethod
+    def position() -> Tuple[int, int]:
+        """Get current mouse position as (x, y) tuple."""
+        ...
+    
+    @staticmethod
+    def size() -> Tuple[int, int]:
+        """Get screen size as (width, height) tuple."""
+        ...
+    
+    @staticmethod
+    def onScreen(x: int, y: int) -> bool:
+        """Check if coordinates are within screen bounds."""
+        ...
+    
+    @staticmethod
+    def moveTo(x: int, y: int, duration: float = 0.0) -> None:
+        """Move mouse to absolute position."""
+        ...
+    
+    @staticmethod
+    def moveRel(xOffset: int, yOffset: int, duration: float = 0.0) -> None:
+        """Move mouse relative to current position."""
+        ...
+    
+    @staticmethod
+    def dragTo(x: int, y: int, duration: float = 0.0, button: str = 'left') -> None:
+        """Drag mouse to position."""
+        ...
+    
+    @staticmethod
+    def dragRel(xOffset: int, yOffset: int, duration: float = 0.0, button: str = 'left') -> None:
+        """Drag mouse relative to current position."""
+        ...
+    
+    @staticmethod
+    def click(x: Optional[int] = None, y: Optional[int] = None, clicks: int = 1,
+              interval: float = 0.0, button: str = 'left') -> None:
+        """Click mouse at position."""
+        ...
+    
+    @staticmethod
+    def mouseDown(x: Optional[int] = None, y: Optional[int] = None, button: str = 'left') -> None:
+        """Press mouse button down."""
+        ...
+    
+    @staticmethod
+    def mouseUp(x: Optional[int] = None, y: Optional[int] = None, button: str = 'left') -> None:
+        """Release mouse button."""
+        ...
+    
+    @staticmethod
+    def keyDown(key: str) -> None:
+        """Press key down."""
+        ...
+    
+    @staticmethod
+    def keyUp(key: str) -> None:
+        """Release key."""
+        ...
+    
+    @staticmethod
+    def press(key: str) -> None:
+        """Press and release a key."""
+        ...
+    
+    @staticmethod
+    def typewrite(text: str, interval: float = 0.0) -> None:
+        """Type text with optional interval between characters."""
+        ...

docs/stubs/mcrfpy/__init__.pyi

@@ -0,0 +1,209 @@
+"""Type stubs for McRogueFace Python API.
+
+Auto-generated - do not edit directly.
+"""
+
+from typing import Any, List, Dict, Tuple, Optional, Callable, Union
+
+# Module documentation
+# McRogueFace Python API\n\nCore game engine interface for creating roguelike games with Python.\n\nThis module provides:\n- Scene management (createScene, setScene, currentScene)\n- UI components (Frame, Caption, Sprite, Grid)\n- Entity system for game objects\n- Audio playback (sound effects and music)\n- Timer system for scheduled events\n- Input handling\n- Performance metrics\n\nExample:\n    import mcrfpy\n    \n    # Create a new scene\n    mcrfpy.createScene('game')\n    mcrfpy.setScene('game')\n    \n    # Add UI elements\n    frame = mcrfpy.Frame(10, 10, 200, 100)\n    caption = mcrfpy.Caption('Hello World', 50, 50)\n    mcrfpy.sceneUI().extend([frame, caption])\n
+
+# Classes
+
+class Animation:
+    """Animation object for animating UI properties"""
+    def __init__(selftype(self)) -> None: ...
+
+    def get_current_value(self, *args, **kwargs) -> Any: ...
+    def start(self, *args, **kwargs) -> Any: ...
+    def update(selfreturns True if still running) -> Any: ...
+
+class Caption:
+    """Caption(text='', x=0, y=0, font=None, fill_color=None, outline_color=None, outline=0, click=None)"""
+    def __init__(selftype(self)) -> None: ...
+
+    def get_bounds(selfx, y, width, height) -> Any: ...
+    def move(selfdx, dy) -> Any: ...
+    def resize(selfwidth, height) -> Any: ...
+
+class Color:
+    """SFML Color Object"""
+    def __init__(selftype(self)) -> None: ...
+
+    def from_hex(selfe.g., '#FF0000' or 'FF0000') -> Any: ...
+    def lerp(self, *args, **kwargs) -> Any: ...
+    def to_hex(self, *args, **kwargs) -> Any: ...
+
+class Drawable:
+    """Base class for all drawable UI elements"""
+    def __init__(selftype(self)) -> None: ...
+
+    def get_bounds(selfx, y, width, height) -> Any: ...
+    def move(selfdx, dy) -> Any: ...
+    def resize(selfwidth, height) -> Any: ...
+
+class Entity:
+    """UIEntity objects"""
+    def __init__(selftype(self)) -> None: ...
+
+    def at(self, *args, **kwargs) -> Any: ...
+    def die(self, *args, **kwargs) -> Any: ...
+    def get_bounds(selfx, y, width, height) -> Any: ...
+    def index(self, *args, **kwargs) -> Any: ...
+    def move(selfdx, dy) -> Any: ...
+    def path_to(selfx: int, y: int) -> bool: ...
+    def resize(selfwidth, height) -> Any: ...
+    def update_visibility(self) -> None: ...
+
+class EntityCollection:
+    """Iterable, indexable collection of Entities"""
+    def __init__(selftype(self)) -> None: ...
+
+    def append(self, *args, **kwargs) -> Any: ...
+    def count(self, *args, **kwargs) -> Any: ...
+    def extend(self, *args, **kwargs) -> Any: ...
+    def index(self, *args, **kwargs) -> Any: ...
+    def remove(self, *args, **kwargs) -> Any: ...
+
+class Font:
+    """SFML Font Object"""
+    def __init__(selftype(self)) -> None: ...
+
+class Frame:
+    """Frame(x=0, y=0, w=0, h=0, fill_color=None, outline_color=None, outline=0, click=None, children=None)"""
+    def __init__(selftype(self)) -> None: ...
+
+    def get_bounds(selfx, y, width, height) -> Any: ...
+    def move(selfdx, dy) -> Any: ...
+    def resize(selfwidth, height) -> Any: ...
+
+class Grid:
+    """Grid(x=0, y=0, grid_size=(20, 20), texture=None, tile_width=16, tile_height=16, scale=1.0, click=None)"""
+    def __init__(selftype(self)) -> None: ...
+
+    def at(self, *args, **kwargs) -> Any: ...
+    def compute_astar_path(selfx1: int, y1: int, x2: int, y2: int, diagonal_cost: float = 1.41) -> List[Tuple[int, int]]: ...
+    def compute_dijkstra(selfroot_x: int, root_y: int, diagonal_cost: float = 1.41) -> None: ...
+    def compute_fov(selfx: int, y: int, radius: int = 0, light_walls: bool = True, algorithm: int = FOV_BASIC) -> None: ...
+    def find_path(selfx1: int, y1: int, x2: int, y2: int, diagonal_cost: float = 1.41) -> List[Tuple[int, int]]: ...
+    def get_bounds(selfx, y, width, height) -> Any: ...
+    def get_dijkstra_distance(selfx: int, y: int) -> Optional[float]: ...
+    def get_dijkstra_path(selfx: int, y: int) -> List[Tuple[int, int]]: ...
+    def is_in_fov(selfx: int, y: int) -> bool: ...
+    def move(selfdx, dy) -> Any: ...
+    def resize(selfwidth, height) -> Any: ...
+
+class GridPoint:
+    """UIGridPoint object"""
+    def __init__(selftype(self)) -> None: ...
+
+class GridPointState:
+    """UIGridPointState object"""
+    def __init__(selftype(self)) -> None: ...
+
+class Scene:
+    """Base class for object-oriented scenes"""
+    def __init__(selftype(self)) -> None: ...
+
+    def activate(self, *args, **kwargs) -> Any: ...
+    def get_ui(self, *args, **kwargs) -> Any: ...
+    def register_keyboard(selfalternative to overriding on_keypress) -> Any: ...
+
+class Sprite:
+    """Sprite(x=0, y=0, texture=None, sprite_index=0, scale=1.0, click=None)"""
+    def __init__(selftype(self)) -> None: ...
+
+    def get_bounds(selfx, y, width, height) -> Any: ...
+    def move(selfdx, dy) -> Any: ...
+    def resize(selfwidth, height) -> Any: ...
+
+class Texture:
+    """SFML Texture Object"""
+    def __init__(selftype(self)) -> None: ...
+
+class Timer:
+    """Timer object for scheduled callbacks"""
+    def __init__(selftype(self)) -> None: ...
+
+    def cancel(self, *args, **kwargs) -> Any: ...
+    def pause(self, *args, **kwargs) -> Any: ...
+    def restart(self, *args, **kwargs) -> Any: ...
+    def resume(self, *args, **kwargs) -> Any: ...
+
+class UICollection:
+    """Iterable, indexable collection of UI objects"""
+    def __init__(selftype(self)) -> None: ...
+
+    def append(self, *args, **kwargs) -> Any: ...
+    def count(self, *args, **kwargs) -> Any: ...
+    def extend(self, *args, **kwargs) -> Any: ...
+    def index(self, *args, **kwargs) -> Any: ...
+    def remove(self, *args, **kwargs) -> Any: ...
+
+class UICollectionIter:
+    """Iterator for a collection of UI objects"""
+    def __init__(selftype(self)) -> None: ...
+
+class UIEntityCollectionIter:
+    """Iterator for a collection of UI objects"""
+    def __init__(selftype(self)) -> None: ...
+
+class Vector:
+    """SFML Vector Object"""
+    def __init__(selftype(self)) -> None: ...
+
+    def angle(self, *args, **kwargs) -> Any: ...
+    def copy(self, *args, **kwargs) -> Any: ...
+    def distance_to(self, *args, **kwargs) -> Any: ...
+    def dot(self, *args, **kwargs) -> Any: ...
+    def magnitude(self, *args, **kwargs) -> Any: ...
+    def magnitude_squared(self, *args, **kwargs) -> Any: ...
+    def normalize(self, *args, **kwargs) -> Any: ...
+
+class Window:
+    """Window singleton for accessing and modifying the game window properties"""
+    def __init__(selftype(self)) -> None: ...
+
+    def center(self, *args, **kwargs) -> Any: ...
+    def get(self, *args, **kwargs) -> Any: ...
+    def screenshot(self, *args, **kwargs) -> Any: ...
+
+# Functions
+
+def createScene(name: str) -> None: ...
+def createSoundBuffer(filename: str) -> int: ...
+def currentScene() -> str: ...
+def delTimer(name: str) -> None: ...
+def exit() -> None: ...
+def find(name: str, scene: str = None) -> UIDrawable | None: ...
+def findAll(pattern: str, scene: str = None) -> list: ...
+def getMetrics() -> dict: ...
+def getMusicVolume() -> int: ...
+def getSoundVolume() -> int: ...
+def keypressScene(handler: callable) -> None: ...
+def loadMusic(filename: str) -> None: ...
+def playSound(buffer_id: int) -> None: ...
+def sceneUI(scene: str = None) -> list: ...
+def setMusicVolume(volume: int) -> None: ...
+def setScale(multiplier: float) -> None: ...
+def setScene(scene: str, transition: str = None, duration: float = 0.0) -> None: ...
+def setSoundVolume(volume: int) -> None: ...
+def setTimer(name: str, handler: callable, interval: int) -> None: ...
+
+# Constants
+
+FOV_BASIC: int
+FOV_DIAMOND: int
+FOV_PERMISSIVE_0: int
+FOV_PERMISSIVE_1: int
+FOV_PERMISSIVE_2: int
+FOV_PERMISSIVE_3: int
+FOV_PERMISSIVE_4: int
+FOV_PERMISSIVE_5: int
+FOV_PERMISSIVE_6: int
+FOV_PERMISSIVE_7: int
+FOV_PERMISSIVE_8: int
+FOV_RESTRICTIVE: int
+FOV_SHADOW: int
+default_font: Any
+default_texture: Any

docs/stubs/mcrfpy/automation.pyi

@@ -0,0 +1,24 @@
+"""Type stubs for McRogueFace automation API."""
+
+from typing import Optional, Tuple
+
+def click(x=None, y=None, clicks=1, interval=0.0, button='left') -> Any: ...
+def doubleClick(x=None, y=None) -> Any: ...
+def dragRel(xOffset, yOffset, duration=0.0, button='left') -> Any: ...
+def dragTo(x, y, duration=0.0, button='left') -> Any: ...
+def hotkey(*keys) - Press a hotkey combination (e.g., hotkey('ctrl', 'c')) -> Any: ...
+def keyDown(key) -> Any: ...
+def keyUp(key) -> Any: ...
+def middleClick(x=None, y=None) -> Any: ...
+def mouseDown(x=None, y=None, button='left') -> Any: ...
+def mouseUp(x=None, y=None, button='left') -> Any: ...
+def moveRel(xOffset, yOffset, duration=0.0) -> Any: ...
+def moveTo(x, y, duration=0.0) -> Any: ...
+def onScreen(x, y) -> Any: ...
+def position() - Get current mouse position as (x, y) -> Any: ...
+def rightClick(x=None, y=None) -> Any: ...
+def screenshot(filename) -> Any: ...
+def scroll(clicks, x=None, y=None) -> Any: ...
+def size() - Get screen size as (width, height) -> Any: ...
+def tripleClick(x=None, y=None) -> Any: ...
+def typewrite(message, interval=0.0) -> Any: ...

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_0/README.md

@@ -0,0 +1,253 @@
+# Part 0 - Setting Up McRogueFace
+
+Welcome to the McRogueFace Roguelike Tutorial! This tutorial will teach you how to create a complete roguelike game using the McRogueFace game engine. Unlike traditional Python libraries, McRogueFace is a complete, portable game engine that includes everything you need to make and distribute games.
+
+## What is McRogueFace?
+
+McRogueFace is a high-performance game engine with Python scripting support. Think of it like Unity or Godot, but specifically designed for roguelikes and 2D games. It includes:
+
+- A complete Python 3.12 runtime (no installation needed!)
+- High-performance C++ rendering and entity management
+- Built-in UI components and scene management
+- Integrated audio system
+- Professional sprite-based graphics
+- Easy distribution - your players don't need Python installed!
+
+## Prerequisites
+
+Before starting this tutorial, you should:
+
+- Have basic Python knowledge (variables, functions, classes)
+- Be comfortable editing text files
+- Have a text editor (VS Code, Sublime Text, Notepad++, etc.)
+
+That's it! Unlike other roguelike tutorials, you don't need Python installed - McRogueFace includes everything.
+
+## Getting McRogueFace
+
+### Step 1: Download the Engine
+
+1. Visit the McRogueFace releases page
+2. Download the version for your operating system:
+   - `McRogueFace-Windows.zip` for Windows
+   - `McRogueFace-MacOS.zip` for macOS
+   - `McRogueFace-Linux.zip` for Linux
+
+### Step 2: Extract the Archive
+
+Extract the downloaded archive to a folder where you want to develop your game. You should see this structure:
+
+```
+McRogueFace/
+├── mcrogueface (or mcrogueface.exe on Windows)
+├── scripts/
+│   └── game.py
+├── assets/
+│   ├── sprites/
+│   ├── fonts/
+│   └── audio/
+└── lib/
+```
+
+### Step 3: Run the Engine
+
+Run the McRogueFace executable:
+
+- **Windows**: Double-click `mcrogueface.exe`
+- **Mac/Linux**: Open a terminal in the folder and run `./mcrogueface`
+
+You should see a window open with the default McRogueFace demo. This shows the engine is working correctly!
+
+## Your First McRogueFace Script
+
+Let's modify the engine to display "Hello Roguelike!" instead of the default demo.
+
+### Step 1: Open game.py
+
+Open `scripts/game.py` in your text editor. You'll see the default demo code. Replace it entirely with:
+
+```python
+import mcrfpy
+
+# Create a new scene called "hello"
+mcrfpy.createScene("hello")
+
+# Switch to our new scene
+mcrfpy.setScene("hello")
+
+# Get the UI container for our scene
+ui = mcrfpy.sceneUI("hello")
+
+# Create a text caption
+caption = mcrfpy.Caption("Hello Roguelike!", 400, 300)
+caption.font_size = 32
+caption.fill_color = mcrfpy.Color(255, 255, 255)  # White text
+
+# Add the caption to our scene
+ui.append(caption)
+
+# Create a smaller instruction caption
+instruction = mcrfpy.Caption("Press ESC to exit", 400, 350)
+instruction.font_size = 16
+instruction.fill_color = mcrfpy.Color(200, 200, 200)  # Light gray
+ui.append(instruction)
+
+# Set up a simple key handler
+def handle_keys(key, state):
+    if state == "start" and key == "Escape":
+        mcrfpy.setScene(None)  # This exits the game
+
+mcrfpy.keypressScene(handle_keys)
+
+print("Hello Roguelike is running!")
+```
+
+### Step 2: Save and Run
+
+1. Save the file
+2. If McRogueFace is still running, it will automatically reload!
+3. If not, run the engine again
+
+You should now see "Hello Roguelike!" displayed in the window.
+
+### Step 3: Understanding the Code
+
+Let's break down what we just wrote:
+
+1. **Import mcrfpy**: This is McRogueFace's Python API
+2. **Create a scene**: Scenes are like game states (menu, gameplay, inventory, etc.)
+3. **UI elements**: We create Caption objects for text display
+4. **Colors**: McRogueFace uses RGB colors (0-255 for each component)
+5. **Input handling**: We set up a callback for keyboard input
+6. **Scene switching**: Setting the scene to None exits the game
+
+## Key Differences from Pure Python Development
+
+### The Game Loop
+
+Unlike typical Python scripts, McRogueFace runs your code inside its game loop:
+
+1. The engine starts and loads `scripts/game.py`
+2. Your script sets up scenes, UI elements, and callbacks
+3. The engine runs at 60 FPS, handling rendering and input
+4. Your callbacks are triggered by game events
+
+### Hot Reloading
+
+McRogueFace can reload your scripts while running! Just save your changes and the engine will reload automatically. This makes development incredibly fast.
+
+### Asset Pipeline
+
+McRogueFace includes a complete asset system:
+
+- **Sprites**: Place images in `assets/sprites/`
+- **Fonts**: TrueType fonts in `assets/fonts/`
+- **Audio**: Sound effects and music in `assets/audio/`
+
+We'll explore these in later lessons.
+
+## Testing Your Setup
+
+Let's create a more interactive test to ensure everything is working properly:
+
+```python
+import mcrfpy
+
+# Create our test scene
+mcrfpy.createScene("test")
+mcrfpy.setScene("test")
+ui = mcrfpy.sceneUI("test")
+
+# Create a background frame
+background = mcrfpy.Frame(0, 0, 1024, 768)
+background.fill_color = mcrfpy.Color(20, 20, 30)  # Dark blue-gray
+ui.append(background)
+
+# Title text
+title = mcrfpy.Caption("McRogueFace Setup Test", 512, 100)
+title.font_size = 36
+title.fill_color = mcrfpy.Color(255, 255, 100)  # Yellow
+ui.append(title)
+
+# Status text that will update
+status_text = mcrfpy.Caption("Press any key to test input...", 512, 300)
+status_text.font_size = 20
+status_text.fill_color = mcrfpy.Color(200, 200, 200)
+ui.append(status_text)
+
+# Instructions
+instructions = [
+    "Arrow Keys: Test movement input",
+    "Space: Test action input",
+    "Mouse Click: Test mouse input",
+    "ESC: Exit"
+]
+
+y_offset = 400
+for instruction in instructions:
+    inst_caption = mcrfpy.Caption(instruction, 512, y_offset)
+    inst_caption.font_size = 16
+    inst_caption.fill_color = mcrfpy.Color(150, 150, 150)
+    ui.append(inst_caption)
+    y_offset += 30
+
+# Input handler
+def handle_input(key, state):
+    if state != "start":
+        return
+        
+    if key == "Escape":
+        mcrfpy.setScene(None)
+    else:
+        status_text.text = f"You pressed: {key}"
+        status_text.fill_color = mcrfpy.Color(100, 255, 100)  # Green
+
+# Set up input handling
+mcrfpy.keypressScene(handle_input)
+
+print("Setup test is running! Try pressing different keys.")
+```
+
+## Troubleshooting
+
+### Engine Won't Start
+
+- **Windows**: Make sure you extracted all files, not just the .exe
+- **Mac**: You may need to right-click and select "Open" the first time
+- **Linux**: Make sure the file is executable: `chmod +x mcrogueface`
+
+### Scripts Not Loading
+
+- Ensure your script is named exactly `game.py` in the `scripts/` folder
+- Check the console output for Python errors
+- Make sure you're using Python 3 syntax
+
+### Performance Issues
+
+- McRogueFace should run smoothly at 60 FPS
+- If not, check if your graphics drivers are updated
+- The engine shows FPS in the window title
+
+## What's Next?
+
+Congratulations! You now have McRogueFace set up and running. You've learned:
+
+- How to download and run the McRogueFace engine
+- The basic structure of a McRogueFace project
+- How to create scenes and UI elements
+- How to handle keyboard input
+- The development workflow with hot reloading
+
+In Part 1, we'll create our player character and implement movement. We'll explore McRogueFace's entity system and learn how to create a game world.
+
+## Why McRogueFace?
+
+Before we continue, let's highlight why McRogueFace is excellent for roguelike development:
+
+1. **No Installation Hassles**: Your players just download and run - no Python needed!
+2. **Professional Performance**: C++ engine core means smooth gameplay even with hundreds of entities
+3. **Built-in Features**: UI, audio, scenes, and animations are already there
+4. **Easy Distribution**: Just zip your game folder and share it
+5. **Rapid Development**: Hot reloading and Python scripting for quick iteration
+
+Ready to make a roguelike? Let's continue to Part 1!

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_0/code/game.py

@@ -0,0 +1,33 @@
+import mcrfpy
+
+# Create a new scene called "hello"
+mcrfpy.createScene("hello")
+
+# Switch to our new scene
+mcrfpy.setScene("hello")
+
+# Get the UI container for our scene
+ui = mcrfpy.sceneUI("hello")
+
+# Create a text caption
+caption = mcrfpy.Caption("Hello Roguelike!", 400, 300)
+caption.font_size = 32
+caption.fill_color = mcrfpy.Color(255, 255, 255)  # White text
+
+# Add the caption to our scene
+ui.append(caption)
+
+# Create a smaller instruction caption
+instruction = mcrfpy.Caption("Press ESC to exit", 400, 350)
+instruction.font_size = 16
+instruction.fill_color = mcrfpy.Color(200, 200, 200)  # Light gray
+ui.append(instruction)
+
+# Set up a simple key handler
+def handle_keys(key, state):
+    if state == "start" and key == "Escape":
+        mcrfpy.setScene(None)  # This exits the game
+
+mcrfpy.keypressScene(handle_keys)
+
+print("Hello Roguelike is running!")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_0/code/setup_test.py

@@ -0,0 +1,55 @@
+import mcrfpy
+
+# Create our test scene
+mcrfpy.createScene("test")
+mcrfpy.setScene("test")
+ui = mcrfpy.sceneUI("test")
+
+# Create a background frame
+background = mcrfpy.Frame(0, 0, 1024, 768)
+background.fill_color = mcrfpy.Color(20, 20, 30)  # Dark blue-gray
+ui.append(background)
+
+# Title text
+title = mcrfpy.Caption("McRogueFace Setup Test", 512, 100)
+title.font_size = 36
+title.fill_color = mcrfpy.Color(255, 255, 100)  # Yellow
+ui.append(title)
+
+# Status text that will update
+status_text = mcrfpy.Caption("Press any key to test input...", 512, 300)
+status_text.font_size = 20
+status_text.fill_color = mcrfpy.Color(200, 200, 200)
+ui.append(status_text)
+
+# Instructions
+instructions = [
+    "Arrow Keys: Test movement input",
+    "Space: Test action input", 
+    "Mouse Click: Test mouse input",
+    "ESC: Exit"
+]
+
+y_offset = 400
+for instruction in instructions:
+    inst_caption = mcrfpy.Caption(instruction, 512, y_offset)
+    inst_caption.font_size = 16
+    inst_caption.fill_color = mcrfpy.Color(150, 150, 150)
+    ui.append(inst_caption)
+    y_offset += 30
+
+# Input handler
+def handle_input(key, state):
+    if state != "start":
+        return
+        
+    if key == "Escape":
+        mcrfpy.setScene(None)
+    else:
+        status_text.text = f"You pressed: {key}"
+        status_text.fill_color = mcrfpy.Color(100, 255, 100)  # Green
+
+# Set up input handling
+mcrfpy.keypressScene(handle_input)
+
+print("Setup test is running! Try pressing different keys.")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_1/README.md

@@ -0,0 +1,457 @@
+# Part 1 - Drawing the '@' Symbol and Moving It Around
+
+In Part 0, we set up McRogueFace and created a simple "Hello Roguelike" scene. Now it's time to create the foundation of our game: a player character that can move around the screen.
+
+In traditional roguelikes, the player is represented by the '@' symbol. We'll honor that tradition while taking advantage of McRogueFace's powerful sprite-based rendering system.
+
+## Understanding McRogueFace's Architecture
+
+Before we dive into code, let's understand two key concepts in McRogueFace:
+
+### Grid - The Game World
+
+A `Grid` represents your game world. It's a 2D array of tiles where each tile can be:
+- **Walkable or not** (for collision detection)
+- **Transparent or not** (for field of view, which we'll cover later)
+- **Have a visual appearance** (sprite index and color)
+
+Think of the Grid as the dungeon floor, walls, and other static elements.
+
+### Entity - Things That Move
+
+An `Entity` represents anything that can move around on the Grid:
+- The player character
+- Monsters
+- Items (if you want them to be thrown or moved)
+- Projectiles
+
+Entities exist "on top of" the Grid and automatically handle smooth movement animation between tiles.
+
+## Creating Our Game World
+
+Let's start by creating a simple room for our player to move around in. Create a new `game.py`:
+
+```python
+import mcrfpy
+
+# Define some constants for our tile types
+FLOOR_TILE = 0
+WALL_TILE = 1
+PLAYER_SPRITE = 2
+
+# Window configuration
+mcrfpy.createScene("game")
+mcrfpy.setScene("game")
+
+# Configure window properties
+window = mcrfpy.Window.get()
+window.title = "McRogueFace Roguelike - Part 1"
+
+# Get the UI container for our scene
+ui = mcrfpy.sceneUI("game")
+
+# Create a dark background
+background = mcrfpy.Frame(0, 0, 1024, 768)
+background.fill_color = mcrfpy.Color(0, 0, 0)
+ui.append(background)
+```
+
+Now we need to set up our tileset. For this tutorial, we'll use ASCII-style sprites. McRogueFace comes with a built-in ASCII tileset:
+
+```python
+# Load the ASCII tileset
+# This tileset has characters mapped to sprite indices
+# For example: @ = 64, # = 35, . = 46
+tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+
+# Create the game grid
+# 50x30 tiles is a good size for a roguelike
+GRID_WIDTH = 50
+GRID_HEIGHT = 30
+
+grid = mcrfpy.Grid(grid_x=GRID_WIDTH, grid_y=GRID_HEIGHT, texture=tileset)
+grid.position = (100, 100)  # Position on screen
+grid.size = (800, 480)      # Size in pixels
+
+# Add the grid to our UI
+ui.append(grid)
+```
+
+## Initializing the Game World
+
+Now let's fill our grid with a simple room:
+
+```python
+def create_room():
+    """Create a room with walls around the edges"""
+    # Fill everything with floor tiles first
+    for y in range(GRID_HEIGHT):
+        for x in range(GRID_WIDTH):
+            cell = grid.at(x, y)
+            cell.walkable = True
+            cell.transparent = True
+            cell.sprite_index = 46  # '.' character
+            cell.color = mcrfpy.Color(50, 50, 50)  # Dark gray floor
+    
+    # Create walls around the edges
+    for x in range(GRID_WIDTH):
+        # Top wall
+        cell = grid.at(x, 0)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)  # Gray walls
+        
+        # Bottom wall
+        cell = grid.at(x, GRID_HEIGHT - 1)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+    
+    for y in range(GRID_HEIGHT):
+        # Left wall
+        cell = grid.at(0, y)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+        
+        # Right wall
+        cell = grid.at(GRID_WIDTH - 1, y)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+
+# Create the room
+create_room()
+```
+
+## Creating the Player
+
+Now let's add our player character:
+
+```python
+# Create the player entity
+player = mcrfpy.Entity(x=GRID_WIDTH // 2, y=GRID_HEIGHT // 2, grid=grid)
+player.sprite_index = 64  # '@' character
+player.color = mcrfpy.Color(255, 255, 255)  # White
+
+# The entity is automatically added to the grid when we pass grid= parameter
+# This is equivalent to: grid.entities.append(player)
+```
+
+## Handling Input
+
+McRogueFace uses a callback system for input. For a turn-based roguelike, we only care about key presses, not releases:
+
+```python
+def handle_input(key, state):
+    """Handle keyboard input for player movement"""
+    # Only process key presses, not releases
+    if state != "start":
+        return
+    
+    # Movement deltas
+    dx, dy = 0, 0
+    
+    # Arrow keys
+    if key == "Up":
+        dy = -1
+    elif key == "Down":
+        dy = 1
+    elif key == "Left":
+        dx = -1
+    elif key == "Right":
+        dx = 1
+    
+    # Numpad movement (for true roguelike feel!)
+    elif key == "Num7":  # Northwest
+        dx, dy = -1, -1
+    elif key == "Num8":  # North
+        dy = -1
+    elif key == "Num9":  # Northeast
+        dx, dy = 1, -1
+    elif key == "Num4":  # West
+        dx = -1
+    elif key == "Num6":  # East
+        dx = 1
+    elif key == "Num1":  # Southwest
+        dx, dy = -1, 1
+    elif key == "Num2":  # South
+        dy = 1
+    elif key == "Num3":  # Southeast
+        dx, dy = 1, 1
+    
+    # Escape to quit
+    elif key == "Escape":
+        mcrfpy.setScene(None)
+        return
+    
+    # If there's movement, try to move the player
+    if dx != 0 or dy != 0:
+        move_player(dx, dy)
+
+# Register the input handler
+mcrfpy.keypressScene(handle_input)
+```
+
+## Implementing Movement with Collision Detection
+
+Now let's implement the movement function with proper collision detection:
+
+```python
+def move_player(dx, dy):
+    """Move the player if the destination is walkable"""
+    # Calculate new position
+    new_x = player.x + dx
+    new_y = player.y + dy
+    
+    # Check bounds
+    if new_x < 0 or new_x >= GRID_WIDTH or new_y < 0 or new_y >= GRID_HEIGHT:
+        return
+    
+    # Check if the destination is walkable
+    destination = grid.at(new_x, new_y)
+    if destination.walkable:
+        # Move the player
+        player.x = new_x
+        player.y = new_y
+        # The entity will automatically animate to the new position!
+```
+
+## Adding Visual Polish
+
+Let's add some UI elements to make our game look more polished:
+
+```python
+# Add a title
+title = mcrfpy.Caption("McRogueFace Roguelike", 512, 30)
+title.font_size = 24
+title.fill_color = mcrfpy.Color(255, 255, 100)  # Yellow
+ui.append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption("Arrow Keys or Numpad to move, ESC to quit", 512, 60)
+instructions.font_size = 16
+instructions.fill_color = mcrfpy.Color(200, 200, 200)  # Light gray
+ui.append(instructions)
+
+# Add a status line at the bottom
+status = mcrfpy.Caption("@ You", 100, 600)
+status.font_size = 18
+status.fill_color = mcrfpy.Color(255, 255, 255)
+ui.append(status)
+```
+
+## Complete Code
+
+Here's the complete `game.py` for Part 1:
+
+```python
+import mcrfpy
+
+# Window configuration
+mcrfpy.createScene("game")
+mcrfpy.setScene("game")
+
+window = mcrfpy.Window.get()
+window.title = "McRogueFace Roguelike - Part 1"
+
+# Get the UI container for our scene
+ui = mcrfpy.sceneUI("game")
+
+# Create a dark background
+background = mcrfpy.Frame(0, 0, 1024, 768)
+background.fill_color = mcrfpy.Color(0, 0, 0)
+ui.append(background)
+
+# Load the ASCII tileset
+tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+
+# Create the game grid
+GRID_WIDTH = 50
+GRID_HEIGHT = 30
+
+grid = mcrfpy.Grid(grid_x=GRID_WIDTH, grid_y=GRID_HEIGHT, texture=tileset)
+grid.position = (100, 100)
+grid.size = (800, 480)
+ui.append(grid)
+
+def create_room():
+    """Create a room with walls around the edges"""
+    # Fill everything with floor tiles first
+    for y in range(GRID_HEIGHT):
+        for x in range(GRID_WIDTH):
+            cell = grid.at(x, y)
+            cell.walkable = True
+            cell.transparent = True
+            cell.sprite_index = 46  # '.' character
+            cell.color = mcrfpy.Color(50, 50, 50)  # Dark gray floor
+    
+    # Create walls around the edges
+    for x in range(GRID_WIDTH):
+        # Top wall
+        cell = grid.at(x, 0)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)  # Gray walls
+        
+        # Bottom wall
+        cell = grid.at(x, GRID_HEIGHT - 1)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+    
+    for y in range(GRID_HEIGHT):
+        # Left wall
+        cell = grid.at(0, y)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+        
+        # Right wall
+        cell = grid.at(GRID_WIDTH - 1, y)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+
+# Create the room
+create_room()
+
+# Create the player entity
+player = mcrfpy.Entity(x=GRID_WIDTH // 2, y=GRID_HEIGHT // 2, grid=grid)
+player.sprite_index = 64  # '@' character
+player.color = mcrfpy.Color(255, 255, 255)  # White
+
+def move_player(dx, dy):
+    """Move the player if the destination is walkable"""
+    # Calculate new position
+    new_x = player.x + dx
+    new_y = player.y + dy
+    
+    # Check bounds
+    if new_x < 0 or new_x >= GRID_WIDTH or new_y < 0 or new_y >= GRID_HEIGHT:
+        return
+    
+    # Check if the destination is walkable
+    destination = grid.at(new_x, new_y)
+    if destination.walkable:
+        # Move the player
+        player.x = new_x
+        player.y = new_y
+
+def handle_input(key, state):
+    """Handle keyboard input for player movement"""
+    # Only process key presses, not releases
+    if state != "start":
+        return
+    
+    # Movement deltas
+    dx, dy = 0, 0
+    
+    # Arrow keys
+    if key == "Up":
+        dy = -1
+    elif key == "Down":
+        dy = 1
+    elif key == "Left":
+        dx = -1
+    elif key == "Right":
+        dx = 1
+    
+    # Numpad movement (for true roguelike feel!)
+    elif key == "Num7":  # Northwest
+        dx, dy = -1, -1
+    elif key == "Num8":  # North
+        dy = -1
+    elif key == "Num9":  # Northeast
+        dx, dy = 1, -1
+    elif key == "Num4":  # West
+        dx = -1
+    elif key == "Num6":  # East
+        dx = 1
+    elif key == "Num1":  # Southwest
+        dx, dy = -1, 1
+    elif key == "Num2":  # South
+        dy = 1
+    elif key == "Num3":  # Southeast
+        dx, dy = 1, 1
+    
+    # Escape to quit
+    elif key == "Escape":
+        mcrfpy.setScene(None)
+        return
+    
+    # If there's movement, try to move the player
+    if dx != 0 or dy != 0:
+        move_player(dx, dy)
+
+# Register the input handler
+mcrfpy.keypressScene(handle_input)
+
+# Add UI elements
+title = mcrfpy.Caption("McRogueFace Roguelike", 512, 30)
+title.font_size = 24
+title.fill_color = mcrfpy.Color(255, 255, 100)
+ui.append(title)
+
+instructions = mcrfpy.Caption("Arrow Keys or Numpad to move, ESC to quit", 512, 60)
+instructions.font_size = 16
+instructions.fill_color = mcrfpy.Color(200, 200, 200)
+ui.append(instructions)
+
+status = mcrfpy.Caption("@ You", 100, 600)
+status.font_size = 18
+status.fill_color = mcrfpy.Color(255, 255, 255)
+ui.append(status)
+
+print("Part 1: The @ symbol moves!")
+```
+
+## Understanding What We've Built
+
+Let's review the key concepts we've implemented:
+
+1. **Grid-Entity Architecture**: The Grid represents our static world (floors and walls), while the Entity (player) moves on top of it.
+
+2. **Collision Detection**: By checking the `walkable` property of grid cells, we prevent the player from walking through walls.
+
+3. **Turn-Based Input**: By only responding to key presses (not releases), we've created true turn-based movement.
+
+4. **Visual Feedback**: The Entity system automatically animates movement between tiles, giving smooth visual feedback.
+
+## Exercises
+
+Try these modifications to deepen your understanding:
+
+1. **Add More Rooms**: Create multiple rooms connected by corridors
+2. **Different Tile Types**: Add doors (walkable but different appearance)
+3. **Sprint Movement**: Hold Shift to move multiple tiles at once
+4. **Mouse Support**: Click a tile to pathfind to it (we'll cover pathfinding properly later)
+
+## ASCII Sprite Reference
+
+Here are some useful ASCII character indices for the default tileset:
+- @ (player): 64
+- # (wall): 35
+- . (floor): 46
+- + (door): 43
+- ~ (water): 126
+- % (item): 37
+- ! (potion): 33
+
+## What's Next?
+
+In Part 2, we'll expand our world with:
+- A proper Entity system for managing multiple objects
+- NPCs that can also move around
+- A more interesting map layout
+- The beginning of our game architecture
+
+The foundation is set - you have a player character that can move around a world with collision detection. This is the core of any roguelike game!

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_1/code/game.py

@@ -0,0 +1,162 @@
+import mcrfpy
+
+# Window configuration
+mcrfpy.createScene("game")
+mcrfpy.setScene("game")
+
+window = mcrfpy.Window.get()
+window.title = "McRogueFace Roguelike - Part 1"
+
+# Get the UI container for our scene
+ui = mcrfpy.sceneUI("game")
+
+# Create a dark background
+background = mcrfpy.Frame(0, 0, 1024, 768)
+background.fill_color = mcrfpy.Color(0, 0, 0)
+ui.append(background)
+
+# Load the ASCII tileset
+tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+
+# Create the game grid
+GRID_WIDTH = 50
+GRID_HEIGHT = 30
+
+grid = mcrfpy.Grid(grid_x=GRID_WIDTH, grid_y=GRID_HEIGHT, texture=tileset)
+grid.position = (100, 100)
+grid.size = (800, 480)
+ui.append(grid)
+
+def create_room():
+    """Create a room with walls around the edges"""
+    # Fill everything with floor tiles first
+    for y in range(GRID_HEIGHT):
+        for x in range(GRID_WIDTH):
+            cell = grid.at(x, y)
+            cell.walkable = True
+            cell.transparent = True
+            cell.sprite_index = 46  # '.' character
+            cell.color = mcrfpy.Color(50, 50, 50)  # Dark gray floor
+    
+    # Create walls around the edges
+    for x in range(GRID_WIDTH):
+        # Top wall
+        cell = grid.at(x, 0)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)  # Gray walls
+        
+        # Bottom wall
+        cell = grid.at(x, GRID_HEIGHT - 1)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+    
+    for y in range(GRID_HEIGHT):
+        # Left wall
+        cell = grid.at(0, y)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+        
+        # Right wall
+        cell = grid.at(GRID_WIDTH - 1, y)
+        cell.walkable = False
+        cell.transparent = False
+        cell.sprite_index = 35  # '#' character
+        cell.color = mcrfpy.Color(100, 100, 100)
+
+# Create the room
+create_room()
+
+# Create the player entity
+player = mcrfpy.Entity(x=GRID_WIDTH // 2, y=GRID_HEIGHT // 2, grid=grid)
+player.sprite_index = 64  # '@' character
+player.color = mcrfpy.Color(255, 255, 255)  # White
+
+def move_player(dx, dy):
+    """Move the player if the destination is walkable"""
+    # Calculate new position
+    new_x = player.x + dx
+    new_y = player.y + dy
+    
+    # Check bounds
+    if new_x < 0 or new_x >= GRID_WIDTH or new_y < 0 or new_y >= GRID_HEIGHT:
+        return
+    
+    # Check if the destination is walkable
+    destination = grid.at(new_x, new_y)
+    if destination.walkable:
+        # Move the player
+        player.x = new_x
+        player.y = new_y
+
+def handle_input(key, state):
+    """Handle keyboard input for player movement"""
+    # Only process key presses, not releases
+    if state != "start":
+        return
+    
+    # Movement deltas
+    dx, dy = 0, 0
+    
+    # Arrow keys
+    if key == "Up":
+        dy = -1
+    elif key == "Down":
+        dy = 1
+    elif key == "Left":
+        dx = -1
+    elif key == "Right":
+        dx = 1
+    
+    # Numpad movement (for true roguelike feel!)
+    elif key == "Num7":  # Northwest
+        dx, dy = -1, -1
+    elif key == "Num8":  # North
+        dy = -1
+    elif key == "Num9":  # Northeast
+        dx, dy = 1, -1
+    elif key == "Num4":  # West
+        dx = -1
+    elif key == "Num6":  # East
+        dx = 1
+    elif key == "Num1":  # Southwest
+        dx, dy = -1, 1
+    elif key == "Num2":  # South
+        dy = 1
+    elif key == "Num3":  # Southeast
+        dx, dy = 1, 1
+    
+    # Escape to quit
+    elif key == "Escape":
+        mcrfpy.setScene(None)
+        return
+    
+    # If there's movement, try to move the player
+    if dx != 0 or dy != 0:
+        move_player(dx, dy)
+
+# Register the input handler
+mcrfpy.keypressScene(handle_input)
+
+# Add UI elements
+title = mcrfpy.Caption("McRogueFace Roguelike", 512, 30)
+title.font_size = 24
+title.fill_color = mcrfpy.Color(255, 255, 100)
+ui.append(title)
+
+instructions = mcrfpy.Caption("Arrow Keys or Numpad to move, ESC to quit", 512, 60)
+instructions.font_size = 16
+instructions.fill_color = mcrfpy.Color(200, 200, 200)
+ui.append(instructions)
+
+status = mcrfpy.Caption("@ You", 100, 600)
+status.font_size = 18
+status.fill_color = mcrfpy.Color(255, 255, 255)
+ui.append(status)
+
+print("Part 1: The @ symbol moves!")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_2/README.md

@@ -0,0 +1,562 @@
+# Part 2 - The Generic Entity, the Render Functions, and the Map
+
+In Part 1, we created a player character that could move around a simple room. Now it's time to build a proper architecture for our roguelike. We'll create a flexible entity system, a proper map structure, and organize our code for future expansion.
+
+## Understanding Game Architecture
+
+Before diving into code, let's understand the architecture we're building:
+
+1. **Entities**: Anything that can exist in the game world (player, monsters, items)
+2. **Game Map**: The dungeon structure with tiles that can be walls or floors
+3. **Game Engine**: Coordinates everything - entities, map, input, and rendering
+
+In McRogueFace, we'll adapt these concepts to work with the engine's scene-based architecture.
+
+## Creating a Flexible Entity System
+
+While McRogueFace provides a built-in `Entity` class, we'll create a wrapper to add game-specific functionality:
+
+```python
+class GameObject:
+    """Base class for all game objects (player, monsters, items)"""
+    
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks  # Does this entity block movement?
+        self._entity = None  # The McRogueFace entity
+        self.grid = None     # Reference to the grid
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = self.color
+    
+    def move(self, dx, dy):
+        """Move by the given amount if possible"""
+        if not self.grid:
+            return
+        
+        new_x = self.x + dx
+        new_y = self.y + dy
+        
+        # Update our position
+        self.x = new_x
+        self.y = new_y
+        
+        # Update the visual entity
+        if self._entity:
+            self._entity.x = new_x
+            self._entity.y = new_y
+    
+    def destroy(self):
+        """Remove this entity from the game"""
+        if self._entity and self.grid:
+            # Find and remove from grid's entity list
+            for i, entity in enumerate(self.grid.entities):
+                if entity == self._entity:
+                    del self.grid.entities[i]
+                    break
+            self._entity = None
+```
+
+## Building the Game Map
+
+Let's create a proper map class that manages our dungeon:
+
+```python
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []  # List of GameObjects
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Initialize all tiles as walls
+        self.fill_with_walls()
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, color=(100, 100, 100))
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, color):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*color)
+    
+    def create_room(self, x1, y1, x2, y2):
+        """Carve out a room in the map"""
+        # Make sure coordinates are in the right order
+        x1, x2 = min(x1, x2), max(x1, x2)
+        y1, y2 = min(y1, y2), max(y1, y2)
+        
+        # Carve out floor tiles
+        for y in range(y1, y2 + 1):
+            for x in range(x1, x2 + 1):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, color=(50, 50, 50))
+    
+    def create_tunnel_h(self, x1, x2, y):
+        """Create a horizontal tunnel"""
+        for x in range(min(x1, x2), max(x1, x2) + 1):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(50, 50, 50))
+    
+    def create_tunnel_v(self, y1, y2, x):
+        """Create a vertical tunnel"""
+        for y in range(min(y1, y2), max(y1, y2) + 1):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(50, 50, 50))
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        # Check map boundaries
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        # Check if tile is walkable
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        # Check if any blocking entity is at this position
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+```
+
+## Creating the Game Engine
+
+Now let's build our game engine to tie everything together:
+
+```python
+class Engine:
+    """Main game engine that manages game state"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        # Create the game scene
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        # Configure window
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 2"
+        
+        # Get UI container
+        self.ui = mcrfpy.sceneUI("game")
+        
+        # Add background
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        # Load tileset
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        # Create the game world
+        self.setup_game()
+        
+        # Setup input handling
+        self.setup_input()
+        
+        # Add UI elements
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        # Create the map
+        self.game_map = GameMap(50, 30)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create some rooms
+        self.game_map.create_room(10, 10, 20, 20)
+        self.game_map.create_room(30, 15, 40, 25)
+        self.game_map.create_room(15, 22, 25, 28)
+        
+        # Connect rooms with tunnels
+        self.game_map.create_tunnel_h(20, 30, 15)
+        self.game_map.create_tunnel_v(20, 22, 20)
+        
+        # Create player
+        self.player = GameObject(15, 15, 64, (255, 255, 255), "Player", blocks=True)
+        self.game_map.add_entity(self.player)
+        
+        # Create an NPC
+        npc = GameObject(35, 20, 64, (255, 255, 0), "NPC", blocks=True)
+        self.game_map.add_entity(npc)
+        self.entities.append(npc)
+        
+        # Create some items (non-blocking)
+        potion = GameObject(12, 12, 33, (255, 0, 255), "Potion", blocks=False)
+        self.game_map.add_entity(potion)
+        self.entities.append(potion)
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        # Check if movement is blocked
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+        else:
+            # Check if we bumped into an entity
+            target = self.game_map.get_blocking_entity_at(new_x, new_y)
+            if target:
+                print(f"You bump into the {target.name}!")
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            # Movement keys
+            movement = {
+                "Up": (0, -1),
+                "Down": (0, 1),
+                "Left": (-1, 0),
+                "Right": (1, 0),
+                "Num7": (-1, -1),
+                "Num8": (0, -1),
+                "Num9": (1, -1),
+                "Num4": (-1, 0),
+                "Num6": (1, 0),
+                "Num1": (-1, 1),
+                "Num2": (0, 1),
+                "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        # Title
+        title = mcrfpy.Caption("McRogueFace Roguelike - Part 2", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        # Instructions
+        instructions = mcrfpy.Caption("Explore the dungeon! ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+```
+
+## Putting It All Together
+
+Here's the complete `game.py` file:
+
+```python
+import mcrfpy
+
+class GameObject:
+    """Base class for all game objects (player, monsters, items)"""
+    
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount if possible"""
+        if not self.grid:
+            return
+        
+        new_x = self.x + dx
+        new_y = self.y + dy
+        
+        self.x = new_x
+        self.y = new_y
+        
+        if self._entity:
+            self._entity.x = new_x
+            self._entity.y = new_y
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        self.fill_with_walls()
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, color=(100, 100, 100))
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, color):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*color)
+    
+    def create_room(self, x1, y1, x2, y2):
+        """Carve out a room in the map"""
+        x1, x2 = min(x1, x2), max(x1, x2)
+        y1, y2 = min(y1, y2), max(y1, y2)
+        
+        for y in range(y1, y2 + 1):
+            for x in range(x1, x2 + 1):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, color=(50, 50, 50))
+    
+    def create_tunnel_h(self, x1, x2, y):
+        """Create a horizontal tunnel"""
+        for x in range(min(x1, x2), max(x1, x2) + 1):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(50, 50, 50))
+    
+    def create_tunnel_v(self, y1, y2, x):
+        """Create a vertical tunnel"""
+        for y in range(min(y1, y2), max(y1, y2) + 1):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(50, 50, 50))
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+
+class Engine:
+    """Main game engine that manages game state"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 2"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(50, 30)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        self.game_map.create_room(10, 10, 20, 20)
+        self.game_map.create_room(30, 15, 40, 25)
+        self.game_map.create_room(15, 22, 25, 28)
+        
+        self.game_map.create_tunnel_h(20, 30, 15)
+        self.game_map.create_tunnel_v(20, 22, 20)
+        
+        self.player = GameObject(15, 15, 64, (255, 255, 255), "Player", blocks=True)
+        self.game_map.add_entity(self.player)
+        
+        npc = GameObject(35, 20, 64, (255, 255, 0), "NPC", blocks=True)
+        self.game_map.add_entity(npc)
+        self.entities.append(npc)
+        
+        potion = GameObject(12, 12, 33, (255, 0, 255), "Potion", blocks=False)
+        self.game_map.add_entity(potion)
+        self.entities.append(potion)
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+        else:
+            target = self.game_map.get_blocking_entity_at(new_x, new_y)
+            if target:
+                print(f"You bump into the {target.name}!")
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("McRogueFace Roguelike - Part 2", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Explore the dungeon! ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+
+# Create and run the game
+engine = Engine()
+print("Part 2: Entities and Maps!")
+```
+
+## Understanding the Architecture
+
+### GameObject Class
+Our `GameObject` class wraps McRogueFace's `Entity` and adds:
+- Game logic properties (name, blocking)
+- Position tracking independent of the visual entity
+- Easy attachment/detachment from grids
+
+### GameMap Class
+The `GameMap` manages:
+- The McRogueFace `Grid` for visual representation
+- A list of all entities in the map
+- Collision detection including entity blocking
+- Map generation utilities (rooms, tunnels)
+
+### Engine Class
+The `Engine` coordinates everything:
+- Scene and UI setup
+- Game state management
+- Input handling
+- Entity-map interactions
+
+## Key Improvements from Part 1
+
+1. **Proper Entity Management**: Multiple entities can exist and interact
+2. **Blocking Entities**: Some entities block movement, others don't
+3. **Map Generation**: Tools for creating rooms and tunnels
+4. **Collision System**: Checks both tiles and entities
+5. **Organized Code**: Clear separation of concerns
+
+## Exercises
+
+1. **Add More Entity Types**: Create different sprites for monsters, items, and NPCs
+2. **Entity Interactions**: Make items disappear when walked over
+3. **Random Map Generation**: Place rooms and tunnels randomly
+4. **Entity Properties**: Add health, damage, or other attributes to GameObjects
+
+## What's Next?
+
+In Part 3, we'll implement proper dungeon generation with:
+- Procedurally generated rooms
+- Smart tunnel routing
+- Entity spawning
+- The beginning of a real roguelike dungeon!
+
+We now have a solid foundation with proper entity management and map structure. This architecture will serve us well as we add more complex features to our roguelike!

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_2/code/game.py

@@ -0,0 +1,217 @@
+import mcrfpy
+
+class GameObject:
+    """Base class for all game objects (player, monsters, items)"""
+    
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount if possible"""
+        if not self.grid:
+            return
+        
+        new_x = self.x + dx
+        new_y = self.y + dy
+        
+        self.x = new_x
+        self.y = new_y
+        
+        if self._entity:
+            self._entity.x = new_x
+            self._entity.y = new_y
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+        self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        self.fill_with_walls()
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, color=(100, 100, 100))
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, color):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*color)
+    
+    def create_room(self, x1, y1, x2, y2):
+        """Carve out a room in the map"""
+        x1, x2 = min(x1, x2), max(x1, x2)
+        y1, y2 = min(y1, y2), max(y1, y2)
+        
+        for y in range(y1, y2 + 1):
+            for x in range(x1, x2 + 1):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, color=(50, 50, 50))
+    
+    def create_tunnel_h(self, x1, x2, y):
+        """Create a horizontal tunnel"""
+        for x in range(min(x1, x2), max(x1, x2) + 1):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(50, 50, 50))
+    
+    def create_tunnel_v(self, y1, y2, x):
+        """Create a vertical tunnel"""
+        for y in range(min(y1, y2), max(y1, y2) + 1):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(50, 50, 50))
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+
+class Engine:
+    """Main game engine that manages game state"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 2"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(50, 30)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        self.game_map.create_room(10, 10, 20, 20)
+        self.game_map.create_room(30, 15, 40, 25)
+        self.game_map.create_room(15, 22, 25, 28)
+        
+        self.game_map.create_tunnel_h(20, 30, 15)
+        self.game_map.create_tunnel_v(20, 22, 20)
+        
+        self.player = GameObject(15, 15, 64, (255, 255, 255), "Player", blocks=True)
+        self.game_map.add_entity(self.player)
+        
+        npc = GameObject(35, 20, 64, (255, 255, 0), "NPC", blocks=True)
+        self.game_map.add_entity(npc)
+        self.entities.append(npc)
+        
+        potion = GameObject(12, 12, 33, (255, 0, 255), "Potion", blocks=False)
+        self.game_map.add_entity(potion)
+        self.entities.append(potion)
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+        else:
+            target = self.game_map.get_blocking_entity_at(new_x, new_y)
+            if target:
+                print(f"You bump into the {target.name}!")
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("McRogueFace Roguelike - Part 2", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Explore the dungeon! ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+
+# Create and run the game
+engine = Engine()
+print("Part 2: Entities and Maps!")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_3/README.md

@@ -0,0 +1,548 @@
+# Part 3 - Generating a Dungeon
+
+In Parts 1 and 2, we created a player that could move around and interact with a hand-crafted dungeon. Now it's time to generate dungeons procedurally - a core feature of any roguelike game!
+
+## The Plan
+
+We'll create a dungeon generator that:
+1. Places rectangular rooms randomly
+2. Ensures rooms don't overlap
+3. Connects rooms with tunnels
+4. Places the player in the first room
+
+This is a classic approach used by many roguelikes, and it creates interesting, playable dungeons.
+
+## Creating a Room Class
+
+First, let's create a class to represent rectangular rooms:
+
+```python
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        """Return the center coordinates of the room"""
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        """Return the inner area of the room as a tuple of slices
+        
+        This property returns the area inside the walls.
+        We'll add 1 to min coordinates and subtract 1 from max coordinates.
+        """
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        """Return True if this room overlaps with another RectangularRoom"""
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+```
+
+## Implementing Tunnel Generation
+
+Since McRogueFace doesn't include line-drawing algorithms, let's implement simple L-shaped tunnels:
+
+```python
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    # Randomly decide whether to go horizontal first or vertical first
+    if random.random() < 0.5:
+        # Horizontal, then vertical
+        corner_x = x2
+        corner_y = y1
+    else:
+        # Vertical, then horizontal
+        corner_x = x1
+        corner_y = y2
+    
+    # Generate the coordinates
+    # First line: from start to corner
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+        
+    # Second line: from corner to end
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+```
+
+## The Dungeon Generator
+
+Now let's update our GameMap class to generate dungeons:
+
+```python
+import random
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []  # Keep track of rooms for game logic
+        
+    def generate_dungeon(
+        self,
+        max_rooms,
+        room_min_size,
+        room_max_size,
+        player
+    ):
+        """Generate a new dungeon map"""
+        # Start with everything as walls
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            # Random width and height
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            # Random position without going out of bounds
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            # Create the room
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            # Check if it intersects with any existing room
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue  # This room intersects, so go to the next attempt
+                
+            # If we get here, it's a valid room
+            
+            # Carve out this room
+            self.carve_room(new_room)
+            
+            # Place the player in the center of the first room
+            if len(self.rooms) == 0:
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                # All rooms after the first:
+                # Tunnel between this room and the previous one
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+            
+            # Finally, append the new room to the list
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, color=(50, 50, 50))
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(30, 30, 40))  # Slightly different color for tunnels
+```
+
+## Complete Code
+
+Here's the complete `game.py` with procedural dungeon generation:
+
+```python
+import mcrfpy
+import random
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        """Return the center coordinates of the room"""
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        """Return the inner area of the room"""
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        """Return True if this room overlaps with another"""
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    # Generate the coordinates
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, color=(100, 100, 100))
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, color):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*color)
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, color=(50, 50, 50))
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(30, 30, 40))
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        if not self.grid.at(x, y).walkable:
+            return True
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 3"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player (before dungeon generation)
+        self.player = GameObject(0, 0, 64, (255, 255, 255), "Player", blocks=True)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Add some monsters in random rooms
+        for i in range(5):
+            if i < len(self.game_map.rooms) - 1:  # Don't spawn in first room
+                room = self.game_map.rooms[i + 1]
+                x, y = room.center
+                
+                # Create an orc
+                orc = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                self.game_map.add_entity(orc)
+                self.entities.append(orc)
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+            elif key == "Space":
+                # Regenerate the dungeon
+                self.regenerate_dungeon()
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def regenerate_dungeon(self):
+        """Generate a new dungeon"""
+        # Clear existing entities
+        self.game_map.entities.clear()
+        self.game_map.rooms.clear()
+        self.entities.clear()
+        
+        # Clear the entity list in the grid
+        if self.game_map.grid:
+            self.game_map.grid.entities.clear()
+        
+        # Regenerate
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player
+        )
+        
+        # Re-add player
+        self.game_map.add_entity(self.player)
+        
+        # Add new monsters
+        for i in range(5):
+            if i < len(self.game_map.rooms) - 1:
+                room = self.game_map.rooms[i + 1]
+                x, y = room.center
+                orc = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                self.game_map.add_entity(orc)
+                self.entities.append(orc)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Procedural Dungeon Generation", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Arrow keys to move, SPACE to regenerate, ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+
+# Create and run the game
+engine = Engine()
+print("Part 3: Procedural Dungeon Generation!")
+print("Press SPACE to generate a new dungeon")
+```
+
+## Understanding the Algorithm
+
+Our dungeon generation algorithm is simple but effective:
+
+1. **Start with solid walls** - The entire map begins filled with wall tiles
+2. **Try to place rooms** - Generate random rooms and check for overlaps
+3. **Connect with tunnels** - Each new room connects to the previous one
+4. **Place entities** - The player starts in the first room, monsters in others
+
+### Room Placement
+
+The algorithm attempts to place `max_rooms` rooms, but may place fewer if many attempts result in overlapping rooms. This is called "rejection sampling" - we generate random rooms and reject ones that don't fit.
+
+### Tunnel Design
+
+Our L-shaped tunnels are simple but effective. They either go:
+- Horizontal first, then vertical
+- Vertical first, then horizontal
+
+This creates variety while ensuring all rooms are connected.
+
+## Experimenting with Parameters
+
+Try adjusting these parameters to create different dungeon styles:
+
+```python
+# Sparse dungeon with large rooms
+self.game_map.generate_dungeon(
+    max_rooms=10,
+    room_min_size=10,
+    room_max_size=15,
+    player=self.player
+)
+
+# Dense dungeon with small rooms
+self.game_map.generate_dungeon(
+    max_rooms=50,
+    room_min_size=4,
+    room_max_size=6,
+    player=self.player
+)
+```
+
+## Visual Enhancements
+
+Notice how we gave tunnels a slightly different color:
+- Rooms: `color=(50, 50, 50)` - Medium gray
+- Tunnels: `color=(30, 30, 40)` - Darker with blue tint
+
+This subtle difference helps players understand the dungeon layout.
+
+## Exercises
+
+1. **Different Room Shapes**: Create circular or cross-shaped rooms
+2. **Better Tunnel Routing**: Implement A* pathfinding for more natural tunnels
+3. **Room Types**: Create special rooms (treasure rooms, trap rooms)
+4. **Dungeon Themes**: Use different tile sets and colors for different dungeon levels
+
+## What's Next?
+
+In Part 4, we'll implement Field of View (FOV) so the player can only see parts of the dungeon they've explored. This will add mystery and atmosphere to our procedurally generated dungeons!
+
+Our dungeon generator is now creating unique, playable levels every time. The foundation of a true roguelike is taking shape!

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_3/code/game.py

@@ -0,0 +1,312 @@
+import mcrfpy
+import random
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        """Return the center coordinates of the room"""
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        """Return the inner area of the room"""
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        """Return True if this room overlaps with another"""
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    # Generate the coordinates
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+        self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, color=(100, 100, 100))
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, color):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*color)
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, color=(50, 50, 50))
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, color=(30, 30, 40))
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        if not self.grid.at(x, y).walkable:
+            return True
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 3"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player (before dungeon generation)
+        self.player = GameObject(0, 0, 64, (255, 255, 255), "Player", blocks=True)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Add some monsters in random rooms
+        for i in range(5):
+            if i < len(self.game_map.rooms) - 1:  # Don't spawn in first room
+                room = self.game_map.rooms[i + 1]
+                x, y = room.center
+                
+                # Create an orc
+                orc = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                self.game_map.add_entity(orc)
+                self.entities.append(orc)
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+            elif key == "Space":
+                # Regenerate the dungeon
+                self.regenerate_dungeon()
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def regenerate_dungeon(self):
+        """Generate a new dungeon"""
+        # Clear existing entities
+        self.game_map.entities.clear()
+        self.game_map.rooms.clear()
+        self.entities.clear()
+        
+        # Clear the entity list in the grid
+        if self.game_map.grid:
+            self.game_map.grid.entities.clear()
+        
+        # Regenerate
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player
+        )
+        
+        # Re-add player
+        self.game_map.add_entity(self.player)
+        
+        # Add new monsters
+        for i in range(5):
+            if i < len(self.game_map.rooms) - 1:
+                room = self.game_map.rooms[i + 1]
+                x, y = room.center
+                orc = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                self.game_map.add_entity(orc)
+                self.entities.append(orc)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Procedural Dungeon Generation", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Arrow keys to move, SPACE to regenerate, ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+
+# Create and run the game
+engine = Engine()
+print("Part 3: Procedural Dungeon Generation!")
+print("Press SPACE to generate a new dungeon")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_4/README.md

@@ -0,0 +1,520 @@
+# Part 4 - Field of View
+
+One of the defining features of roguelikes is exploration and discovery. In Part 3, we could see the entire dungeon at once. Now we'll implement Field of View (FOV) so players can only see what their character can actually see, adding mystery and tactical depth to our game.
+
+## Understanding Field of View
+
+Field of View creates three distinct visibility states for each tile:
+
+1. **Visible**: Currently in the player's line of sight
+2. **Explored**: Previously seen but not currently visible
+3. **Unexplored**: Never seen (completely hidden)
+
+This creates the classic "fog of war" effect where you remember the layout of areas you've explored, but can't see current enemy positions unless they're in your view.
+
+## McRogueFace's FOV System
+
+Good news! McRogueFace includes built-in FOV support through its C++ engine. We just need to enable and configure it. The engine uses an efficient shadowcasting algorithm that provides smooth, realistic line-of-sight calculations.
+
+Let's update our code to use FOV:
+
+```python
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+```
+
+## Configuring Visibility Rendering
+
+McRogueFace automatically handles the rendering of visible/explored/unexplored tiles. We need to set up our grid to use perspective-based rendering:
+
+```python
+class GameMap:
+    """Manages the game world"""
+    
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering (0 = first entity = player)
+        self.grid.perspective = 0
+        
+        return self.grid
+```
+
+## Visual Appearance Configuration
+
+Let's define how our tiles look in different visibility states:
+
+```python
+# Color configurations for visibility states
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    # Light gray
+    'floor': (50, 50, 50),      # Dark gray
+    'tunnel': (30, 30, 40),     # Dark blue-gray
+}
+
+COLORS_EXPLORED = {
+    'wall': (50, 50, 70),       # Darker, bluish
+    'floor': (20, 20, 30),      # Very dark
+    'tunnel': (15, 15, 25),     # Almost black
+}
+
+# Update the tile-setting methods to store the tile type
+def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+    """Set properties for a specific tile"""
+    if 0 <= x < self.width and 0 <= y < self.height:
+        cell = self.grid.at(x, y)
+        cell.walkable = walkable
+        cell.transparent = transparent
+        cell.sprite_index = sprite_index
+        # Store both visible and explored colors
+        cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+        # The engine will automatically darken explored tiles
+```
+
+## Complete Implementation
+
+Here's the complete updated `game.py` with FOV:
+
+```python
+import mcrfpy
+import random
+
+# Color configurations for visibility
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    
+    'floor': (50, 50, 50),      
+    'tunnel': (30, 30, 40),     
+}
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering (0 = first entity = player)
+        self.grid.perspective = 0
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, tile_type='wall')
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, tile_type='floor')
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, tile_type='tunnel')
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        if not self.grid.at(x, y).walkable:
+            return True
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        self.fov_radius = 8
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 4"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player
+        self.player = GameObject(0, 0, 64, (255, 255, 255), "Player", blocks=True)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Add monsters in random rooms
+        for i in range(10):
+            if i < len(self.game_map.rooms) - 1:
+                room = self.game_map.rooms[i + 1]
+                x, y = room.center
+                
+                # Randomly offset from center
+                x += random.randint(-2, 2)
+                y += random.randint(-2, 2)
+                
+                # Make sure position is walkable
+                if self.game_map.grid.at(x, y).walkable:
+                    if i % 2 == 0:
+                        # Create an orc
+                        orc = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                        self.game_map.add_entity(orc)
+                        self.entities.append(orc)
+                    else:
+                        # Create a troll
+                        troll = GameObject(x, y, 84, (0, 127, 0), "Troll", blocks=True)
+                        self.game_map.add_entity(troll)
+                        self.entities.append(troll)
+        
+        # Initial FOV calculation
+        self.player.update_fov()
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+            elif key == "v":
+                # Toggle FOV on/off
+                if self.game_map.grid.perspective == 0:
+                    self.game_map.grid.perspective = -1  # Omniscient
+                    print("FOV disabled - omniscient view")
+                else:
+                    self.game_map.grid.perspective = 0  # Player perspective
+                    print("FOV enabled - player perspective")
+            elif key == "Plus" or key == "Equals":
+                # Increase FOV radius
+                self.fov_radius = min(self.fov_radius + 1, 20)
+                self.player._entity.update_fov(radius=self.fov_radius)
+                print(f"FOV radius: {self.fov_radius}")
+            elif key == "Minus":
+                # Decrease FOV radius
+                self.fov_radius = max(self.fov_radius - 1, 3)
+                self.player._entity.update_fov(radius=self.fov_radius)
+                print(f"FOV radius: {self.fov_radius}")
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Field of View", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Arrow keys to move | V to toggle FOV | +/- to adjust radius | ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+        
+        # FOV indicator
+        self.fov_text = mcrfpy.Caption(f"FOV Radius: {self.fov_radius}", 900, 100)
+        self.fov_text.font_size = 14
+        self.fov_text.fill_color = mcrfpy.Color(150, 200, 255)
+        self.ui.append(self.fov_text)
+
+# Create and run the game
+engine = Engine()
+print("Part 4: Field of View!")
+print("Press V to toggle FOV on/off")
+print("Press +/- to adjust FOV radius")
+```
+
+## How FOV Works
+
+McRogueFace's built-in FOV system uses a shadowcasting algorithm that:
+
+1. **Casts rays** from the player's position to tiles within the radius
+2. **Checks transparency** along each ray path
+3. **Marks tiles as visible** if the ray reaches them unobstructed
+4. **Remembers explored tiles** automatically
+
+The engine handles all the complex calculations in C++ for optimal performance.
+
+## Visibility States in Detail
+
+### Visible Tiles
+- Currently in the player's line of sight
+- Rendered at full brightness
+- Show current entity positions
+
+### Explored Tiles
+- Previously seen but not currently visible
+- Rendered darker/muted
+- Show remembered terrain but not entities
+
+### Unexplored Tiles
+- Never been in the player's FOV
+- Rendered as black/invisible
+- Complete mystery to the player
+
+## FOV Parameters
+
+You can customize FOV behavior:
+
+```python
+# Basic FOV update
+entity.update_fov(radius=8)
+
+# The grid's perspective property controls rendering:
+grid.perspective = 0   # Use first entity's FOV (player)
+grid.perspective = 1   # Use second entity's FOV
+grid.perspective = -1  # Omniscient (no FOV, see everything)
+```
+
+## Performance Considerations
+
+McRogueFace's C++ FOV implementation is highly optimized:
+- Uses efficient shadowcasting algorithm
+- Only recalculates when needed
+- Handles large maps smoothly
+- Automatically culls entities outside FOV
+
+## Visual Polish
+
+The engine automatically handles visual transitions:
+- Smooth color changes between visibility states
+- Entities fade in/out of view
+- Explored areas remain visible but dimmed
+
+## Exercises
+
+1. **Variable Vision**: Give different entities different FOV radii
+2. **Light Sources**: Create torches that expand local FOV
+3. **Blind Spots**: Add pillars that create interesting shadows
+4. **X-Ray Vision**: Temporary power-up to see through walls
+
+## What's Next?
+
+In Part 5, we'll place enemies throughout the dungeon and implement basic interactions. With FOV in place, enemies will appear and disappear as you explore, creating tension and surprise!
+
+Field of View transforms our dungeon from a tactical puzzle into a mysterious world to explore. The fog of war adds atmosphere and gameplay depth that's essential to the roguelike experience.

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_4/code/game.py

@@ -0,0 +1,334 @@
+import mcrfpy
+import random
+
+# Color configurations for visibility
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    
+    'floor': (50, 50, 50),      
+    'tunnel': (30, 30, 40),     
+}
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+        self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering (0 = first entity = player)
+        self.grid.perspective = 0
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, tile_type='wall')
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, tile_type='floor')
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, tile_type='tunnel')
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        if not self.grid.at(x, y).walkable:
+            return True
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return True
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        self.fov_radius = 8
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 4"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player
+        self.player = GameObject(0, 0, 64, (255, 255, 255), "Player", blocks=True)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Add monsters in random rooms
+        for i in range(10):
+            if i < len(self.game_map.rooms) - 1:
+                room = self.game_map.rooms[i + 1]
+                x, y = room.center
+                
+                # Randomly offset from center
+                x += random.randint(-2, 2)
+                y += random.randint(-2, 2)
+                
+                # Make sure position is walkable
+                if self.game_map.grid.at(x, y).walkable:
+                    if i % 2 == 0:
+                        # Create an orc
+                        orc = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                        self.game_map.add_entity(orc)
+                        self.entities.append(orc)
+                    else:
+                        # Create a troll
+                        troll = GameObject(x, y, 84, (0, 127, 0), "Troll", blocks=True)
+                        self.game_map.add_entity(troll)
+                        self.entities.append(troll)
+        
+        # Initial FOV calculation
+        self.player.update_fov()
+    
+    def handle_movement(self, dx, dy):
+        """Handle player movement"""
+        new_x = self.player.x + dx
+        new_y = self.player.y + dy
+        
+        if not self.game_map.is_blocked(new_x, new_y):
+            self.player.move(dx, dy)
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                self.handle_movement(dx, dy)
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+            elif key == "v":
+                # Toggle FOV on/off
+                if self.game_map.grid.perspective == 0:
+                    self.game_map.grid.perspective = -1  # Omniscient
+                    print("FOV disabled - omniscient view")
+                else:
+                    self.game_map.grid.perspective = 0  # Player perspective
+                    print("FOV enabled - player perspective")
+            elif key == "Plus" or key == "Equals":
+                # Increase FOV radius
+                self.fov_radius = min(self.fov_radius + 1, 20)
+                self.player._entity.update_fov(radius=self.fov_radius)
+                print(f"FOV radius: {self.fov_radius}")
+            elif key == "Minus":
+                # Decrease FOV radius
+                self.fov_radius = max(self.fov_radius - 1, 3)
+                self.player._entity.update_fov(radius=self.fov_radius)
+                print(f"FOV radius: {self.fov_radius}")
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Field of View", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Arrow keys to move | V to toggle FOV | +/- to adjust radius | ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+        
+        # FOV indicator
+        self.fov_text = mcrfpy.Caption(f"FOV Radius: {self.fov_radius}", 900, 100)
+        self.fov_text.font_size = 14
+        self.fov_text.fill_color = mcrfpy.Color(150, 200, 255)
+        self.ui.append(self.fov_text)
+
+# Create and run the game
+engine = Engine()
+print("Part 4: Field of View!")
+print("Press V to toggle FOV on/off")
+print("Press +/- to adjust FOV radius")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_5/README.md

@@ -0,0 +1,570 @@
+# Part 5 - Placing Enemies and Kicking Them (Harmlessly)
+
+Now that we have Field of View working, it's time to populate our dungeon with enemies! In this part, we'll:
+- Place enemies randomly in rooms
+- Implement entity-to-entity collision detection
+- Create basic interactions (bumping into enemies)
+- Set the stage for combat in Part 6
+
+## Enemy Spawning System
+
+First, let's create a system to spawn enemies in our dungeon rooms. We'll avoid placing them in the first room (where the player starts) to give players a safe starting area.
+
+```python
+def spawn_enemies_in_room(room, game_map, max_enemies=2):
+    """Spawn between 0 and max_enemies in a room"""
+    import random
+    
+    number_of_enemies = random.randint(0, max_enemies)
+    
+    for i in range(number_of_enemies):
+        # Try to find a valid position
+        attempts = 10
+        while attempts > 0:
+            # Random position within room bounds
+            x = random.randint(room.x1 + 1, room.x2 - 1)
+            y = random.randint(room.y1 + 1, room.y2 - 1)
+            
+            # Check if position is valid
+            if not game_map.is_blocked(x, y):
+                # 80% chance for orc, 20% for troll
+                if random.random() < 0.8:
+                    enemy = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                else:
+                    enemy = GameObject(x, y, 84, (0, 127, 0), "Troll", blocks=True)
+                
+                game_map.add_entity(enemy)
+                break
+            
+            attempts -= 1
+```
+
+## Enhanced Collision Detection
+
+We need to improve our collision detection to check for entities, not just walls:
+
+```python
+class GameMap:
+    """Manages the game world"""
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        # Check boundaries
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        # Check walls
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        # Check entities
+        if self.get_blocking_entity_at(x, y):
+            return True
+        
+        return False
+```
+
+## Action System Introduction
+
+Let's create a simple action system to handle different types of interactions:
+
+```python
+class Action:
+    """Base class for all actions"""
+    pass
+
+class MovementAction(Action):
+    """Action for moving an entity"""
+    def __init__(self, dx, dy):
+        self.dx = dx
+        self.dy = dy
+
+class BumpAction(Action):
+    """Action for bumping into something"""
+    def __init__(self, dx, dy, target=None):
+        self.dx = dx
+        self.dy = dy
+        self.target = target
+
+class WaitAction(Action):
+    """Action for waiting/skipping turn"""
+    pass
+```
+
+## Handling Player Actions
+
+Now let's update our movement handling to support bumping into enemies:
+
+```python
+def handle_player_turn(self, action):
+    """Process the player's action"""
+    if isinstance(action, MovementAction):
+        dest_x = self.player.x + action.dx
+        dest_y = self.player.y + action.dy
+        
+        # Check what's at the destination
+        target = self.game_map.get_blocking_entity_at(dest_x, dest_y)
+        
+        if target:
+            # We bumped into something!
+            print(f"You kick the {target.name} in the shins, much to its annoyance!")
+        elif not self.game_map.is_blocked(dest_x, dest_y):
+            # Move the player
+            self.player.move(action.dx, action.dy)
+            # Update message
+            self.status_text.text = "Exploring the dungeon..."
+        else:
+            # Bumped into a wall
+            self.status_text.text = "Ouch! You bump into a wall."
+    
+    elif isinstance(action, WaitAction):
+        self.status_text.text = "You wait..."
+```
+
+## Complete Updated Code
+
+Here's the complete `game.py` with enemy placement and interactions:
+
+```python
+import mcrfpy
+import random
+
+# Color configurations
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    
+    'floor': (50, 50, 50),      
+    'tunnel': (30, 30, 40),     
+}
+
+# Actions
+class Action:
+    """Base class for all actions"""
+    pass
+
+class MovementAction(Action):
+    """Action for moving an entity"""
+    def __init__(self, dx, dy):
+        self.dx = dx
+        self.dy = dy
+
+class WaitAction(Action):
+    """Action for waiting/skipping turn"""
+    pass
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+def spawn_enemies_in_room(room, game_map, max_enemies=2):
+    """Spawn between 0 and max_enemies in a room"""
+    number_of_enemies = random.randint(0, max_enemies)
+    
+    enemies_spawned = []
+    
+    for i in range(number_of_enemies):
+        # Try to find a valid position
+        attempts = 10
+        while attempts > 0:
+            # Random position within room bounds
+            x = random.randint(room.x1 + 1, room.x2 - 1)
+            y = random.randint(room.y1 + 1, room.y2 - 1)
+            
+            # Check if position is valid
+            if not game_map.is_blocked(x, y):
+                # 80% chance for orc, 20% for troll
+                if random.random() < 0.8:
+                    enemy = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                else:
+                    enemy = GameObject(x, y, 84, (0, 127, 0), "Troll", blocks=True)
+                
+                game_map.add_entity(enemy)
+                enemies_spawned.append(enemy)
+                break
+            
+            attempts -= 1
+    
+    return enemies_spawned
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering
+        self.grid.perspective = 0
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, tile_type='wall')
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player, max_enemies_per_room):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                # First room - place player
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                # All other rooms - add tunnel and enemies
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+                spawn_enemies_in_room(new_room, self, max_enemies_per_room)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, tile_type='floor')
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, tile_type='tunnel')
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        if self.get_blocking_entity_at(x, y):
+            return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 5"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player
+        self.player = GameObject(0, 0, 64, (255, 255, 255), "Player", blocks=True)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player,
+            max_enemies_per_room=2
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Store reference to all entities
+        self.entities = [e for e in self.game_map.entities if e != self.player]
+        
+        # Initial FOV calculation
+        self.player.update_fov()
+    
+    def handle_player_turn(self, action):
+        """Process the player's action"""
+        if isinstance(action, MovementAction):
+            dest_x = self.player.x + action.dx
+            dest_y = self.player.y + action.dy
+            
+            # Check what's at the destination
+            target = self.game_map.get_blocking_entity_at(dest_x, dest_y)
+            
+            if target:
+                # We bumped into something!
+                print(f"You kick the {target.name} in the shins, much to its annoyance!")
+                self.status_text.text = f"You kick the {target.name}!"
+            elif not self.game_map.is_blocked(dest_x, dest_y):
+                # Move the player
+                self.player.move(action.dx, action.dy)
+                self.status_text.text = ""
+            else:
+                # Bumped into a wall
+                self.status_text.text = "Blocked!"
+        
+        elif isinstance(action, WaitAction):
+            self.status_text.text = "You wait..."
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            action = None
+            
+            # Movement keys
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num5": (0, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                if dx == 0 and dy == 0:
+                    action = WaitAction()
+                else:
+                    action = MovementAction(dx, dy)
+            elif key == "Period":
+                action = WaitAction()
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+                return
+            
+            # Process the action
+            if action:
+                self.handle_player_turn(action)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Placing Enemies", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Arrow keys to move | . to wait | Bump into enemies! | ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+        
+        # Status text
+        self.status_text = mcrfpy.Caption("", 512, 600)
+        self.status_text.font_size = 18
+        self.status_text.fill_color = mcrfpy.Color(255, 200, 200)
+        self.ui.append(self.status_text)
+        
+        # Entity count
+        entity_count = len(self.entities)
+        count_text = mcrfpy.Caption(f"Enemies: {entity_count}", 900, 100)
+        count_text.font_size = 14
+        count_text.fill_color = mcrfpy.Color(150, 150, 255)
+        self.ui.append(count_text)
+
+# Create and run the game
+engine = Engine()
+print("Part 5: Placing Enemies!")
+print("Try bumping into enemies - combat coming in Part 6!")
+```
+
+## Understanding Entity Interactions
+
+### Collision Detection
+Our system now checks three things when the player tries to move:
+1. **Map boundaries** - Can't move outside the map
+2. **Wall tiles** - Can't walk through walls
+3. **Blocking entities** - Can't walk through enemies
+
+### The Action System
+We've introduced a simple action system that will grow in Part 6:
+- `Action` - Base class for all actions
+- `MovementAction` - Represents attempted movement
+- `WaitAction` - Skip a turn (important for turn-based games)
+
+### Entity Spawning
+Enemies are placed randomly in rooms with these rules:
+- Never in the first room (player's starting room)
+- Random number between 0 and max per room
+- 80% orcs, 20% trolls
+- Must be placed on walkable, unoccupied tiles
+
+## Visual Feedback
+
+With FOV enabled, enemies will appear and disappear as you explore:
+- Enemies in sight are fully visible
+- Enemies in explored but dark areas are hidden
+- Creates tension and surprise encounters
+
+## Exercises
+
+1. **More Enemy Types**: Add different sprites and names (goblins, skeletons)
+2. **Enemy Density**: Adjust spawn rates based on dungeon depth
+3. **Special Rooms**: Create rooms with guaranteed enemies or treasures
+4. **Better Feedback**: Add sound effects or visual effects for bumping
+
+## What's Next?
+
+In Part 6, we'll transform those harmless kicks into a real combat system! We'll add:
+- Health points for all entities
+- Damage calculations
+- Death and corpses
+- Combat messages
+- The beginning of a real roguelike!
+
+Right now our enemies are just obstacles. Soon they'll fight back!

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_5/code/game.py

@@ -0,0 +1,388 @@
+import mcrfpy
+import random
+
+# Color configurations
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    
+    'floor': (50, 50, 50),      
+    'tunnel': (30, 30, 40),     
+}
+
+# Actions
+class Action:
+    """Base class for all actions"""
+    pass
+
+class MovementAction(Action):
+    """Action for moving an entity"""
+    def __init__(self, dx, dy):
+        self.dx = dx
+        self.dy = dy
+
+class WaitAction(Action):
+    """Action for waiting/skipping turn"""
+    pass
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, blocks=False):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+def spawn_enemies_in_room(room, game_map, max_enemies=2):
+    """Spawn between 0 and max_enemies in a room"""
+    number_of_enemies = random.randint(0, max_enemies)
+    
+    enemies_spawned = []
+    
+    for i in range(number_of_enemies):
+        # Try to find a valid position
+        attempts = 10
+        while attempts > 0:
+            # Random position within room bounds
+            x = random.randint(room.x1 + 1, room.x2 - 1)
+            y = random.randint(room.y1 + 1, room.y2 - 1)
+            
+            # Check if position is valid
+            if not game_map.is_blocked(x, y):
+                # 80% chance for orc, 20% for troll
+                if random.random() < 0.8:
+                    enemy = GameObject(x, y, 111, (63, 127, 63), "Orc", blocks=True)
+                else:
+                    enemy = GameObject(x, y, 84, (0, 127, 0), "Troll", blocks=True)
+                
+                game_map.add_entity(enemy)
+                enemies_spawned.append(enemy)
+                break
+            
+            attempts -= 1
+    
+    return enemies_spawned
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+        self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering
+        self.grid.perspective = 0
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, tile_type='wall')
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player, max_enemies_per_room):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                # First room - place player
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                # All other rooms - add tunnel and enemies
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+                spawn_enemies_in_room(new_room, self, max_enemies_per_room)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, tile_type='floor')
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, tile_type='tunnel')
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        if self.get_blocking_entity_at(x, y):
+            return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 5"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player
+        self.player = GameObject(0, 0, 64, (255, 255, 255), "Player", blocks=True)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player,
+            max_enemies_per_room=2
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Store reference to all entities
+        self.entities = [e for e in self.game_map.entities if e != self.player]
+        
+        # Initial FOV calculation
+        self.player.update_fov()
+    
+    def handle_player_turn(self, action):
+        """Process the player's action"""
+        if isinstance(action, MovementAction):
+            dest_x = self.player.x + action.dx
+            dest_y = self.player.y + action.dy
+            
+            # Check what's at the destination
+            target = self.game_map.get_blocking_entity_at(dest_x, dest_y)
+            
+            if target:
+                # We bumped into something!
+                print(f"You kick the {target.name} in the shins, much to its annoyance!")
+                self.status_text.text = f"You kick the {target.name}!"
+            elif not self.game_map.is_blocked(dest_x, dest_y):
+                # Move the player
+                self.player.move(action.dx, action.dy)
+                self.status_text.text = ""
+            else:
+                # Bumped into a wall
+                self.status_text.text = "Blocked!"
+        
+        elif isinstance(action, WaitAction):
+            self.status_text.text = "You wait..."
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            action = None
+            
+            # Movement keys
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num5": (0, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                if dx == 0 and dy == 0:
+                    action = WaitAction()
+                else:
+                    action = MovementAction(dx, dy)
+            elif key == "Period":
+                action = WaitAction()
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+                return
+            
+            # Process the action
+            if action:
+                self.handle_player_turn(action)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Placing Enemies", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Arrow keys to move | . to wait | Bump into enemies! | ESC to quit", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+        
+        # Status text
+        self.status_text = mcrfpy.Caption("", 512, 600)
+        self.status_text.font_size = 18
+        self.status_text.fill_color = mcrfpy.Color(255, 200, 200)
+        self.ui.append(self.status_text)
+        
+        # Entity count
+        entity_count = len(self.entities)
+        count_text = mcrfpy.Caption(f"Enemies: {entity_count}", 900, 100)
+        count_text.font_size = 14
+        count_text.fill_color = mcrfpy.Color(150, 150, 255)
+        self.ui.append(count_text)
+
+# Create and run the game
+engine = Engine()
+print("Part 5: Placing Enemies!")
+print("Try bumping into enemies - combat coming in Part 6!")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_6/README.md

@@ -0,0 +1,743 @@
+# Part 6 - Doing (and Taking) Some Damage
+
+It's time to turn our harmless kicks into real combat! In this part, we'll implement:
+- Health points for all entities
+- A damage calculation system
+- Death and corpse mechanics
+- Combat feedback messages
+- The foundation of tactical roguelike combat
+
+## Adding Combat Stats
+
+First, let's enhance our GameObject class with combat capabilities:
+
+```python
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, 
+                 blocks=False, hp=0, defense=0, power=0):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+        
+        # Combat stats
+        self.max_hp = hp
+        self.hp = hp
+        self.defense = defense
+        self.power = power
+        
+    @property
+    def is_alive(self):
+        """Returns True if this entity can act"""
+        return self.hp > 0
+    
+    def take_damage(self, amount):
+        """Apply damage to this entity"""
+        damage = amount - self.defense
+        if damage > 0:
+            self.hp -= damage
+            
+        # Check for death
+        if self.hp <= 0 and self.hp + damage > 0:
+            self.die()
+            
+        return damage
+    
+    def die(self):
+        """Handle entity death"""
+        if self.name == "Player":
+            # Player death is special - we'll handle it differently
+            self.sprite_index = 64  # Stay as @ but change color
+            self.color = (127, 0, 0)  # Dark red
+            if self._entity:
+                self._entity.color = mcrfpy.Color(127, 0, 0)
+            print("You have died!")
+        else:
+            # Enemy death
+            self.sprite_index = 37  # % character for corpse
+            self.color = (127, 0, 0)  # Dark red
+            self.blocks = False  # Corpses don't block
+            self.name = f"remains of {self.name}"
+            
+            if self._entity:
+                self._entity.sprite_index = 37
+                self._entity.color = mcrfpy.Color(127, 0, 0)
+```
+
+## The Combat System
+
+Now let's implement actual combat when entities bump into each other:
+
+```python
+class MeleeAction(Action):
+    """Action for melee attacks"""
+    def __init__(self, attacker, target):
+        self.attacker = attacker
+        self.target = target
+    
+    def perform(self):
+        """Execute the attack"""
+        if not self.target.is_alive:
+            return  # Can't attack the dead
+        
+        damage = self.attacker.power - self.target.defense
+        
+        if damage > 0:
+            attack_desc = f"{self.attacker.name} attacks {self.target.name} for {damage} damage!"
+            self.target.take_damage(damage)
+        else:
+            attack_desc = f"{self.attacker.name} attacks {self.target.name} but does no damage."
+        
+        return attack_desc
+```
+
+## Entity Factories
+
+Let's create factory functions for consistent entity creation:
+
+```python
+def create_player(x, y):
+    """Create the player entity"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=64,  # @
+        color=(255, 255, 255),
+        name="Player",
+        blocks=True,
+        hp=30,
+        defense=2,
+        power=5
+    )
+
+def create_orc(x, y):
+    """Create an orc enemy"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=111,  # o
+        color=(63, 127, 63),
+        name="Orc",
+        blocks=True,
+        hp=10,
+        defense=0,
+        power=3
+    )
+
+def create_troll(x, y):
+    """Create a troll enemy"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=84,  # T
+        color=(0, 127, 0),
+        name="Troll",
+        blocks=True,
+        hp=16,
+        defense=1,
+        power=4
+    )
+```
+
+## The Message Log
+
+Combat needs feedback! Let's create a simple message log:
+
+```python
+class MessageLog:
+    """Manages game messages"""
+    def __init__(self, max_messages=5):
+        self.messages = []
+        self.max_messages = max_messages
+        
+    def add_message(self, text, color=(255, 255, 255)):
+        """Add a message to the log"""
+        self.messages.append((text, color))
+        # Keep only recent messages
+        if len(self.messages) > self.max_messages:
+            self.messages.pop(0)
+    
+    def render(self, ui, x, y, line_height=20):
+        """Render messages to the UI"""
+        for i, (text, color) in enumerate(self.messages):
+            caption = mcrfpy.Caption(text, x, y + i * line_height)
+            caption.font_size = 14
+            caption.fill_color = mcrfpy.Color(*color)
+            ui.append(caption)
+```
+
+## Complete Implementation
+
+Here's the complete `game.py` with combat:
+
+```python
+import mcrfpy
+import random
+
+# Color configurations
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    
+    'floor': (50, 50, 50),      
+    'tunnel': (30, 30, 40),     
+}
+
+# Message colors
+COLOR_PLAYER_ATK = (230, 230, 230)
+COLOR_ENEMY_ATK = (255, 200, 200)
+COLOR_PLAYER_DIE = (255, 100, 100)
+COLOR_ENEMY_DIE = (255, 165, 0)
+
+# Actions
+class Action:
+    """Base class for all actions"""
+    pass
+
+class MovementAction(Action):
+    """Action for moving an entity"""
+    def __init__(self, dx, dy):
+        self.dx = dx
+        self.dy = dy
+
+class MeleeAction(Action):
+    """Action for melee attacks"""
+    def __init__(self, attacker, target):
+        self.attacker = attacker
+        self.target = target
+    
+    def perform(self):
+        """Execute the attack"""
+        if not self.target.is_alive:
+            return None
+        
+        damage = self.attacker.power - self.target.defense
+        
+        if damage > 0:
+            attack_desc = f"{self.attacker.name} attacks {self.target.name} for {damage} damage!"
+            self.target.take_damage(damage)
+            
+            # Choose color based on attacker
+            if self.attacker.name == "Player":
+                color = COLOR_PLAYER_ATK
+            else:
+                color = COLOR_ENEMY_ATK
+                
+            return attack_desc, color
+        else:
+            attack_desc = f"{self.attacker.name} attacks {self.target.name} but does no damage."
+            return attack_desc, (150, 150, 150)
+
+class WaitAction(Action):
+    """Action for waiting/skipping turn"""
+    pass
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, 
+                 blocks=False, hp=0, defense=0, power=0):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+        
+        # Combat stats
+        self.max_hp = hp
+        self.hp = hp
+        self.defense = defense
+        self.power = power
+        
+    @property
+    def is_alive(self):
+        """Returns True if this entity can act"""
+        return self.hp > 0
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+    
+    def take_damage(self, amount):
+        """Apply damage to this entity"""
+        self.hp -= amount
+            
+        # Check for death
+        if self.hp <= 0:
+            self.die()
+    
+    def die(self):
+        """Handle entity death"""
+        if self.name == "Player":
+            # Player death
+            self.sprite_index = 64  # Stay as @
+            self.color = (127, 0, 0)  # Dark red
+            if self._entity:
+                self._entity.color = mcrfpy.Color(127, 0, 0)
+        else:
+            # Enemy death
+            self.sprite_index = 37  # % character for corpse
+            self.color = (127, 0, 0)  # Dark red
+            self.blocks = False  # Corpses don't block
+            self.name = f"remains of {self.name}"
+            
+            if self._entity:
+                self._entity.sprite_index = 37
+                self._entity.color = mcrfpy.Color(127, 0, 0)
+
+# Entity factories
+def create_player(x, y):
+    """Create the player entity"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=64,  # @
+        color=(255, 255, 255),
+        name="Player",
+        blocks=True,
+        hp=30,
+        defense=2,
+        power=5
+    )
+
+def create_orc(x, y):
+    """Create an orc enemy"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=111,  # o
+        color=(63, 127, 63),
+        name="Orc",
+        blocks=True,
+        hp=10,
+        defense=0,
+        power=3
+    )
+
+def create_troll(x, y):
+    """Create a troll enemy"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=84,  # T
+        color=(0, 127, 0),
+        name="Troll",
+        blocks=True,
+        hp=16,
+        defense=1,
+        power=4
+    )
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+def spawn_enemies_in_room(room, game_map, max_enemies=2):
+    """Spawn between 0 and max_enemies in a room"""
+    number_of_enemies = random.randint(0, max_enemies)
+    
+    enemies_spawned = []
+    
+    for i in range(number_of_enemies):
+        attempts = 10
+        while attempts > 0:
+            x = random.randint(room.x1 + 1, room.x2 - 1)
+            y = random.randint(room.y1 + 1, room.y2 - 1)
+            
+            if not game_map.is_blocked(x, y):
+                # 80% chance for orc, 20% for troll
+                if random.random() < 0.8:
+                    enemy = create_orc(x, y)
+                else:
+                    enemy = create_troll(x, y)
+                
+                game_map.add_entity(enemy)
+                enemies_spawned.append(enemy)
+                break
+            
+            attempts -= 1
+    
+    return enemies_spawned
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+                self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering
+        self.grid.perspective = 0
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, tile_type='wall')
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player, max_enemies_per_room):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                # First room - place player
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                # All other rooms - add tunnel and enemies
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+                spawn_enemies_in_room(new_room, self, max_enemies_per_room)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, tile_type='floor')
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, tile_type='tunnel')
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        if self.get_blocking_entity_at(x, y):
+            return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        self.messages = []  # Simple message log
+        self.max_messages = 5
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 6"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def add_message(self, text, color=(255, 255, 255)):
+        """Add a message to the log"""
+        self.messages.append((text, color))
+        if len(self.messages) > self.max_messages:
+            self.messages.pop(0)
+        self.update_message_display()
+    
+    def update_message_display(self):
+        """Update the message display"""
+        # Clear old messages
+        for caption in self.message_captions:
+            # Remove from UI (McRogueFace doesn't have remove, so we hide it)
+            caption.text = ""
+        
+        # Display current messages
+        for i, (text, color) in enumerate(self.messages):
+            if i < len(self.message_captions):
+                self.message_captions[i].text = text
+                self.message_captions[i].fill_color = mcrfpy.Color(*color)
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player
+        self.player = create_player(0, 0)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player,
+            max_enemies_per_room=2
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Store reference to all entities
+        self.entities = [e for e in self.game_map.entities if e != self.player]
+        
+        # Initial FOV calculation
+        self.player.update_fov()
+        
+        # Welcome message
+        self.add_message("Welcome to the dungeon!", (100, 100, 255))
+    
+    def handle_player_turn(self, action):
+        """Process the player's action"""
+        if not self.player.is_alive:
+            return
+            
+        if isinstance(action, MovementAction):
+            dest_x = self.player.x + action.dx
+            dest_y = self.player.y + action.dy
+            
+            # Check what's at the destination
+            target = self.game_map.get_blocking_entity_at(dest_x, dest_y)
+            
+            if target:
+                # Attack!
+                attack = MeleeAction(self.player, target)
+                result = attack.perform()
+                if result:
+                    text, color = result
+                    self.add_message(text, color)
+                    
+                    # Check if target died
+                    if not target.is_alive:
+                        death_msg = f"The {target.name.replace('remains of ', '')} is dead!"
+                        self.add_message(death_msg, COLOR_ENEMY_DIE)
+                        
+            elif not self.game_map.is_blocked(dest_x, dest_y):
+                # Move the player
+                self.player.move(action.dx, action.dy)
+                
+        elif isinstance(action, WaitAction):
+            pass  # Do nothing
+        
+        # Enemy turns
+        self.handle_enemy_turns()
+    
+    def handle_enemy_turns(self):
+        """Let all enemies take their turn"""
+        for entity in self.entities:
+            if entity.is_alive:
+                # Simple AI: if player is adjacent, attack. Otherwise, do nothing.
+                dx = entity.x - self.player.x
+                dy = entity.y - self.player.y
+                distance = abs(dx) + abs(dy)
+                
+                if distance == 1:  # Adjacent to player
+                    attack = MeleeAction(entity, self.player)
+                    result = attack.perform()
+                    if result:
+                        text, color = result
+                        self.add_message(text, color)
+                        
+                        # Check if player died
+                        if not self.player.is_alive:
+                            self.add_message("You have died!", COLOR_PLAYER_DIE)
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            action = None
+            
+            # Movement keys
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num5": (0, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                if dx == 0 and dy == 0:
+                    action = WaitAction()
+                else:
+                    action = MovementAction(dx, dy)
+            elif key == "Period":
+                action = WaitAction()
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+                return
+            
+            # Process the action
+            if action:
+                self.handle_player_turn(action)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Combat System", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Attack enemies by bumping into them!", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+        
+        # Player stats
+        self.hp_text = mcrfpy.Caption(f"HP: {self.player.hp}/{self.player.max_hp}", 50, 100)
+        self.hp_text.font_size = 18
+        self.hp_text.fill_color = mcrfpy.Color(255, 100, 100)
+        self.ui.append(self.hp_text)
+        
+        # Message log
+        self.message_captions = []
+        for i in range(self.max_messages):
+            caption = mcrfpy.Caption("", 50, 620 + i * 20)
+            caption.font_size = 14
+            caption.fill_color = mcrfpy.Color(200, 200, 200)
+            self.ui.append(caption)
+            self.message_captions.append(caption)
+        
+        # Timer to update HP display
+        def update_stats(dt):
+            self.hp_text.text = f"HP: {self.player.hp}/{self.player.max_hp}"
+            if self.player.hp <= 0:
+                self.hp_text.fill_color = mcrfpy.Color(127, 0, 0)
+            elif self.player.hp < self.player.max_hp // 3:
+                self.hp_text.fill_color = mcrfpy.Color(255, 100, 100)
+            else:
+                self.hp_text.fill_color = mcrfpy.Color(0, 255, 0)
+        
+        mcrfpy.setTimer("update_stats", update_stats, 100)
+
+# Create and run the game
+engine = Engine()
+print("Part 6: Combat System!")
+print("Attack enemies to defeat them, but watch your HP!")

roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_6/code/game.py

@@ -0,0 +1,568 @@
+import mcrfpy
+import random
+
+# Color configurations
+COLORS_VISIBLE = {
+    'wall': (100, 100, 100),    
+    'floor': (50, 50, 50),      
+    'tunnel': (30, 30, 40),     
+}
+
+# Message colors
+COLOR_PLAYER_ATK = (230, 230, 230)
+COLOR_ENEMY_ATK = (255, 200, 200)
+COLOR_PLAYER_DIE = (255, 100, 100)
+COLOR_ENEMY_DIE = (255, 165, 0)
+
+# Actions
+class Action:
+    """Base class for all actions"""
+    pass
+
+class MovementAction(Action):
+    """Action for moving an entity"""
+    def __init__(self, dx, dy):
+        self.dx = dx
+        self.dy = dy
+
+class MeleeAction(Action):
+    """Action for melee attacks"""
+    def __init__(self, attacker, target):
+        self.attacker = attacker
+        self.target = target
+    
+    def perform(self):
+        """Execute the attack"""
+        if not self.target.is_alive:
+            return None
+        
+        damage = self.attacker.power - self.target.defense
+        
+        if damage > 0:
+            attack_desc = f"{self.attacker.name} attacks {self.target.name} for {damage} damage!"
+            self.target.take_damage(damage)
+            
+            # Choose color based on attacker
+            if self.attacker.name == "Player":
+                color = COLOR_PLAYER_ATK
+            else:
+                color = COLOR_ENEMY_ATK
+                
+            return attack_desc, color
+        else:
+            attack_desc = f"{self.attacker.name} attacks {self.target.name} but does no damage."
+            return attack_desc, (150, 150, 150)
+
+class WaitAction(Action):
+    """Action for waiting/skipping turn"""
+    pass
+
+class GameObject:
+    """Base class for all game objects"""
+    def __init__(self, x, y, sprite_index, color, name, 
+                 blocks=False, hp=0, defense=0, power=0):
+        self.x = x
+        self.y = y
+        self.sprite_index = sprite_index
+        self.color = color
+        self.name = name
+        self.blocks = blocks
+        self._entity = None
+        self.grid = None
+        
+        # Combat stats
+        self.max_hp = hp
+        self.hp = hp
+        self.defense = defense
+        self.power = power
+        
+    @property
+    def is_alive(self):
+        """Returns True if this entity can act"""
+        return self.hp > 0
+    
+    def attach_to_grid(self, grid):
+        """Attach this game object to a McRogueFace grid"""
+        self.grid = grid
+        self._entity = mcrfpy.Entity(x=self.x, y=self.y, grid=grid)
+        self._entity.sprite_index = self.sprite_index
+        self._entity.color = mcrfpy.Color(*self.color)
+    
+    def move(self, dx, dy):
+        """Move by the given amount"""
+        if not self.grid:
+            return
+        self.x += dx
+        self.y += dy
+        if self._entity:
+            self._entity.x = self.x
+            self._entity.y = self.y
+            # Update FOV when player moves
+            if self.name == "Player":
+                self.update_fov()
+    
+    def update_fov(self):
+        """Update field of view from this entity's position"""
+        if self._entity and self.grid:
+            self._entity.update_fov(radius=8)
+    
+    def take_damage(self, amount):
+        """Apply damage to this entity"""
+        self.hp -= amount
+            
+        # Check for death
+        if self.hp <= 0:
+            self.die()
+    
+    def die(self):
+        """Handle entity death"""
+        if self.name == "Player":
+            # Player death
+            self.sprite_index = 64  # Stay as @
+            self.color = (127, 0, 0)  # Dark red
+            if self._entity:
+                self._entity.color = mcrfpy.Color(127, 0, 0)
+        else:
+            # Enemy death
+            self.sprite_index = 37  # % character for corpse
+            self.color = (127, 0, 0)  # Dark red
+            self.blocks = False  # Corpses don't block
+            self.name = f"remains of {self.name}"
+            
+            if self._entity:
+                self._entity.sprite_index = 37
+                self._entity.color = mcrfpy.Color(127, 0, 0)
+
+# Entity factories
+def create_player(x, y):
+    """Create the player entity"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=64,  # @
+        color=(255, 255, 255),
+        name="Player",
+        blocks=True,
+        hp=30,
+        defense=2,
+        power=5
+    )
+
+def create_orc(x, y):
+    """Create an orc enemy"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=111,  # o
+        color=(63, 127, 63),
+        name="Orc",
+        blocks=True,
+        hp=10,
+        defense=0,
+        power=3
+    )
+
+def create_troll(x, y):
+    """Create a troll enemy"""
+    return GameObject(
+        x=x, y=y,
+        sprite_index=84,  # T
+        color=(0, 127, 0),
+        name="Troll",
+        blocks=True,
+        hp=16,
+        defense=1,
+        power=4
+    )
+
+class RectangularRoom:
+    """A rectangular room with its position and size"""
+    
+    def __init__(self, x, y, width, height):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + width
+        self.y2 = y + height
+        
+    @property
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return center_x, center_y
+    
+    @property
+    def inner(self):
+        return self.x1 + 1, self.y1 + 1, self.x2 - 1, self.y2 - 1
+    
+    def intersects(self, other):
+        return (
+            self.x1 <= other.x2
+            and self.x2 >= other.x1
+            and self.y1 <= other.y2
+            and self.y2 >= other.y1
+        )
+
+def tunnel_between(start, end):
+    """Return an L-shaped tunnel between two points"""
+    x1, y1 = start
+    x2, y2 = end
+    
+    if random.random() < 0.5:
+        corner_x = x2
+        corner_y = y1
+    else:
+        corner_x = x1
+        corner_y = y2
+    
+    for x in range(min(x1, corner_x), max(x1, corner_x) + 1):
+        yield x, y1
+    for y in range(min(y1, corner_y), max(y1, corner_y) + 1):
+        yield corner_x, y
+    for x in range(min(corner_x, x2), max(corner_x, x2) + 1):
+        yield x, corner_y
+    for y in range(min(corner_y, y2), max(corner_y, y2) + 1):
+        yield x2, y
+
+def spawn_enemies_in_room(room, game_map, max_enemies=2):
+    """Spawn between 0 and max_enemies in a room"""
+    number_of_enemies = random.randint(0, max_enemies)
+    
+    enemies_spawned = []
+    
+    for i in range(number_of_enemies):
+        attempts = 10
+        while attempts > 0:
+            x = random.randint(room.x1 + 1, room.x2 - 1)
+            y = random.randint(room.y1 + 1, room.y2 - 1)
+            
+            if not game_map.is_blocked(x, y):
+                # 80% chance for orc, 20% for troll
+                if random.random() < 0.8:
+                    enemy = create_orc(x, y)
+                else:
+                    enemy = create_troll(x, y)
+                
+                game_map.add_entity(enemy)
+                enemies_spawned.append(enemy)
+                break
+            
+            attempts -= 1
+    
+    return enemies_spawned
+
+class GameMap:
+    """Manages the game world"""
+    
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid = None
+        self.entities = []
+        self.rooms = []
+        
+    def create_grid(self, tileset):
+        """Create the McRogueFace grid"""
+        self.grid = mcrfpy.Grid(grid_x=self.width, grid_y=self.height, texture=tileset)
+        self.grid.position = (100, 100)
+        self.grid.size = (800, 480)
+        
+        # Enable perspective rendering
+        self.grid.perspective = 0
+        
+        return self.grid
+    
+    def fill_with_walls(self):
+        """Fill the entire map with wall tiles"""
+        for y in range(self.height):
+            for x in range(self.width):
+                self.set_tile(x, y, walkable=False, transparent=False, 
+                            sprite_index=35, tile_type='wall')
+    
+    def set_tile(self, x, y, walkable, transparent, sprite_index, tile_type):
+        """Set properties for a specific tile"""
+        if 0 <= x < self.width and 0 <= y < self.height:
+            cell = self.grid.at(x, y)
+            cell.walkable = walkable
+            cell.transparent = transparent
+            cell.sprite_index = sprite_index
+            cell.color = mcrfpy.Color(*COLORS_VISIBLE[tile_type])
+    
+    def generate_dungeon(self, max_rooms, room_min_size, room_max_size, player, max_enemies_per_room):
+        """Generate a new dungeon map"""
+        self.fill_with_walls()
+        
+        for r in range(max_rooms):
+            room_width = random.randint(room_min_size, room_max_size)
+            room_height = random.randint(room_min_size, room_max_size)
+            
+            x = random.randint(0, self.width - room_width - 1)
+            y = random.randint(0, self.height - room_height - 1)
+            
+            new_room = RectangularRoom(x, y, room_width, room_height)
+            
+            if any(new_room.intersects(other_room) for other_room in self.rooms):
+                continue
+                
+            self.carve_room(new_room)
+            
+            if len(self.rooms) == 0:
+                # First room - place player
+                player.x, player.y = new_room.center
+                if player._entity:
+                    player._entity.x, player._entity.y = new_room.center
+            else:
+                # All other rooms - add tunnel and enemies
+                self.carve_tunnel(self.rooms[-1].center, new_room.center)
+                spawn_enemies_in_room(new_room, self, max_enemies_per_room)
+            
+            self.rooms.append(new_room)
+    
+    def carve_room(self, room):
+        """Carve out a room"""
+        inner_x1, inner_y1, inner_x2, inner_y2 = room.inner
+        
+        for y in range(inner_y1, inner_y2):
+            for x in range(inner_x1, inner_x2):
+                self.set_tile(x, y, walkable=True, transparent=True,
+                            sprite_index=46, tile_type='floor')
+    
+    def carve_tunnel(self, start, end):
+        """Carve a tunnel between two points"""
+        for x, y in tunnel_between(start, end):
+            self.set_tile(x, y, walkable=True, transparent=True,
+                        sprite_index=46, tile_type='tunnel')
+    
+    def get_blocking_entity_at(self, x, y):
+        """Return any blocking entity at the given position"""
+        for entity in self.entities:
+            if entity.blocks and entity.x == x and entity.y == y:
+                return entity
+        return None
+    
+    def is_blocked(self, x, y):
+        """Check if a tile blocks movement"""
+        if x < 0 or x >= self.width or y < 0 or y >= self.height:
+            return True
+        
+        if not self.grid.at(x, y).walkable:
+            return True
+        
+        if self.get_blocking_entity_at(x, y):
+            return True
+        
+        return False
+    
+    def add_entity(self, entity):
+        """Add a GameObject to the map"""
+        self.entities.append(entity)
+        entity.attach_to_grid(self.grid)
+
+class Engine:
+    """Main game engine"""
+    
+    def __init__(self):
+        self.game_map = None
+        self.player = None
+        self.entities = []
+        self.messages = []  # Simple message log
+        self.max_messages = 5
+        
+        mcrfpy.createScene("game")
+        mcrfpy.setScene("game")
+        
+        window = mcrfpy.Window.get()
+        window.title = "McRogueFace Roguelike - Part 6"
+        
+        self.ui = mcrfpy.sceneUI("game")
+        
+        background = mcrfpy.Frame(0, 0, 1024, 768)
+        background.fill_color = mcrfpy.Color(0, 0, 0)
+        self.ui.append(background)
+        
+        self.tileset = mcrfpy.Texture("assets/sprites/ascii_tileset.png", 16, 16)
+        
+        self.setup_game()
+        self.setup_input()
+        self.setup_ui()
+    
+    def add_message(self, text, color=(255, 255, 255)):
+        """Add a message to the log"""
+        self.messages.append((text, color))
+        if len(self.messages) > self.max_messages:
+            self.messages.pop(0)
+        self.update_message_display()
+    
+    def update_message_display(self):
+        """Update the message display"""
+        # Clear old messages
+        for caption in self.message_captions:
+            # Remove from UI (McRogueFace doesn't have remove, so we hide it)
+            caption.text = ""
+        
+        # Display current messages
+        for i, (text, color) in enumerate(self.messages):
+            if i < len(self.message_captions):
+                self.message_captions[i].text = text
+                self.message_captions[i].fill_color = mcrfpy.Color(*color)
+    
+    def setup_game(self):
+        """Initialize the game world"""
+        self.game_map = GameMap(80, 45)
+        grid = self.game_map.create_grid(self.tileset)
+        self.ui.append(grid)
+        
+        # Create player
+        self.player = create_player(0, 0)
+        
+        # Generate the dungeon
+        self.game_map.generate_dungeon(
+            max_rooms=30,
+            room_min_size=6,
+            room_max_size=10,
+            player=self.player,
+            max_enemies_per_room=2
+        )
+        
+        # Add player to map
+        self.game_map.add_entity(self.player)
+        
+        # Store reference to all entities
+        self.entities = [e for e in self.game_map.entities if e != self.player]
+        
+        # Initial FOV calculation
+        self.player.update_fov()
+        
+        # Welcome message
+        self.add_message("Welcome to the dungeon!", (100, 100, 255))
+    
+    def handle_player_turn(self, action):
+        """Process the player's action"""
+        if not self.player.is_alive:
+            return
+            
+        if isinstance(action, MovementAction):
+            dest_x = self.player.x + action.dx
+            dest_y = self.player.y + action.dy
+            
+            # Check what's at the destination
+            target = self.game_map.get_blocking_entity_at(dest_x, dest_y)
+            
+            if target:
+                # Attack!
+                attack = MeleeAction(self.player, target)
+                result = attack.perform()
+                if result:
+                    text, color = result
+                    self.add_message(text, color)
+                    
+                    # Check if target died
+                    if not target.is_alive:
+                        death_msg = f"The {target.name.replace('remains of ', '')} is dead!"
+                        self.add_message(death_msg, COLOR_ENEMY_DIE)
+                        
+            elif not self.game_map.is_blocked(dest_x, dest_y):
+                # Move the player
+                self.player.move(action.dx, action.dy)
+                
+        elif isinstance(action, WaitAction):
+            pass  # Do nothing
+        
+        # Enemy turns
+        self.handle_enemy_turns()
+    
+    def handle_enemy_turns(self):
+        """Let all enemies take their turn"""
+        for entity in self.entities:
+            if entity.is_alive:
+                # Simple AI: if player is adjacent, attack. Otherwise, do nothing.
+                dx = entity.x - self.player.x
+                dy = entity.y - self.player.y
+                distance = abs(dx) + abs(dy)
+                
+                if distance == 1:  # Adjacent to player
+                    attack = MeleeAction(entity, self.player)
+                    result = attack.perform()
+                    if result:
+                        text, color = result
+                        self.add_message(text, color)
+                        
+                        # Check if player died
+                        if not self.player.is_alive:
+                            self.add_message("You have died!", COLOR_PLAYER_DIE)
+    
+    def setup_input(self):
+        """Setup keyboard input handling"""
+        def handle_keys(key, state):
+            if state != "start":
+                return
+            
+            action = None
+            
+            # Movement keys
+            movement = {
+                "Up": (0, -1), "Down": (0, 1),
+                "Left": (-1, 0), "Right": (1, 0),
+                "Num7": (-1, -1), "Num8": (0, -1), "Num9": (1, -1),
+                "Num4": (-1, 0), "Num5": (0, 0), "Num6": (1, 0),
+                "Num1": (-1, 1), "Num2": (0, 1), "Num3": (1, 1),
+            }
+            
+            if key in movement:
+                dx, dy = movement[key]
+                if dx == 0 and dy == 0:
+                    action = WaitAction()
+                else:
+                    action = MovementAction(dx, dy)
+            elif key == "Period":
+                action = WaitAction()
+            elif key == "Escape":
+                mcrfpy.setScene(None)
+                return
+            
+            # Process the action
+            if action:
+                self.handle_player_turn(action)
+        
+        mcrfpy.keypressScene(handle_keys)
+    
+    def setup_ui(self):
+        """Setup UI elements"""
+        title = mcrfpy.Caption("Combat System", 512, 30)
+        title.font_size = 24
+        title.fill_color = mcrfpy.Color(255, 255, 100)
+        self.ui.append(title)
+        
+        instructions = mcrfpy.Caption("Attack enemies by bumping into them!", 512, 60)
+        instructions.font_size = 16
+        instructions.fill_color = mcrfpy.Color(200, 200, 200)
+        self.ui.append(instructions)
+        
+        # Player stats
+        self.hp_text = mcrfpy.Caption(f"HP: {self.player.hp}/{self.player.max_hp}", 50, 100)
+        self.hp_text.font_size = 18
+        self.hp_text.fill_color = mcrfpy.Color(255, 100, 100)
+        self.ui.append(self.hp_text)
+        
+        # Message log
+        self.message_captions = []
+        for i in range(self.max_messages):
+            caption = mcrfpy.Caption("", 50, 620 + i * 20)
+            caption.font_size = 14
+            caption.fill_color = mcrfpy.Color(200, 200, 200)
+            self.ui.append(caption)
+            self.message_captions.append(caption)
+        
+        # Timer to update HP display
+        def update_stats(dt):
+            self.hp_text.text = f"HP: {self.player.hp}/{self.player.max_hp}"
+            if self.player.hp <= 0:
+                self.hp_text.fill_color = mcrfpy.Color(127, 0, 0)
+            elif self.player.hp < self.player.max_hp // 3:
+                self.hp_text.fill_color = mcrfpy.Color(255, 100, 100)
+            else:
+                self.hp_text.fill_color = mcrfpy.Color(0, 255, 0)
+        
+        mcrfpy.setTimer("update_stats", update_stats, 100)
+
+# Create and run the game
+engine = Engine()
+print("Part 6: Combat System!")
+print("Attack enemies to defeat them, but watch your HP!")

roguelike_tutorial/part_0.py

@@ -0,0 +1,80 @@
+"""
+McRogueFace Tutorial - Part 0: Introduction to Scene, Texture, and Grid
+
+This tutorial introduces the basic building blocks:
+- Scene: A container for UI elements and game state
+- Texture: Loading image assets for use in the game
+- Grid: A tilemap component for rendering tile-based worlds
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = zoom
+grid.center = (grid_width/2.0)*16, (grid_height/2.0)*16 # center on the middle of the central tile
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 0",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((280, 750),
+    text="Scene + Texture + Grid = Tilemap!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 0 loaded!")
+print(f"Created a {grid.grid_size[0]}x{grid.grid_size[1]} grid")
+print(f"Grid positioned at ({grid.x}, {grid.y})")

roguelike_tutorial/part_1.py

@@ -0,0 +1,116 @@
+"""
+McRogueFace Tutorial - Part 1: Entities and Keyboard Input
+
+This tutorial builds on Part 0 by adding:
+- Entity: A game object that can be placed in a grid
+- Keyboard handling: Responding to key presses to move the entity
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = zoom
+grid.center = (grid_width/2.0)*16, (grid_height/2.0)*16 # center on the middle of the central tile
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    if state == "start":  # Only respond to key press, not release
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y 
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            py -= 1
+        elif key == "S" or key == "Down":
+            py += 1
+        elif key == "A" or key == "Left":
+            px -= 1
+        elif key == "D" or key == "Right":
+            px += 1
+        
+        # Update player position (no collision checking yet)
+        player.x = px 
+        player.y = py
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 1",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((200, 750),
+    text="Use WASD or Arrow Keys to move the hero!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 1 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Use WASD or Arrow keys to move!")

roguelike_tutorial/part_1b.py

@@ -0,0 +1,117 @@
+"""
+McRogueFace Tutorial - Part 1: Entities and Keyboard Input
+
+This tutorial builds on Part 0 by adding:
+- Entity: A game object that can be placed in a grid
+- Keyboard handling: Responding to key presses to move the entity
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    if state == "start":  # Only respond to key press, not release
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y 
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            py -= 1
+        elif key == "S" or key == "Down":
+            py += 1
+        elif key == "A" or key == "Left":
+            px -= 1
+        elif key == "D" or key == "Right":
+            px += 1
+        
+        # Update player position (no collision checking yet)
+        player.x = px 
+        player.y = py
+        grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 1",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((200, 750),
+    text="Use WASD or Arrow Keys to move the hero!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 1 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Use WASD or Arrow keys to move!")

roguelike_tutorial/part_2-naive.py

@@ -0,0 +1,149 @@
+"""
+McRogueFace Tutorial - Part 2: Animated Movement
+
+This tutorial builds on Part 1 by adding:
+- Animation system for smooth movement
+- Movement that takes 0.5 seconds per tile
+- Input blocking during movement animation
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Movement state tracking
+is_moving = False
+move_animations = []  # Track active animations
+
+# Animation completion callback
+def movement_complete(runtime):
+    """Called when movement animation completes"""
+    global is_moving
+    is_moving = False
+    # Ensure grid is centered on final position
+    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+
+motion_speed = 0.30 # seconds per tile
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    global is_moving, move_animations
+    
+    if state == "start" and not is_moving:  # Only respond to key press when not moving
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y
+        new_x, new_y = px, py
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            new_y -= 1
+        elif key == "S" or key == "Down":
+            new_y += 1
+        elif key == "A" or key == "Left":
+            new_x -= 1
+        elif key == "D" or key == "Right":
+            new_x += 1
+        
+        # If position changed, start movement animation
+        if new_x != px or new_y != py:
+            is_moving = True
+            
+            # Create animations for player position
+            anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad")
+            anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad")
+            anim_x.start(player)
+            anim_y.start(player)
+            
+            # Animate grid center to follow player
+            center_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
+            center_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
+            center_x.start(grid)
+            center_y.start(grid)
+            
+            # Set a timer to mark movement as complete
+            mcrfpy.setTimer("move_complete", movement_complete, 500)
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 2",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((150, 750),
+    text="Smooth movement! Each step takes 0.5 seconds.",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 2 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Movement is now animated over 0.5 seconds per tile!")
+print("Use WASD or Arrow keys to move!")

roguelike_tutorial/part_2-onemovequeued.py

@@ -0,0 +1,241 @@
+"""
+McRogueFace Tutorial - Part 2: Enhanced with Single Move Queue
+
+This tutorial builds on Part 2 by adding:
+- Single queued move system for responsive input
+- Debug display showing position and queue status
+- Smooth continuous movement when keys are held
+- Animation callbacks to prevent race conditions
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Movement state tracking
+is_moving = False
+move_queue = []  # List to store queued moves (max 1 item)
+#last_position = (4, 4)  # Track last position
+current_destination = None  # Track where we're currently moving to
+current_move = None  # Track current move direction
+
+# Store animation references
+player_anim_x = None
+player_anim_y = None
+grid_anim_x = None
+grid_anim_y = None
+
+# Debug display caption
+debug_caption = mcrfpy.Caption((10, 40),
+    text="Last: (4, 4) | Queue: 0 | Dest: None",
+)
+debug_caption.font_size = 16
+debug_caption.fill_color = mcrfpy.Color(255, 255, 0, 255)
+mcrfpy.sceneUI("tutorial").append(debug_caption)
+
+# Additional debug caption for movement state
+move_debug_caption = mcrfpy.Caption((10, 60),
+    text="Moving: False | Current: None | Queued: None",
+)
+move_debug_caption.font_size = 16
+move_debug_caption.fill_color = mcrfpy.Color(255, 200, 0, 255)
+mcrfpy.sceneUI("tutorial").append(move_debug_caption)
+
+def key_to_direction(key):
+    """Convert key to direction string"""
+    if key == "W" or key == "Up":
+        return "Up"
+    elif key == "S" or key == "Down":
+        return "Down"
+    elif key == "A" or key == "Left":
+        return "Left"
+    elif key == "D" or key == "Right":
+        return "Right"
+    return None
+
+def update_debug_display():
+    """Update the debug caption with current state"""
+    queue_count = len(move_queue)
+    dest_text = f"({current_destination[0]}, {current_destination[1]})" if current_destination else "None"
+    debug_caption.text = f"Last: ({player.x}, {player.y}) | Queue: {queue_count} | Dest: {dest_text}"
+    
+    # Update movement state debug
+    current_dir = key_to_direction(current_move) if current_move else "None"
+    queued_dir = key_to_direction(move_queue[0]) if move_queue else "None"
+    move_debug_caption.text = f"Moving: {is_moving} | Current: {current_dir} | Queued: {queued_dir}"
+
+# Animation completion callback
+def movement_complete(anim, target):
+    """Called when movement animation completes"""
+    global is_moving, move_queue, current_destination, current_move
+    global player_anim_x, player_anim_y
+    print(f"In callback for animation: {anim=} {target=}")
+    # Clear movement state
+    is_moving = False
+    current_move = None
+    current_destination = None
+    # Clear animation references
+    player_anim_x = None
+    player_anim_y = None
+    
+    # Update last position to where we actually are now
+    #last_position = (int(player.x), int(player.y))
+    
+    # Ensure grid is centered on final position
+    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+    
+    # Check if there's a queued move
+    if move_queue:
+        # Pop the next move from the queue
+        next_move = move_queue.pop(0)
+        print(f"Processing queued move: {next_move}")
+        # Process it like a fresh input
+        process_move(next_move)
+    
+    update_debug_display()
+
+motion_speed = 0.30 # seconds per tile
+
+def process_move(key):
+    """Process a move based on the key"""
+    global is_moving, current_move, current_destination, move_queue
+    global player_anim_x, player_anim_y, grid_anim_x, grid_anim_y
+    
+    # If already moving, just update the queue
+    if is_moving:
+        print(f"process_move processing {key=} as a queued move (is_moving = True)")
+        # Clear queue and add new move (only keep 1 queued move)
+        move_queue.clear()
+        move_queue.append(key)
+        update_debug_display()
+        return
+    print(f"process_move processing {key=} as a new, immediate animation (is_moving = False)")
+    # Calculate new position from current position
+    px, py = int(player.x), int(player.y)
+    new_x, new_y = px, py
+    
+    # Calculate new position based on key press (only one tile movement)
+    if key == "W" or key == "Up":
+        new_y -= 1
+    elif key == "S" or key == "Down":
+        new_y += 1
+    elif key == "A" or key == "Left":
+        new_x -= 1
+    elif key == "D" or key == "Right":
+        new_x += 1
+    
+    # Start the move if position changed
+    if new_x != px or new_y != py:
+        is_moving = True
+        current_move = key
+        current_destination = (new_x, new_y)
+        # only animate a single axis, same callback from either
+        if new_x != px:
+            player_anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad", callback=movement_complete)
+            player_anim_x.start(player)
+        elif new_y != py:
+            player_anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad", callback=movement_complete)
+            player_anim_y.start(player)
+        
+        # Animate grid center to follow player
+        grid_anim_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
+        grid_anim_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
+        grid_anim_x.start(grid)
+        grid_anim_y.start(grid)
+        
+        update_debug_display()
+
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    if state == "start":
+        # Only process movement keys
+        if key in ["W", "Up", "S", "Down", "A", "Left", "D", "Right"]:
+            print(f"handle_keys producing actual input: {key=}")
+            process_move(key)
+
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 2 Enhanced",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((150, 750),
+    text="One-move queue system with animation callbacks!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 2 Enhanced loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Movement now uses animation callbacks to prevent race conditions!")
+print("Use WASD or Arrow keys to move!")

roguelike_tutorial/part_2.py

@@ -0,0 +1,149 @@
+"""
+McRogueFace Tutorial - Part 2: Animated Movement
+
+This tutorial builds on Part 1 by adding:
+- Animation system for smooth movement
+- Movement that takes 0.5 seconds per tile
+- Input blocking during movement animation
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Movement state tracking
+is_moving = False
+move_animations = []  # Track active animations
+
+# Animation completion callback
+def movement_complete(runtime):
+    """Called when movement animation completes"""
+    global is_moving
+    is_moving = False
+    # Ensure grid is centered on final position
+    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+
+motion_speed = 0.30 # seconds per tile
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    global is_moving, move_animations
+    
+    if state == "start" and not is_moving:  # Only respond to key press when not moving
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y
+        new_x, new_y = px, py
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            new_y -= 1
+        elif key == "S" or key == "Down":
+            new_y += 1
+        elif key == "A" or key == "Left":
+            new_x -= 1
+        elif key == "D" or key == "Right":
+            new_x += 1
+        
+        # If position changed, start movement animation
+        if new_x != px or new_y != py:
+            is_moving = True
+            
+            # Create animations for player position
+            anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad")
+            anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad")
+            anim_x.start(player)
+            anim_y.start(player)
+            
+            # Animate grid center to follow player
+            center_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
+            center_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
+            center_x.start(grid)
+            center_y.start(grid)
+            
+            # Set a timer to mark movement as complete
+            mcrfpy.setTimer("move_complete", movement_complete, 500)
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 2",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((150, 750),
+    "Smooth movement! Each step takes 0.5 seconds.",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 2 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Movement is now animated over 0.5 seconds per tile!")
+print("Use WASD or Arrow keys to move!")

src/ActionCode.h

@@ -11,10 +11,10 @@ public:
     const static int WHEEL_NUM = 4;
     const static int WHEEL_NEG = 2;
     const static int WHEEL_DEL = 1;
-    static int keycode(sf::Keyboard::Key& k) { return KEY + (int)k; }
-    static int keycode(sf::Mouse::Button& b) { return MOUSEBUTTON + (int)b; }
+    static int keycode(const sf::Keyboard::Key& k) { return KEY + (int)k; }
+    static int keycode(const sf::Mouse::Button& b) { return MOUSEBUTTON + (int)b; }
     //static int keycode(sf::Mouse::Wheel& w, float d) { return MOUSEWHEEL + (((int)w)<<12) + int(d*16) + 512; }
-    static int keycode(sf::Mouse::Wheel& w, float d) {
+    static int keycode(const sf::Mouse::Wheel& w, float d) {
         int neg = 0;
         if (d < 0) { neg = 1; }
         return MOUSEWHEEL + (w * WHEEL_NUM) + (neg * WHEEL_NEG) + 1;
@@ -32,7 +32,7 @@ public:
         return (a & WHEEL_DEL) * factor;
     }
 
-    static std::string key_str(sf::Keyboard::Key& keycode)
+    static std::string key_str(const sf::Keyboard::Key& keycode)
     {
         switch(keycode)
         {

src/Animation.cpp

@@ -0,0 +1,675 @@
+#include "Animation.h"
+#include "UIDrawable.h"
+#include "UIEntity.h"
+#include "PyAnimation.h"
+#include "McRFPy_API.h"
+#include "PythonObjectCache.h"
+#include <cmath>
+#include <algorithm>
+#include <unordered_map>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+// Forward declaration of PyAnimation type
+namespace mcrfpydef {
+    extern PyTypeObject PyAnimationType;
+}
+
+// Animation implementation
+Animation::Animation(const std::string& targetProperty, 
+                     const AnimationValue& targetValue,
+                     float duration,
+                     EasingFunction easingFunc,
+                     bool delta,
+                     PyObject* callback)
+    : targetProperty(targetProperty)
+    , targetValue(targetValue)
+    , duration(duration)
+    , easingFunc(easingFunc)
+    , delta(delta)
+    , pythonCallback(callback)
+{
+    // Increase reference count for Python callback
+    if (pythonCallback) {
+        Py_INCREF(pythonCallback);
+    }
+}
+
+Animation::~Animation() {
+    // Decrease reference count for Python callback if we still own it
+    PyObject* callback = pythonCallback;
+    if (callback) {
+        pythonCallback = nullptr;
+        
+        PyGILState_STATE gstate = PyGILState_Ensure();
+        Py_DECREF(callback);
+        PyGILState_Release(gstate);
+    }
+    
+    // Clean up cache entry
+    if (serial_number != 0) {
+        PythonObjectCache::getInstance().remove(serial_number);
+    }
+}
+
+void Animation::start(std::shared_ptr<UIDrawable> target) {
+    if (!target) return;
+    
+    targetWeak = target;
+    elapsed = 0.0f;
+    callbackTriggered = false; // Reset callback state
+    
+    // Capture start value from target
+    std::visit([this, &target](const auto& targetVal) {
+        using T = std::decay_t<decltype(targetVal)>;
+        
+        if constexpr (std::is_same_v<T, float>) {
+            float value;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+        else if constexpr (std::is_same_v<T, int>) {
+            int value;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+        else if constexpr (std::is_same_v<T, std::vector<int>>) {
+            // For sprite animation, get current sprite index
+            int value;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+        else if constexpr (std::is_same_v<T, sf::Color>) {
+            sf::Color value;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+        else if constexpr (std::is_same_v<T, sf::Vector2f>) {
+            sf::Vector2f value;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+        else if constexpr (std::is_same_v<T, std::string>) {
+            std::string value;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+    }, targetValue);
+}
+
+void Animation::startEntity(std::shared_ptr<UIEntity> target) {
+    if (!target) return;
+    
+    entityTargetWeak = target;
+    elapsed = 0.0f;
+    callbackTriggered = false; // Reset callback state
+    
+    // Capture the starting value from the entity
+    std::visit([this, target](const auto& val) {
+        using T = std::decay_t<decltype(val)>;
+        
+        if constexpr (std::is_same_v<T, float>) {
+            float value = 0.0f;
+            if (target->getProperty(targetProperty, value)) {
+                startValue = value;
+            }
+        }
+        else if constexpr (std::is_same_v<T, int>) {
+            // For entities, we might need to handle sprite_index differently
+            if (targetProperty == "sprite_index" || targetProperty == "sprite_number") {
+                startValue = target->sprite.getSpriteIndex();
+            }
+        }
+        // Entities don't support other types yet
+    }, targetValue);
+}
+
+bool Animation::hasValidTarget() const {
+    return !targetWeak.expired() || !entityTargetWeak.expired();
+}
+
+void Animation::clearCallback() {
+    // Safely clear the callback when PyAnimation is being destroyed
+    PyObject* callback = pythonCallback;
+    if (callback) {
+        pythonCallback = nullptr;
+        callbackTriggered = true; // Prevent future triggering
+        
+        PyGILState_STATE gstate = PyGILState_Ensure();
+        Py_DECREF(callback);
+        PyGILState_Release(gstate);
+    }
+}
+
+void Animation::complete() {
+    // Jump to end of animation
+    elapsed = duration;
+    
+    // Apply final value
+    if (auto target = targetWeak.lock()) {
+        AnimationValue finalValue = interpolate(1.0f);
+        applyValue(target.get(), finalValue);
+    }
+    else if (auto entity = entityTargetWeak.lock()) {
+        AnimationValue finalValue = interpolate(1.0f);
+        applyValue(entity.get(), finalValue);
+    }
+}
+
+bool Animation::update(float deltaTime) {
+    // Try to lock weak_ptr to get shared_ptr
+    std::shared_ptr<UIDrawable> target = targetWeak.lock();
+    std::shared_ptr<UIEntity> entity = entityTargetWeak.lock();
+    
+    // If both are null, target was destroyed
+    if (!target && !entity) {
+        return false;  // Remove this animation
+    }
+    
+    if (isComplete()) {
+        return false;
+    }
+    
+    elapsed += deltaTime;
+    elapsed = std::min(elapsed, duration);
+    
+    // Calculate easing value (0.0 to 1.0)
+    float t = duration > 0 ? elapsed / duration : 1.0f;
+    float easedT = easingFunc(t);
+    
+    // Get interpolated value
+    AnimationValue currentValue = interpolate(easedT);
+    
+    // Apply to whichever target is valid
+    if (target) {
+        applyValue(target.get(), currentValue);
+    } else if (entity) {
+        applyValue(entity.get(), currentValue);
+    }
+    
+    // Trigger callback when animation completes
+    // Check pythonCallback again in case it was cleared during update
+    if (isComplete() && !callbackTriggered && pythonCallback) {
+        triggerCallback();
+    }
+    
+    return !isComplete();
+}
+
+AnimationValue Animation::getCurrentValue() const {
+    float t = duration > 0 ? elapsed / duration : 1.0f;
+    float easedT = easingFunc(t);
+    return interpolate(easedT);
+}
+
+AnimationValue Animation::interpolate(float t) const {
+    // Visit the variant to perform type-specific interpolation
+    return std::visit([this, t](const auto& target) -> AnimationValue {
+        using T = std::decay_t<decltype(target)>;
+        
+        if constexpr (std::is_same_v<T, float>) {
+            // Interpolate float
+            const float* start = std::get_if<float>(&startValue);
+            if (!start) return target;  // Type mismatch
+            
+            if (delta) {
+                return *start + target * t;
+            } else {
+                return *start + (target - *start) * t;
+            }
+        }
+        else if constexpr (std::is_same_v<T, int>) {
+            // Interpolate integer
+            const int* start = std::get_if<int>(&startValue);
+            if (!start) return target;
+            
+            float result;
+            if (delta) {
+                result = *start + target * t;
+            } else {
+                result = *start + (target - *start) * t;
+            }
+            return static_cast<int>(std::round(result));
+        }
+        else if constexpr (std::is_same_v<T, std::vector<int>>) {
+            // For sprite animation, interpolate through the list
+            if (target.empty()) return target;
+            
+            // Map t to an index in the vector
+            size_t index = static_cast<size_t>(t * (target.size() - 1));
+            index = std::min(index, target.size() - 1);
+            return static_cast<int>(target[index]);
+        }
+        else if constexpr (std::is_same_v<T, sf::Color>) {
+            // Interpolate color
+            const sf::Color* start = std::get_if<sf::Color>(&startValue);
+            if (!start) return target;
+            
+            sf::Color result;
+            if (delta) {
+                result.r = std::clamp(start->r + target.r * t, 0.0f, 255.0f);
+                result.g = std::clamp(start->g + target.g * t, 0.0f, 255.0f);
+                result.b = std::clamp(start->b + target.b * t, 0.0f, 255.0f);
+                result.a = std::clamp(start->a + target.a * t, 0.0f, 255.0f);
+            } else {
+                result.r = start->r + (target.r - start->r) * t;
+                result.g = start->g + (target.g - start->g) * t;
+                result.b = start->b + (target.b - start->b) * t;
+                result.a = start->a + (target.a - start->a) * t;
+            }
+            return result;
+        }
+        else if constexpr (std::is_same_v<T, sf::Vector2f>) {
+            // Interpolate vector
+            const sf::Vector2f* start = std::get_if<sf::Vector2f>(&startValue);
+            if (!start) return target;
+            
+            if (delta) {
+                return sf::Vector2f(start->x + target.x * t, 
+                                    start->y + target.y * t);
+            } else {
+                return sf::Vector2f(start->x + (target.x - start->x) * t,
+                                    start->y + (target.y - start->y) * t);
+            }
+        }
+        else if constexpr (std::is_same_v<T, std::string>) {
+            // For text, show characters based on t
+            const std::string* start = std::get_if<std::string>(&startValue);
+            if (!start) return target;
+            
+            // If delta mode, append characters from target
+            if (delta) {
+                size_t chars = static_cast<size_t>(target.length() * t);
+                return *start + target.substr(0, chars);
+            } else {
+                // Transition from start text to target text
+                if (t < 0.5f) {
+                    // First half: remove characters from start
+                    size_t chars = static_cast<size_t>(start->length() * (1.0f - t * 2.0f));
+                    return start->substr(0, chars);
+                } else {
+                    // Second half: add characters to target
+                    size_t chars = static_cast<size_t>(target.length() * ((t - 0.5f) * 2.0f));
+                    return target.substr(0, chars);
+                }
+            }
+        }
+        
+        return target;  // Fallback
+    }, targetValue);
+}
+
+void Animation::applyValue(UIDrawable* target, const AnimationValue& value) {
+    if (!target) return;
+    
+    std::visit([this, target](const auto& val) {
+        using T = std::decay_t<decltype(val)>;
+        
+        if constexpr (std::is_same_v<T, float>) {
+            target->setProperty(targetProperty, val);
+        }
+        else if constexpr (std::is_same_v<T, int>) {
+            target->setProperty(targetProperty, val);
+        }
+        else if constexpr (std::is_same_v<T, sf::Color>) {
+            target->setProperty(targetProperty, val);
+        }
+        else if constexpr (std::is_same_v<T, sf::Vector2f>) {
+            target->setProperty(targetProperty, val);
+        }
+        else if constexpr (std::is_same_v<T, std::string>) {
+            target->setProperty(targetProperty, val);
+        }
+    }, value);
+}
+
+void Animation::applyValue(UIEntity* entity, const AnimationValue& value) {
+    if (!entity) return;
+    
+    std::visit([this, entity](const auto& val) {
+        using T = std::decay_t<decltype(val)>;
+        
+        if constexpr (std::is_same_v<T, float>) {
+            entity->setProperty(targetProperty, val);
+        }
+        else if constexpr (std::is_same_v<T, int>) {
+            entity->setProperty(targetProperty, val);
+        }
+        // Entities don't support other types yet
+    }, value);
+}
+
+void Animation::triggerCallback() {
+    if (!pythonCallback) return;
+    
+    // Ensure we only trigger once
+    if (callbackTriggered) return;
+    callbackTriggered = true;
+    
+    PyGILState_STATE gstate = PyGILState_Ensure();
+    
+    // TODO: In future, create PyAnimation wrapper for this animation
+    // For now, pass None for both parameters
+    PyObject* args = PyTuple_New(2);
+    Py_INCREF(Py_None);
+    Py_INCREF(Py_None);
+    PyTuple_SetItem(args, 0, Py_None); // animation parameter
+    PyTuple_SetItem(args, 1, Py_None); // target parameter
+    
+    PyObject* result = PyObject_CallObject(pythonCallback, args);
+    Py_DECREF(args);
+    
+    if (!result) {
+        // Print error but don't crash
+        PyErr_Print();
+        PyErr_Clear(); // Clear the error state
+    } else {
+        Py_DECREF(result);
+    }
+    
+    PyGILState_Release(gstate);
+}
+
+// Easing functions implementation
+namespace EasingFunctions {
+
+float linear(float t) {
+    return t;
+}
+
+float easeIn(float t) {
+    return t * t;
+}
+
+float easeOut(float t) {
+    return t * (2.0f - t);
+}
+
+float easeInOut(float t) {
+    return t < 0.5f ? 2.0f * t * t : -1.0f + (4.0f - 2.0f * t) * t;
+}
+
+// Quadratic
+float easeInQuad(float t) {
+    return t * t;
+}
+
+float easeOutQuad(float t) {
+    return t * (2.0f - t);
+}
+
+float easeInOutQuad(float t) {
+    return t < 0.5f ? 2.0f * t * t : -1.0f + (4.0f - 2.0f * t) * t;
+}
+
+// Cubic
+float easeInCubic(float t) {
+    return t * t * t;
+}
+
+float easeOutCubic(float t) {
+    float t1 = t - 1.0f;
+    return t1 * t1 * t1 + 1.0f;
+}
+
+float easeInOutCubic(float t) {
+    return t < 0.5f ? 4.0f * t * t * t : (t - 1.0f) * (2.0f * t - 2.0f) * (2.0f * t - 2.0f) + 1.0f;
+}
+
+// Quartic
+float easeInQuart(float t) {
+    return t * t * t * t;
+}
+
+float easeOutQuart(float t) {
+    float t1 = t - 1.0f;
+    return 1.0f - t1 * t1 * t1 * t1;
+}
+
+float easeInOutQuart(float t) {
+    return t < 0.5f ? 8.0f * t * t * t * t : 1.0f - 8.0f * (t - 1.0f) * (t - 1.0f) * (t - 1.0f) * (t - 1.0f);
+}
+
+// Sine
+float easeInSine(float t) {
+    return 1.0f - std::cos(t * M_PI / 2.0f);
+}
+
+float easeOutSine(float t) {
+    return std::sin(t * M_PI / 2.0f);
+}
+
+float easeInOutSine(float t) {
+    return 0.5f * (1.0f - std::cos(M_PI * t));
+}
+
+// Exponential
+float easeInExpo(float t) {
+    return t == 0.0f ? 0.0f : std::pow(2.0f, 10.0f * (t - 1.0f));
+}
+
+float easeOutExpo(float t) {
+    return t == 1.0f ? 1.0f : 1.0f - std::pow(2.0f, -10.0f * t);
+}
+
+float easeInOutExpo(float t) {
+    if (t == 0.0f) return 0.0f;
+    if (t == 1.0f) return 1.0f;
+    if (t < 0.5f) {
+        return 0.5f * std::pow(2.0f, 20.0f * t - 10.0f);
+    } else {
+        return 1.0f - 0.5f * std::pow(2.0f, -20.0f * t + 10.0f);
+    }
+}
+
+// Circular
+float easeInCirc(float t) {
+    return 1.0f - std::sqrt(1.0f - t * t);
+}
+
+float easeOutCirc(float t) {
+    float t1 = t - 1.0f;
+    return std::sqrt(1.0f - t1 * t1);
+}
+
+float easeInOutCirc(float t) {
+    if (t < 0.5f) {
+        return 0.5f * (1.0f - std::sqrt(1.0f - 4.0f * t * t));
+    } else {
+        return 0.5f * (std::sqrt(1.0f - (2.0f * t - 2.0f) * (2.0f * t - 2.0f)) + 1.0f);
+    }
+}
+
+// Elastic
+float easeInElastic(float t) {
+    if (t == 0.0f) return 0.0f;
+    if (t == 1.0f) return 1.0f;
+    float p = 0.3f;
+    float a = 1.0f;
+    float s = p / 4.0f;
+    float t1 = t - 1.0f;
+    return -(a * std::pow(2.0f, 10.0f * t1) * std::sin((t1 - s) * (2.0f * M_PI) / p));
+}
+
+float easeOutElastic(float t) {
+    if (t == 0.0f) return 0.0f;
+    if (t == 1.0f) return 1.0f;
+    float p = 0.3f;
+    float a = 1.0f;
+    float s = p / 4.0f;
+    return a * std::pow(2.0f, -10.0f * t) * std::sin((t - s) * (2.0f * M_PI) / p) + 1.0f;
+}
+
+float easeInOutElastic(float t) {
+    if (t == 0.0f) return 0.0f;
+    if (t == 1.0f) return 1.0f;
+    float p = 0.45f;
+    float a = 1.0f;
+    float s = p / 4.0f;
+    
+    if (t < 0.5f) {
+        float t1 = 2.0f * t - 1.0f;
+        return -0.5f * (a * std::pow(2.0f, 10.0f * t1) * std::sin((t1 - s) * (2.0f * M_PI) / p));
+    } else {
+        float t1 = 2.0f * t - 1.0f;
+        return a * std::pow(2.0f, -10.0f * t1) * std::sin((t1 - s) * (2.0f * M_PI) / p) * 0.5f + 1.0f;
+    }
+}
+
+// Back (overshooting)
+float easeInBack(float t) {
+    const float s = 1.70158f;
+    return t * t * ((s + 1.0f) * t - s);
+}
+
+float easeOutBack(float t) {
+    const float s = 1.70158f;
+    float t1 = t - 1.0f;
+    return t1 * t1 * ((s + 1.0f) * t1 + s) + 1.0f;
+}
+
+float easeInOutBack(float t) {
+    const float s = 1.70158f * 1.525f;
+    if (t < 0.5f) {
+        return 0.5f * (4.0f * t * t * ((s + 1.0f) * 2.0f * t - s));
+    } else {
+        float t1 = 2.0f * t - 2.0f;
+        return 0.5f * (t1 * t1 * ((s + 1.0f) * t1 + s) + 2.0f);
+    }
+}
+
+// Bounce
+float easeOutBounce(float t) {
+    if (t < 1.0f / 2.75f) {
+        return 7.5625f * t * t;
+    } else if (t < 2.0f / 2.75f) {
+        float t1 = t - 1.5f / 2.75f;
+        return 7.5625f * t1 * t1 + 0.75f;
+    } else if (t < 2.5f / 2.75f) {
+        float t1 = t - 2.25f / 2.75f;
+        return 7.5625f * t1 * t1 + 0.9375f;
+    } else {
+        float t1 = t - 2.625f / 2.75f;
+        return 7.5625f * t1 * t1 + 0.984375f;
+    }
+}
+
+float easeInBounce(float t) {
+    return 1.0f - easeOutBounce(1.0f - t);
+}
+
+float easeInOutBounce(float t) {
+    if (t < 0.5f) {
+        return 0.5f * easeInBounce(2.0f * t);
+    } else {
+        return 0.5f * easeOutBounce(2.0f * t - 1.0f) + 0.5f;
+    }
+}
+
+// Get easing function by name
+EasingFunction getByName(const std::string& name) {
+    static std::unordered_map<std::string, EasingFunction> easingMap = {
+        {"linear", linear},
+        {"easeIn", easeIn},
+        {"easeOut", easeOut},
+        {"easeInOut", easeInOut},
+        {"easeInQuad", easeInQuad},
+        {"easeOutQuad", easeOutQuad},
+        {"easeInOutQuad", easeInOutQuad},
+        {"easeInCubic", easeInCubic},
+        {"easeOutCubic", easeOutCubic},
+        {"easeInOutCubic", easeInOutCubic},
+        {"easeInQuart", easeInQuart},
+        {"easeOutQuart", easeOutQuart},
+        {"easeInOutQuart", easeInOutQuart},
+        {"easeInSine", easeInSine},
+        {"easeOutSine", easeOutSine},
+        {"easeInOutSine", easeInOutSine},
+        {"easeInExpo", easeInExpo},
+        {"easeOutExpo", easeOutExpo},
+        {"easeInOutExpo", easeInOutExpo},
+        {"easeInCirc", easeInCirc},
+        {"easeOutCirc", easeOutCirc},
+        {"easeInOutCirc", easeInOutCirc},
+        {"easeInElastic", easeInElastic},
+        {"easeOutElastic", easeOutElastic},
+        {"easeInOutElastic", easeInOutElastic},
+        {"easeInBack", easeInBack},
+        {"easeOutBack", easeOutBack},
+        {"easeInOutBack", easeInOutBack},
+        {"easeInBounce", easeInBounce},
+        {"easeOutBounce", easeOutBounce},
+        {"easeInOutBounce", easeInOutBounce}
+    };
+    
+    auto it = easingMap.find(name);
+    if (it != easingMap.end()) {
+        return it->second;
+    }
+    return linear;  // Default to linear
+}
+
+} // namespace EasingFunctions
+
+// AnimationManager implementation
+AnimationManager& AnimationManager::getInstance() {
+    static AnimationManager instance;
+    return instance;
+}
+
+void AnimationManager::addAnimation(std::shared_ptr<Animation> animation) {
+    if (animation && animation->hasValidTarget()) {
+        if (isUpdating) {
+            // Defer adding during update to avoid iterator invalidation
+            pendingAnimations.push_back(animation);
+        } else {
+            activeAnimations.push_back(animation);
+        }
+    }
+}
+
+void AnimationManager::update(float deltaTime) {
+    // Set flag to defer new animations
+    isUpdating = true;
+    
+    // Remove completed or invalid animations
+    activeAnimations.erase(
+        std::remove_if(activeAnimations.begin(), activeAnimations.end(),
+            [deltaTime](std::shared_ptr<Animation>& anim) {
+                return !anim || !anim->update(deltaTime);
+            }),
+        activeAnimations.end()
+    );
+    
+    // Clear update flag
+    isUpdating = false;
+    
+    // Add any animations that were created during update
+    if (!pendingAnimations.empty()) {
+        activeAnimations.insert(activeAnimations.end(), 
+                              pendingAnimations.begin(), 
+                              pendingAnimations.end());
+        pendingAnimations.clear();
+    }
+}
+
+
+void AnimationManager::clear(bool completeAnimations) {
+    if (completeAnimations) {
+        // Complete all animations before clearing
+        for (auto& anim : activeAnimations) {
+            if (anim) {
+                anim->complete();
+            }
+        }
+    }
+    activeAnimations.clear();
+}

src/Animation.h

@@ -0,0 +1,175 @@
+#pragma once
+
+#include <string>
+#include <functional>
+#include <memory>
+#include <variant>
+#include <vector>
+#include <SFML/Graphics.hpp>
+#include "Python.h"
+
+// Forward declarations
+class UIDrawable;
+class UIEntity;
+
+// Forward declare namespace
+namespace EasingFunctions {
+    float linear(float t);
+}
+
+// Easing function type
+typedef std::function<float(float)> EasingFunction;
+
+// Animation target value can be various types
+typedef std::variant<
+    float,                    // Single float value
+    int,                      // Single integer value
+    std::vector<int>,         // List of integers (for sprite animation)
+    sf::Color,                // Color animation
+    sf::Vector2f,             // Vector animation
+    std::string               // String animation (for text)
+> AnimationValue;
+
+class Animation {
+public:
+    // Constructor
+    Animation(const std::string& targetProperty, 
+              const AnimationValue& targetValue,
+              float duration,
+              EasingFunction easingFunc = EasingFunctions::linear,
+              bool delta = false,
+              PyObject* callback = nullptr);
+    
+    // Destructor - cleanup Python callback reference
+    ~Animation();
+    
+    // Apply this animation to a drawable
+    void start(std::shared_ptr<UIDrawable> target);
+    
+    // Apply this animation to an entity (special case since Entity doesn't inherit from UIDrawable)
+    void startEntity(std::shared_ptr<UIEntity> target);
+    
+    // Complete the animation immediately (jump to final value)
+    void complete();
+    
+    // Update animation (called each frame)
+    // Returns true if animation is still running, false if complete
+    bool update(float deltaTime);
+    
+    // Get current interpolated value
+    AnimationValue getCurrentValue() const;
+    
+    // Check if animation has valid target
+    bool hasValidTarget() const;
+    
+    // Clear the callback (called when PyAnimation is deallocated)
+    void clearCallback();
+    
+    // Animation properties
+    std::string getTargetProperty() const { return targetProperty; }
+    float getDuration() const { return duration; }
+    float getElapsed() const { return elapsed; }
+    bool isComplete() const { return elapsed >= duration; }
+    bool isDelta() const { return delta; }
+    
+private:
+    std::string targetProperty;    // Property name to animate (e.g., "x", "color.r", "sprite_number")
+    AnimationValue startValue;     // Starting value (captured when animation starts)
+    AnimationValue targetValue;    // Target value to animate to
+    float duration;                // Animation duration in seconds
+    float elapsed = 0.0f;          // Elapsed time
+    EasingFunction easingFunc;     // Easing function to use
+    bool delta;                    // If true, targetValue is relative to start
+    
+    // RAII: Use weak_ptr for safe target tracking
+    std::weak_ptr<UIDrawable> targetWeak;
+    std::weak_ptr<UIEntity> entityTargetWeak;
+    
+    // Callback support
+    PyObject* pythonCallback = nullptr;  // Python callback function (we own a reference)
+    bool callbackTriggered = false;      // Ensure callback only fires once
+    PyObject* pyAnimationWrapper = nullptr; // Weak reference to PyAnimation if created from Python
+    
+    // Python object cache support
+    uint64_t serial_number = 0;
+    
+    // Helper to interpolate between values
+    AnimationValue interpolate(float t) const;
+    
+    // Helper to apply value to target
+    void applyValue(UIDrawable* target, const AnimationValue& value);
+    void applyValue(UIEntity* entity, const AnimationValue& value);
+    
+    // Trigger callback when animation completes
+    void triggerCallback();
+};
+
+// Easing functions library
+namespace EasingFunctions {
+    // Basic easing functions
+    float linear(float t);
+    float easeIn(float t);
+    float easeOut(float t);
+    float easeInOut(float t);
+    
+    // Advanced easing functions
+    float easeInQuad(float t);
+    float easeOutQuad(float t);
+    float easeInOutQuad(float t);
+    
+    float easeInCubic(float t);
+    float easeOutCubic(float t);
+    float easeInOutCubic(float t);
+    
+    float easeInQuart(float t);
+    float easeOutQuart(float t);
+    float easeInOutQuart(float t);
+    
+    float easeInSine(float t);
+    float easeOutSine(float t);
+    float easeInOutSine(float t);
+    
+    float easeInExpo(float t);
+    float easeOutExpo(float t);
+    float easeInOutExpo(float t);
+    
+    float easeInCirc(float t);
+    float easeOutCirc(float t);
+    float easeInOutCirc(float t);
+    
+    float easeInElastic(float t);
+    float easeOutElastic(float t);
+    float easeInOutElastic(float t);
+    
+    float easeInBack(float t);
+    float easeOutBack(float t);
+    float easeInOutBack(float t);
+    
+    float easeInBounce(float t);
+    float easeOutBounce(float t);
+    float easeInOutBounce(float t);
+    
+    // Get easing function by name
+    EasingFunction getByName(const std::string& name);
+}
+
+// Animation manager to handle active animations
+class AnimationManager {
+public:
+    static AnimationManager& getInstance();
+    
+    // Add an animation to be managed
+    void addAnimation(std::shared_ptr<Animation> animation);
+    
+    // Update all animations
+    void update(float deltaTime);
+    
+    // Clear all animations (optionally completing them first)
+    void clear(bool completeAnimations = false);
+    
+private:
+    AnimationManager() = default;
+    std::vector<std::shared_ptr<Animation>> activeAnimations;
+    std::vector<std::shared_ptr<Animation>> pendingAnimations; // Animations to add after update
+    bool isUpdating = false; // Flag to track if we're in update loop
+};

src/CommandLineParser.cpp

@@ -0,0 +1,172 @@
+#include "CommandLineParser.h"
+#include <iostream>
+#include <filesystem>
+#include <algorithm>
+
+CommandLineParser::CommandLineParser(int argc, char* argv[]) 
+    : argc(argc), argv(argv) {}
+
+CommandLineParser::ParseResult CommandLineParser::parse(McRogueFaceConfig& config) {
+    ParseResult result;
+    current_arg = 1;  // Reset for each parse
+    
+    // Detect if running as Python interpreter
+    std::filesystem::path exec_name = std::filesystem::path(argv[0]).filename();
+    if (exec_name.string().find("python") == 0) {
+        config.headless = true;
+        config.python_mode = true;
+    }
+    
+    while (current_arg < argc) {
+        std::string arg = argv[current_arg];
+        
+        // Handle Python-style single-letter flags
+        if (arg == "-h" || arg == "--help") {
+            print_help();
+            result.should_exit = true;
+            result.exit_code = 0;
+            return result;
+        }
+        
+        if (arg == "-V" || arg == "--version") {
+            print_version();
+            result.should_exit = true;
+            result.exit_code = 0;
+            return result;
+        }
+        
+        // Python execution modes
+        if (arg == "-c") {
+            config.python_mode = true;
+            current_arg++;
+            if (current_arg >= argc) {
+                std::cerr << "Argument expected for the -c option" << std::endl;
+                result.should_exit = true;
+                result.exit_code = 1;
+                return result;
+            }
+            config.python_command = argv[current_arg];
+            current_arg++;
+            continue;
+        }
+        
+        if (arg == "-m") {
+            config.python_mode = true;
+            current_arg++;
+            if (current_arg >= argc) {
+                std::cerr << "Argument expected for the -m option" << std::endl;
+                result.should_exit = true;
+                result.exit_code = 1;
+                return result;
+            }
+            config.python_module = argv[current_arg];
+            current_arg++;
+            // Collect remaining args as module args
+            while (current_arg < argc) {
+                config.script_args.push_back(argv[current_arg]);
+                current_arg++;
+            }
+            continue;
+        }
+        
+        if (arg == "-i") {
+            config.interactive_mode = true;
+            config.python_mode = true;
+            current_arg++;
+            continue;
+        }
+        
+        // McRogueFace specific flags
+        if (arg == "--headless") {
+            config.headless = true;
+            config.audio_enabled = false;
+            current_arg++;
+            continue;
+        }
+        
+        if (arg == "--audio-off") {
+            config.audio_enabled = false;
+            current_arg++;
+            continue;
+        }
+        
+        if (arg == "--audio-on") {
+            config.audio_enabled = true;
+            current_arg++;
+            continue;
+        }
+        
+        if (arg == "--screenshot") {
+            config.take_screenshot = true;
+            current_arg++;
+            if (current_arg < argc && argv[current_arg][0] != '-') {
+                config.screenshot_path = argv[current_arg];
+                current_arg++;
+            } else {
+                config.screenshot_path = "screenshot.png";
+            }
+            continue;
+        }
+        
+        if (arg == "--exec") {
+            current_arg++;
+            if (current_arg >= argc) {
+                std::cerr << "Argument expected for the --exec option" << std::endl;
+                result.should_exit = true;
+                result.exit_code = 1;
+                return result;
+            }
+            config.exec_scripts.push_back(argv[current_arg]);
+            config.python_mode = true;
+            current_arg++;
+            continue;
+        }
+        
+        // If no flags matched, treat as positional argument (script name)
+        if (arg[0] != '-') {
+            config.script_path = arg;
+            config.python_mode = true;
+            current_arg++;
+            // Remaining args are script args
+            while (current_arg < argc) {
+                config.script_args.push_back(argv[current_arg]);
+                current_arg++;
+            }
+            break;
+        }
+        
+        // Unknown flag
+        std::cerr << "Unknown option: " << arg << std::endl;
+        result.should_exit = true;
+        result.exit_code = 1;
+        return result;
+    }
+    
+    return result;
+}
+
+void CommandLineParser::print_help() {
+    std::cout << "usage: mcrogueface [option] ... [-c cmd | -m mod | file | -] [arg] ...\n"
+              << "Options:\n"
+              << "  -c cmd : program passed in as string (terminates option list)\n"
+              << "  -h     : print this help message and exit (also --help)\n"
+              << "  -i     : inspect interactively after running script\n"
+              << "  -m mod : run library module as a script (terminates option list)\n"
+              << "  -V     : print the Python version number and exit (also --version)\n"
+              << "\n"
+              << "McRogueFace specific options:\n"
+              << "  --exec file  : execute script before main program (can be used multiple times)\n"
+              << "  --headless   : run without creating a window (implies --audio-off)\n"
+              << "  --audio-off  : disable audio\n"
+              << "  --audio-on   : enable audio (even in headless mode)\n"
+              << "  --screenshot [path] : take a screenshot in headless mode\n"
+              << "\n"
+              << "Arguments:\n"
+              << "  file   : program read from script file\n"
+              << "  -      : program read from stdin\n"
+              << "  arg ...: arguments passed to program in sys.argv[1:]\n";
+}
+
+void CommandLineParser::print_version() {
+    std::cout << "Python 3.12.0 (McRogueFace embedded)\n";
+}

src/CommandLineParser.h

@@ -0,0 +1,30 @@
+#ifndef COMMAND_LINE_PARSER_H
+#define COMMAND_LINE_PARSER_H
+
+#include <string>
+#include <vector>
+#include "McRogueFaceConfig.h"
+
+class CommandLineParser {
+public:
+    struct ParseResult {
+        bool should_exit = false;
+        int exit_code = 0;
+    };
+    
+    CommandLineParser(int argc, char* argv[]);
+    ParseResult parse(McRogueFaceConfig& config);
+    
+private:
+    int argc;
+    char** argv;
+    int current_arg = 1;  // Skip program name
+    
+    bool has_flag(const std::string& short_flag, const std::string& long_flag = "");
+    std::string get_next_arg(const std::string& flag_name);
+    void parse_positional_args(McRogueFaceConfig& config);
+    void print_help();
+    void print_version();
+};
+
+#endif // COMMAND_LINE_PARSER_H

src/GameEngine.cpp

@@ -4,67 +4,285 @@
 #include "PyScene.h"
 #include "UITestScene.h"
 #include "Resources.h"
+#include "Animation.h"
+#include "Timer.h"
+#include <cmath>
 
-GameEngine::GameEngine()
+GameEngine::GameEngine() : GameEngine(McRogueFaceConfig{})
+{
+}
+
+GameEngine::GameEngine(const McRogueFaceConfig& cfg)
+    : config(cfg), headless(cfg.headless)
 {
     Resources::font.loadFromFile("./assets/JetbrainsMono.ttf");
     Resources::game = this;
-    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);
+    window_title = "McRogueFace Engine";
+    
+    // Initialize rendering based on headless mode
+    if (headless) {
+        headless_renderer = std::make_unique<HeadlessRenderer>();
+        if (!headless_renderer->init(1024, 768)) {
+            throw std::runtime_error("Failed to initialize headless renderer");
+        }
+        render_target = &headless_renderer->getRenderTarget();
+    } else {
+        window = std::make_unique<sf::RenderWindow>();
+        window->create(sf::VideoMode(1024, 768), window_title, sf::Style::Titlebar | sf::Style::Close | sf::Style::Resize);
+        window->setFramerateLimit(60);
+        render_target = window.get();
+    }
+    
+    visible = render_target->getDefaultView();
+    
+    // Initialize the game view
+    gameView.setSize(static_cast<float>(gameResolution.x), static_cast<float>(gameResolution.y));
+    // Use integer center coordinates for pixel-perfect rendering
+    gameView.setCenter(std::floor(gameResolution.x / 2.0f), std::floor(gameResolution.y / 2.0f));
+    updateViewport();
     scene = "uitest";
     scenes["uitest"] = new UITestScene(this);
     
     McRFPy_API::game = this;
-    McRFPy_API::api_init();
-    McRFPy_API::executePyString("import mcrfpy");
-    McRFPy_API::executeScript("scripts/game.py");
+    
+    // Only load game.py if no custom script/command/module/exec is specified
+    bool should_load_game = config.script_path.empty() && 
+                           config.python_command.empty() && 
+                           config.python_module.empty() &&
+                           config.exec_scripts.empty() &&
+                           !config.interactive_mode &&
+                           !config.python_mode;
+    
+    if (should_load_game) {
+        if (!Py_IsInitialized()) {
+            McRFPy_API::api_init();
+        }
+        McRFPy_API::executePyString("import mcrfpy");
+        McRFPy_API::executeScript("scripts/game.py");
+    }
+    
+    // Execute any --exec scripts in order
+    if (!config.exec_scripts.empty()) {
+        if (!Py_IsInitialized()) {
+            McRFPy_API::api_init();
+        }
+        McRFPy_API::executePyString("import mcrfpy");
+        
+        for (const auto& exec_script : config.exec_scripts) {
+            std::cout << "Executing script: " << exec_script << std::endl;
+            McRFPy_API::executeScript(exec_script.string());
+        }
+        std::cout << "All --exec scripts completed" << std::endl;
+    }
 
     clock.restart();
     runtime.restart();
 }
 
+GameEngine::~GameEngine()
+{
+    cleanup();
+    for (auto& [name, scene] : scenes) {
+        delete scene;
+    }
+}
+
+void GameEngine::cleanup()
+{
+    if (cleaned_up) return;
+    cleaned_up = true;
+    
+    // Clear all animations first (RAII handles invalidation)
+    AnimationManager::getInstance().clear();
+    
+    // Clear Python references before destroying C++ objects
+    // Clear all timers (they hold Python callables)
+    timers.clear();
+    
+    // Clear McRFPy_API's reference to this game engine
+    if (McRFPy_API::game == this) {
+        McRFPy_API::game = nullptr;
+    }
+    
+    // Force close the window if it's still open
+    if (window && window->isOpen()) {
+        window->close();
+    }
+}
+
 Scene* GameEngine::currentScene() { return scenes[scene]; }
 void GameEngine::changeScene(std::string s)
 {
-    /*std::cout << "Current scene is now '" << s << "'\n";*/
-    if (scenes.find(s) != scenes.end())
-        scene = s;
+    changeScene(s, TransitionType::None, 0.0f);
+}
+
+void GameEngine::changeScene(std::string sceneName, TransitionType transitionType, float duration)
+{
+    if (scenes.find(sceneName) == scenes.end())
+    {
+        std::cout << "Attempted to change to a scene that doesn't exist (`" << sceneName << "`)" << std::endl;
+        return;
+    }
+    
+    if (transitionType == TransitionType::None || duration <= 0.0f)
+    {
+        // Immediate scene change
+        std::string old_scene = scene;
+        scene = sceneName;
+        
+        // Trigger Python scene lifecycle events
+        McRFPy_API::triggerSceneChange(old_scene, sceneName);
+    }
     else
-        std::cout << "Attempted to change to a scene that doesn't exist (`" << s << "`)" << std::endl;
+    {
+        // Start transition
+        transition.start(transitionType, scene, sceneName, duration);
+        
+        // Render current scene to texture
+        sf::RenderTarget* original_target = render_target;
+        render_target = transition.oldSceneTexture.get();
+        transition.oldSceneTexture->clear();
+        currentScene()->render();
+        transition.oldSceneTexture->display();
+        
+        // Change to new scene
+        std::string old_scene = scene;
+        scene = sceneName;
+        
+        // Render new scene to texture
+        render_target = transition.newSceneTexture.get();
+        transition.newSceneTexture->clear();
+        currentScene()->render();
+        transition.newSceneTexture->display();
+        
+        // Restore original render target and scene
+        render_target = original_target;
+        scene = old_scene;
+    }
 }
 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; }
+sf::RenderWindow & GameEngine::getWindow() { 
+    if (!window) {
+        throw std::runtime_error("Window not available in headless mode");
+    }
+    return *window; 
+}
+
+sf::RenderTarget & GameEngine::getRenderTarget() { 
+    return *render_target; 
+}
 
 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);
+    if (!headless && window) {
+        window->setSize(sf::Vector2u(gameResolution.x * multiplier, gameResolution.y * multiplier));
+        updateViewport();
+    }
 }
 
 void GameEngine::run()
 {
+    //std::cout << "GameEngine::run() starting main loop..." << std::endl;
     float fps = 0.0;
+    frameTime = 0.016f; // Initialize to ~60 FPS
     clock.restart();
     while (running)
     {
+        // Reset per-frame metrics
+        metrics.resetPerFrame();
+        
         currentScene()->update();
         testTimers();
-        sUserInput();
+        
+        // Update Python scenes
+        McRFPy_API::updatePythonScenes(frameTime);
+        
+        // Update animations (only if frameTime is valid)
+        if (frameTime > 0.0f && frameTime < 1.0f) {
+            AnimationManager::getInstance().update(frameTime);
+        }
+        
+        if (!headless) {
+            sUserInput();
+        }
         if (!paused)
         {
         }
-        currentScene()->sRender();
+        
+        // Handle scene transitions
+        if (transition.type != TransitionType::None)
+        {
+            transition.update(frameTime);
+            
+            if (transition.isComplete())
+            {
+                // Transition complete - finalize scene change
+                scene = transition.toScene;
+                transition.type = TransitionType::None;
+                
+                // Trigger Python scene lifecycle events
+                McRFPy_API::triggerSceneChange(transition.fromScene, transition.toScene);
+            }
+            else
+            {
+                // Render transition
+                render_target->clear();
+                transition.render(*render_target);
+            }
+        }
+        else
+        {
+            // Normal scene rendering
+            currentScene()->render();
+        }
+        
+        // Display the frame
+        if (headless) {
+            headless_renderer->display();
+            // Take screenshot if requested
+            if (config.take_screenshot) {
+                headless_renderer->saveScreenshot(config.screenshot_path.empty() ? "screenshot.png" : config.screenshot_path);
+                config.take_screenshot = false; // Only take one screenshot
+            }
+        } else {
+            window->display();
+        }
+        
         currentFrame++;
         frameTime = clock.restart().asSeconds();
         fps = 1 / frameTime;
-        window.setTitle(window_title + " " + std::to_string(fps) + " FPS");
+        
+        // Update profiling metrics
+        metrics.updateFrameTime(frameTime * 1000.0f); // Convert to milliseconds
+        
+        int whole_fps = metrics.fps;
+        int tenth_fps = (metrics.fps * 10) % 10;
+        
+        if (!headless && window) {
+            window->setTitle(window_title);
+        }
+        
+        // In windowed mode, check if window was closed
+        if (!headless && window && !window->isOpen()) {
+            running = false;
+        }
     }
+    
+    // Clean up before exiting the run loop
+    cleanup();
+}
+
+std::shared_ptr<Timer> GameEngine::getTimer(const std::string& name)
+{
+    auto it = timers.find(name);
+    if (it != timers.end()) {
+        return it->second;
+    }
+    return nullptr;
 }
 
 void GameEngine::manageTimer(std::string name, PyObject* target, int interval)
@@ -76,7 +294,7 @@ void GameEngine::manageTimer(std::string name, PyObject* target, int interval)
         {
             // 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());
+            timers[name] = std::make_shared<Timer>(Py_None, 1000, runtime.getElapsedTime().asMilliseconds());
             return;
         }
     }
@@ -85,7 +303,7 @@ void GameEngine::manageTimer(std::string name, PyObject* target, int interval)
         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());
+    timers[name] = std::make_shared<Timer>(target, interval, runtime.getElapsedTime().asMilliseconds());
 }
 
 void GameEngine::testTimers()
@@ -96,7 +314,8 @@ void GameEngine::testTimers()
     {
         it->second->test(now);
         
-        if (it->second->isNone())
+        // Remove timers that have been cancelled or are one-shot and fired
+        if (!it->second->getCallback() || it->second->getCallback() == Py_None)
         {
             it = timers.erase(it);
         }
@@ -105,86 +324,58 @@ void GameEngine::testTimers()
     }
 }
 
+void GameEngine::processEvent(const sf::Event& event)
+{
+    std::string actionType;
+    int actionCode = 0;
+
+    if (event.type == sf::Event::Closed) { running = false; return; }
+    // Handle window resize events
+    else if (event.type == sf::Event::Resized) {
+        // Update the viewport to handle the new window size
+        updateViewport();
+        
+        // Notify Python scenes about the resize
+        McRFPy_API::triggerResize(event.size.width, event.size.height);
+    }
+
+    else if (event.type == sf::Event::KeyPressed || event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseWheelScrolled) actionType = "start";
+    else if (event.type == sf::Event::KeyReleased || event.type == sf::Event::MouseButtonReleased) actionType = "end";
+
+    if (event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseButtonReleased)
+        actionCode = ActionCode::keycode(event.mouseButton.button);
+    else if (event.type == sf::Event::KeyPressed || event.type == sf::Event::KeyReleased)
+        actionCode = ActionCode::keycode(event.key.code);
+    else if (event.type == sf::Event::MouseWheelScrolled)
+    {
+        if (event.mouseWheelScroll.wheel == sf::Mouse::VerticalWheel)
+        {
+            int delta = 1;
+            if (event.mouseWheelScroll.delta < 0) delta = -1;
+            actionCode = ActionCode::keycode(event.mouseWheelScroll.wheel, delta );
+        }
+    }
+    else
+        return;
+
+    if (currentScene()->hasAction(actionCode))
+    {
+        std::string name = currentScene()->action(actionCode);
+        currentScene()->doAction(name, actionType);
+    }
+    else if (currentScene()->key_callable && 
+             (event.type == sf::Event::KeyPressed || event.type == sf::Event::KeyReleased))
+    {
+        currentScene()->key_callable->call(ActionCode::key_str(event.key.code), actionType);
+    }
+}
+
 void GameEngine::sUserInput()
 {
     sf::Event event;
-    while (window.pollEvent(event))
+    while (window && window->pollEvent(event))
     {
-        std::string actionType;
-        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);
-            //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";
-        else if (event.type == sf::Event::KeyReleased || event.type == sf::Event::MouseButtonReleased) actionType = "end";
-
-        if (event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseButtonReleased)
-            actionCode = ActionCode::keycode(event.mouseButton.button);
-        else if (event.type == sf::Event::KeyPressed || event.type == sf::Event::KeyReleased)
-            actionCode = ActionCode::keycode(event.key.code);
-        else if (event.type == sf::Event::MouseWheelScrolled)
-        {
-        //    //sf::Mouse::Wheel w = event.MouseWheelScrollEvent.wheel;
-            if (event.mouseWheelScroll.wheel == sf::Mouse::VerticalWheel)
-            {
-                int delta = 1;
-                if (event.mouseWheelScroll.delta < 0) delta = -1;
-                actionCode = ActionCode::keycode(event.mouseWheelScroll.wheel, delta );
-                /*
-                std::cout << "[GameEngine] Generated MouseWheel code w(" << (int)event.mouseWheelScroll.wheel << ") d(" << event.mouseWheelScroll.delta << ") D(" << delta << ") = " << actionCode << std::endl;
-                std::cout << " test decode: isMouseWheel=" << ActionCode::isMouseWheel(actionCode) << ", wheel=" << ActionCode::wheel(actionCode) << ", delta=" << ActionCode::delta(actionCode) << std::endl;
-                std::cout << " math test: actionCode && WHEEL_NEG -> " << (actionCode && ActionCode::WHEEL_NEG) << "; actionCode && WHEEL_DEL -> " << (actionCode && ActionCode::WHEEL_DEL) << ";" << std::endl;
-                */
-            }
-        //    float d = event.MouseWheelScrollEvent.delta;
-        //    actionCode = ActionCode::keycode(0, d);
-        }
-        else
-            continue;
-
-        //std::cout << "Event produced action code " << actionCode << ": " << actionType << std::endl;
-
-        if (currentScene()->hasAction(actionCode))
-        {
-            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;
-        }
+        processEvent(event);
     }
 }
 
@@ -205,3 +396,123 @@ std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> GameEngine::scene_ui(s
     if (scenes.count(target) == 0) return NULL;
     return scenes[target]->ui_elements;
 }
+
+void GameEngine::setWindowTitle(const std::string& title)
+{
+    window_title = title;
+    if (!headless && window) {
+        window->setTitle(title);
+    }
+}
+
+void GameEngine::setVSync(bool enabled)
+{
+    vsync_enabled = enabled;
+    if (!headless && window) {
+        window->setVerticalSyncEnabled(enabled);
+    }
+}
+
+void GameEngine::setFramerateLimit(unsigned int limit)
+{
+    framerate_limit = limit;
+    if (!headless && window) {
+        window->setFramerateLimit(limit);
+    }
+}
+
+void GameEngine::setGameResolution(unsigned int width, unsigned int height) {
+    gameResolution = sf::Vector2u(width, height);
+    gameView.setSize(static_cast<float>(width), static_cast<float>(height));
+    // Use integer center coordinates for pixel-perfect rendering
+    gameView.setCenter(std::floor(width / 2.0f), std::floor(height / 2.0f));
+    updateViewport();
+}
+
+void GameEngine::setViewportMode(ViewportMode mode) {
+    viewportMode = mode;
+    updateViewport();
+}
+
+std::string GameEngine::getViewportModeString() const {
+    switch (viewportMode) {
+        case ViewportMode::Center:  return "center";
+        case ViewportMode::Stretch: return "stretch";
+        case ViewportMode::Fit:     return "fit";
+    }
+    return "unknown";
+}
+
+void GameEngine::updateViewport() {
+    if (!render_target) return;
+    
+    auto windowSize = render_target->getSize();
+    
+    switch (viewportMode) {
+        case ViewportMode::Center: {
+            // 1:1 pixels, centered in window
+            float viewportWidth = std::min(static_cast<float>(gameResolution.x), static_cast<float>(windowSize.x));
+            float viewportHeight = std::min(static_cast<float>(gameResolution.y), static_cast<float>(windowSize.y));
+            
+            // Floor offsets to ensure integer pixel alignment
+            float offsetX = std::floor((windowSize.x - viewportWidth) / 2.0f);
+            float offsetY = std::floor((windowSize.y - viewportHeight) / 2.0f);
+            
+            gameView.setViewport(sf::FloatRect(
+                offsetX / windowSize.x,
+                offsetY / windowSize.y,
+                viewportWidth / windowSize.x,
+                viewportHeight / windowSize.y
+            ));
+            break;
+        }
+        
+        case ViewportMode::Stretch: {
+            // Fill entire window, ignore aspect ratio
+            gameView.setViewport(sf::FloatRect(0, 0, 1, 1));
+            break;
+        }
+        
+        case ViewportMode::Fit: {
+            // Maintain aspect ratio with black bars
+            float windowAspect = static_cast<float>(windowSize.x) / windowSize.y;
+            float gameAspect = static_cast<float>(gameResolution.x) / gameResolution.y;
+            
+            float viewportWidth, viewportHeight;
+            float offsetX = 0, offsetY = 0;
+            
+            if (windowAspect > gameAspect) {
+                // Window is wider - black bars on sides
+                // Calculate viewport size in pixels and floor for pixel-perfect scaling
+                float pixelHeight = static_cast<float>(windowSize.y);
+                float pixelWidth = std::floor(pixelHeight * gameAspect);
+                
+                viewportHeight = 1.0f;
+                viewportWidth = pixelWidth / windowSize.x;
+                offsetX = (1.0f - viewportWidth) / 2.0f;
+            } else {
+                // Window is taller - black bars on top/bottom
+                // Calculate viewport size in pixels and floor for pixel-perfect scaling
+                float pixelWidth = static_cast<float>(windowSize.x);
+                float pixelHeight = std::floor(pixelWidth / gameAspect);
+                
+                viewportWidth = 1.0f;
+                viewportHeight = pixelHeight / windowSize.y;
+                offsetY = (1.0f - viewportHeight) / 2.0f;
+            }
+            
+            gameView.setViewport(sf::FloatRect(offsetX, offsetY, viewportWidth, viewportHeight));
+            break;
+        }
+    }
+    
+    // Apply the view
+    render_target->setView(gameView);
+}
+
+sf::Vector2f GameEngine::windowToGameCoords(const sf::Vector2f& windowPos) const {
+    if (!render_target) return windowPos;
+    
+    // Convert window coordinates to game coordinates using the view
+    return render_target->mapPixelToCoords(sf::Vector2i(windowPos), gameView);
+}

src/GameEngine.h

@@ -6,10 +6,26 @@
 #include "IndexTexture.h"
 #include "Timer.h"
 #include "PyCallable.h"
+#include "McRogueFaceConfig.h"
+#include "HeadlessRenderer.h"
+#include "SceneTransition.h"
+#include <memory>
 
 class GameEngine
 {
-    sf::RenderWindow window;
+public:
+    // Viewport modes (moved here so private section can use it)
+    enum class ViewportMode {
+        Center,     // 1:1 pixels, viewport centered in window
+        Stretch,    // viewport size = window size, doesn't respect aspect ratio
+        Fit         // maintains original aspect ratio, leaves black bars
+    };
+
+private:
+    std::unique_ptr<sf::RenderWindow> window;
+    std::unique_ptr<HeadlessRenderer> headless_renderer;
+    sf::RenderTarget* render_target;
+    
     sf::Font font;
     std::map<std::string, Scene*> scenes;
     bool running = true;
@@ -19,29 +35,106 @@ class GameEngine
     sf::Clock clock;
     float frameTime;
     std::string window_title;
+    
+    bool headless = false;
+    McRogueFaceConfig config;
+    bool cleaned_up = false;
+    
+    // Window state tracking
+    bool vsync_enabled = false;
+    unsigned int framerate_limit = 60;
+    
+    // Scene transition state
+    SceneTransition transition;
+    
+    // Viewport system
+    sf::Vector2u gameResolution{1024, 768};  // Fixed game resolution
+    sf::View gameView;                        // View for the game content
+    ViewportMode viewportMode = ViewportMode::Fit;
+    
+    void updateViewport();
 
-    sf::Clock runtime;
-    //std::map<std::string, Timer> timers;
-    std::map<std::string, std::shared_ptr<PyTimerCallable>> timers;
     void testTimers();
 
 public:
+    sf::Clock runtime;
+    std::map<std::string, std::shared_ptr<Timer>> timers;
     std::string scene;
+    
+    // Profiling metrics
+    struct ProfilingMetrics {
+        float frameTime = 0.0f;          // Current frame time in milliseconds
+        float avgFrameTime = 0.0f;       // Average frame time over last N frames
+        int fps = 0;                     // Frames per second
+        int drawCalls = 0;               // Draw calls per frame
+        int uiElements = 0;              // Number of UI elements rendered
+        int visibleElements = 0;         // Number of visible elements
+        
+        // Frame time history for averaging
+        static constexpr int HISTORY_SIZE = 60;
+        float frameTimeHistory[HISTORY_SIZE] = {0};
+        int historyIndex = 0;
+        
+        void updateFrameTime(float deltaMs) {
+            frameTime = deltaMs;
+            frameTimeHistory[historyIndex] = deltaMs;
+            historyIndex = (historyIndex + 1) % HISTORY_SIZE;
+            
+            // Calculate average
+            float sum = 0.0f;
+            for (int i = 0; i < HISTORY_SIZE; ++i) {
+                sum += frameTimeHistory[i];
+            }
+            avgFrameTime = sum / HISTORY_SIZE;
+            fps = avgFrameTime > 0 ? static_cast<int>(1000.0f / avgFrameTime) : 0;
+        }
+        
+        void resetPerFrame() {
+            drawCalls = 0;
+            uiElements = 0;
+            visibleElements = 0;
+        }
+    } metrics;
     GameEngine();
+    GameEngine(const McRogueFaceConfig& cfg);
+    ~GameEngine();
     Scene* currentScene();
     void changeScene(std::string);
+    void changeScene(std::string sceneName, TransitionType transitionType, float duration);
     void createScene(std::string);
     void quit();
     void setPause(bool);
     sf::Font & getFont();
     sf::RenderWindow & getWindow();
+    sf::RenderTarget & getRenderTarget();
+    sf::RenderTarget* getRenderTargetPtr() { return render_target; }
     void run();
     void sUserInput();
+    void cleanup(); // Clean up Python references before destruction
     int getFrame() { return currentFrame; }
     float getFrameTime() { return frameTime; }
     sf::View getView() { return visible; }
     void manageTimer(std::string, PyObject*, int);
+    std::shared_ptr<Timer> getTimer(const std::string& name);
     void setWindowScale(float);
+    bool isHeadless() const { return headless; }
+    void processEvent(const sf::Event& event);
+    
+    // Window property accessors
+    const std::string& getWindowTitle() const { return window_title; }
+    void setWindowTitle(const std::string& title);
+    bool getVSync() const { return vsync_enabled; }
+    void setVSync(bool enabled);
+    unsigned int getFramerateLimit() const { return framerate_limit; }
+    void setFramerateLimit(unsigned int limit);
+    
+    // Viewport system
+    void setGameResolution(unsigned int width, unsigned int height);
+    sf::Vector2u getGameResolution() const { return gameResolution; }
+    void setViewportMode(ViewportMode mode);
+    ViewportMode getViewportMode() const { return viewportMode; }
+    std::string getViewportModeString() const;
+    sf::Vector2f windowToGameCoords(const sf::Vector2f& windowPos) const;
 
     // global textures for scripts to access
     std::vector<IndexTexture> textures;

src/HeadlessRenderer.cpp

@@ -0,0 +1,27 @@
+#include "HeadlessRenderer.h"
+#include <iostream>
+
+bool HeadlessRenderer::init(int width, int height) {
+    if (!render_texture.create(width, height)) {
+        std::cerr << "Failed to create headless render texture" << std::endl;
+        return false;
+    }
+    return true;
+}
+
+sf::RenderTarget& HeadlessRenderer::getRenderTarget() {
+    return render_texture;
+}
+
+void HeadlessRenderer::saveScreenshot(const std::string& path) {
+    sf::Image screenshot = render_texture.getTexture().copyToImage();
+    if (!screenshot.saveToFile(path)) {
+        std::cerr << "Failed to save screenshot to: " << path << std::endl;
+    } else {
+        std::cout << "Screenshot saved to: " << path << std::endl;
+    }
+}
+
+void HeadlessRenderer::display() {
+    render_texture.display();
+}

src/HeadlessRenderer.h

@@ -0,0 +1,20 @@
+#ifndef HEADLESS_RENDERER_H
+#define HEADLESS_RENDERER_H
+
+#include <SFML/Graphics.hpp>
+#include <memory>
+#include <string>
+
+class HeadlessRenderer {
+private:
+    sf::RenderTexture render_texture;
+    
+public:
+    bool init(int width = 1024, int height = 768);
+    sf::RenderTarget& getRenderTarget();
+    void saveScreenshot(const std::string& path);
+    void display();  // Finalize the current frame
+    bool isOpen() const { return true; }  // Always "open" in headless mode
+};
+
+#endif // HEADLESS_RENDERER_H

src/McRFPy_API.h

@@ -3,6 +3,10 @@
 #include "Python.h"
 #include <list>
 
+#include "PyFont.h"
+#include "PyTexture.h"
+#include "McRogueFaceConfig.h"
+
 class GameEngine; // forward declared (circular members)
 
 class McRFPy_API
@@ -14,25 +18,28 @@ private:
 
     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_init(const McRogueFaceConfig& config, int argc, char** argv);
+    static PyStatus init_python_with_config(const McRogueFaceConfig& config, int argc, char** argv);
     static void api_shutdown();
     // Python API functionality - use mcrfpy.* in scripts
     //static PyObject* _drawSprite(PyObject*, PyObject*);
     static void REPL_device(FILE * fp, const char *filename);
     static void REPL();
 
-    static std::vector<sf::SoundBuffer> soundbuffers;
-    static sf::Music music;
-    static sf::Sound sfx;
+    static std::vector<sf::SoundBuffer>* soundbuffers;
+    static sf::Music* music;
+    static sf::Sound* sfx;
     
-    static std::map<std::string, PyObject*> callbacks;
-    static PyObject* _registerPyAction(PyObject*, PyObject*);
-    static PyObject* _registerInputAction(PyObject*, PyObject*);
     
     static PyObject* _createSoundBuffer(PyObject*, PyObject*);
     static PyObject* _loadMusic(PyObject*, PyObject*);
@@ -59,12 +66,23 @@ public:
 
     // accept keyboard input from scene
     static sf::Vector2i cursor_position;
-    static void player_input(int, int);
-    static void computerTurn();
-    static void playerTurn();
     
-    static void doAction(std::string);
 
     static void executeScript(std::string);
     static void executePyString(std::string);
+    
+    // Helper to mark scenes as needing z_index resort
+    static void markSceneNeedsSort();
+    
+    // Name-based finding methods
+    static PyObject* _find(PyObject*, PyObject*);
+    static PyObject* _findAll(PyObject*, PyObject*);
+    
+    // Profiling/metrics
+    static PyObject* _getMetrics(PyObject*, PyObject*);
+    
+    // Scene lifecycle management for Python Scene objects
+    static void triggerSceneChange(const std::string& from_scene, const std::string& to_scene);
+    static void updatePythonScenes(float dt);
+    static void triggerResize(int width, int height);
 };

src/McRFPy_Automation.cpp

@@ -0,0 +1,817 @@
+#include "McRFPy_Automation.h"
+#include "McRFPy_API.h"
+#include "GameEngine.h"
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+
+// Helper function to get game engine
+GameEngine* McRFPy_Automation::getGameEngine() {
+    return McRFPy_API::game;
+}
+
+// Sleep helper
+void McRFPy_Automation::sleep_ms(int milliseconds) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+}
+
+// Convert string to SFML key code
+sf::Keyboard::Key McRFPy_Automation::stringToKey(const std::string& keyName) {
+    static const std::unordered_map<std::string, sf::Keyboard::Key> keyMap = {
+        // Letters
+        {"a", sf::Keyboard::A}, {"b", sf::Keyboard::B}, {"c", sf::Keyboard::C},
+        {"d", sf::Keyboard::D}, {"e", sf::Keyboard::E}, {"f", sf::Keyboard::F},
+        {"g", sf::Keyboard::G}, {"h", sf::Keyboard::H}, {"i", sf::Keyboard::I},
+        {"j", sf::Keyboard::J}, {"k", sf::Keyboard::K}, {"l", sf::Keyboard::L},
+        {"m", sf::Keyboard::M}, {"n", sf::Keyboard::N}, {"o", sf::Keyboard::O},
+        {"p", sf::Keyboard::P}, {"q", sf::Keyboard::Q}, {"r", sf::Keyboard::R},
+        {"s", sf::Keyboard::S}, {"t", sf::Keyboard::T}, {"u", sf::Keyboard::U},
+        {"v", sf::Keyboard::V}, {"w", sf::Keyboard::W}, {"x", sf::Keyboard::X},
+        {"y", sf::Keyboard::Y}, {"z", sf::Keyboard::Z},
+        
+        // Numbers
+        {"0", sf::Keyboard::Num0}, {"1", sf::Keyboard::Num1}, {"2", sf::Keyboard::Num2},
+        {"3", sf::Keyboard::Num3}, {"4", sf::Keyboard::Num4}, {"5", sf::Keyboard::Num5},
+        {"6", sf::Keyboard::Num6}, {"7", sf::Keyboard::Num7}, {"8", sf::Keyboard::Num8},
+        {"9", sf::Keyboard::Num9},
+        
+        // Function keys
+        {"f1", sf::Keyboard::F1}, {"f2", sf::Keyboard::F2}, {"f3", sf::Keyboard::F3},
+        {"f4", sf::Keyboard::F4}, {"f5", sf::Keyboard::F5}, {"f6", sf::Keyboard::F6},
+        {"f7", sf::Keyboard::F7}, {"f8", sf::Keyboard::F8}, {"f9", sf::Keyboard::F9},
+        {"f10", sf::Keyboard::F10}, {"f11", sf::Keyboard::F11}, {"f12", sf::Keyboard::F12},
+        {"f13", sf::Keyboard::F13}, {"f14", sf::Keyboard::F14}, {"f15", sf::Keyboard::F15},
+        
+        // Special keys
+        {"escape", sf::Keyboard::Escape}, {"esc", sf::Keyboard::Escape},
+        {"enter", sf::Keyboard::Enter}, {"return", sf::Keyboard::Enter},
+        {"space", sf::Keyboard::Space}, {" ", sf::Keyboard::Space},
+        {"tab", sf::Keyboard::Tab}, {"\t", sf::Keyboard::Tab},
+        {"backspace", sf::Keyboard::BackSpace},
+        {"delete", sf::Keyboard::Delete}, {"del", sf::Keyboard::Delete},
+        {"insert", sf::Keyboard::Insert},
+        {"home", sf::Keyboard::Home},
+        {"end", sf::Keyboard::End},
+        {"pageup", sf::Keyboard::PageUp}, {"pgup", sf::Keyboard::PageUp},
+        {"pagedown", sf::Keyboard::PageDown}, {"pgdn", sf::Keyboard::PageDown},
+        
+        // Arrow keys
+        {"left", sf::Keyboard::Left},
+        {"right", sf::Keyboard::Right},
+        {"up", sf::Keyboard::Up},
+        {"down", sf::Keyboard::Down},
+        
+        // Modifiers
+        {"ctrl", sf::Keyboard::LControl}, {"ctrlleft", sf::Keyboard::LControl},
+        {"ctrlright", sf::Keyboard::RControl},
+        {"alt", sf::Keyboard::LAlt}, {"altleft", sf::Keyboard::LAlt},
+        {"altright", sf::Keyboard::RAlt},
+        {"shift", sf::Keyboard::LShift}, {"shiftleft", sf::Keyboard::LShift},
+        {"shiftright", sf::Keyboard::RShift},
+        {"win", sf::Keyboard::LSystem}, {"winleft", sf::Keyboard::LSystem},
+        {"winright", sf::Keyboard::RSystem}, {"command", sf::Keyboard::LSystem},
+        
+        // Punctuation
+        {",", sf::Keyboard::Comma}, {".", sf::Keyboard::Period},
+        {"/", sf::Keyboard::Slash}, {"\\", sf::Keyboard::BackSlash},
+        {";", sf::Keyboard::SemiColon}, {"'", sf::Keyboard::Quote},
+        {"[", sf::Keyboard::LBracket}, {"]", sf::Keyboard::RBracket},
+        {"-", sf::Keyboard::Dash}, {"=", sf::Keyboard::Equal},
+        
+        // Numpad
+        {"num0", sf::Keyboard::Numpad0}, {"num1", sf::Keyboard::Numpad1},
+        {"num2", sf::Keyboard::Numpad2}, {"num3", sf::Keyboard::Numpad3},
+        {"num4", sf::Keyboard::Numpad4}, {"num5", sf::Keyboard::Numpad5},
+        {"num6", sf::Keyboard::Numpad6}, {"num7", sf::Keyboard::Numpad7},
+        {"num8", sf::Keyboard::Numpad8}, {"num9", sf::Keyboard::Numpad9},
+        {"add", sf::Keyboard::Add}, {"subtract", sf::Keyboard::Subtract},
+        {"multiply", sf::Keyboard::Multiply}, {"divide", sf::Keyboard::Divide},
+        
+        // Other
+        {"pause", sf::Keyboard::Pause},
+        {"capslock", sf::Keyboard::LControl},  // Note: SFML doesn't have CapsLock
+        {"numlock", sf::Keyboard::LControl},   // Note: SFML doesn't have NumLock
+        {"scrolllock", sf::Keyboard::LControl}, // Note: SFML doesn't have ScrollLock
+    };
+    
+    auto it = keyMap.find(keyName);
+    if (it != keyMap.end()) {
+        return it->second;
+    }
+    return sf::Keyboard::Unknown;
+}
+
+// Inject mouse event into the game engine
+void McRFPy_Automation::injectMouseEvent(sf::Event::EventType type, int x, int y, sf::Mouse::Button button) {
+    auto engine = getGameEngine();
+    if (!engine) return;
+    
+    sf::Event event;
+    event.type = type;
+    
+    switch (type) {
+        case sf::Event::MouseMoved:
+            event.mouseMove.x = x;
+            event.mouseMove.y = y;
+            break;
+        case sf::Event::MouseButtonPressed:
+        case sf::Event::MouseButtonReleased:
+            event.mouseButton.button = button;
+            event.mouseButton.x = x;
+            event.mouseButton.y = y;
+            break;
+        case sf::Event::MouseWheelScrolled:
+            event.mouseWheelScroll.wheel = sf::Mouse::VerticalWheel;
+            event.mouseWheelScroll.delta = static_cast<float>(x); // x is used for scroll amount
+            event.mouseWheelScroll.x = x;
+            event.mouseWheelScroll.y = y;
+            break;
+        default:
+            break;
+    }
+    
+    engine->processEvent(event);
+}
+
+// Inject keyboard event into the game engine
+void McRFPy_Automation::injectKeyEvent(sf::Event::EventType type, sf::Keyboard::Key key) {
+    auto engine = getGameEngine();
+    if (!engine) return;
+    
+    sf::Event event;
+    event.type = type;
+    
+    if (type == sf::Event::KeyPressed || type == sf::Event::KeyReleased) {
+        event.key.code = key;
+        event.key.alt = sf::Keyboard::isKeyPressed(sf::Keyboard::LAlt) || 
+                        sf::Keyboard::isKeyPressed(sf::Keyboard::RAlt);
+        event.key.control = sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) || 
+                           sf::Keyboard::isKeyPressed(sf::Keyboard::RControl);
+        event.key.shift = sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) || 
+                         sf::Keyboard::isKeyPressed(sf::Keyboard::RShift);
+        event.key.system = sf::Keyboard::isKeyPressed(sf::Keyboard::LSystem) || 
+                          sf::Keyboard::isKeyPressed(sf::Keyboard::RSystem);
+    }
+    
+    engine->processEvent(event);
+}
+
+// Inject text event for typing
+void McRFPy_Automation::injectTextEvent(sf::Uint32 unicode) {
+    auto engine = getGameEngine();
+    if (!engine) return;
+    
+    sf::Event event;
+    event.type = sf::Event::TextEntered;
+    event.text.unicode = unicode;
+    
+    engine->processEvent(event);
+}
+
+// Screenshot implementation
+PyObject* McRFPy_Automation::_screenshot(PyObject* self, PyObject* args) {
+    const char* filename;
+    if (!PyArg_ParseTuple(args, "s", &filename)) {
+        return NULL;
+    }
+    
+    auto engine = getGameEngine();
+    if (!engine) {
+        PyErr_SetString(PyExc_RuntimeError, "Game engine not initialized");
+        return NULL;
+    }
+    
+    // Get the render target
+    sf::RenderTarget* target = engine->getRenderTargetPtr();
+    if (!target) {
+        PyErr_SetString(PyExc_RuntimeError, "No render target available");
+        return NULL;
+    }
+    
+    // For RenderWindow, we can get a screenshot directly
+    if (auto* window = dynamic_cast<sf::RenderWindow*>(target)) {
+        sf::Vector2u windowSize = window->getSize();
+        sf::Texture texture;
+        texture.create(windowSize.x, windowSize.y);
+        texture.update(*window);
+        
+        if (texture.copyToImage().saveToFile(filename)) {
+            Py_RETURN_TRUE;
+        } else {
+            Py_RETURN_FALSE;
+        }
+    }
+    // For RenderTexture (headless mode)
+    else if (auto* renderTexture = dynamic_cast<sf::RenderTexture*>(target)) {
+        if (renderTexture->getTexture().copyToImage().saveToFile(filename)) {
+            Py_RETURN_TRUE;
+        } else {
+            Py_RETURN_FALSE;
+        }
+    }
+    
+    PyErr_SetString(PyExc_RuntimeError, "Unknown render target type");
+    return NULL;
+}
+
+// Get current mouse position
+PyObject* McRFPy_Automation::_position(PyObject* self, PyObject* args) {
+    auto engine = getGameEngine();
+    if (!engine || !engine->getRenderTargetPtr()) {
+        return Py_BuildValue("(ii)", 0, 0);
+    }
+    
+    // In headless mode, we'd need to track the simulated mouse position
+    // For now, return the actual mouse position relative to window if available
+    if (auto* window = dynamic_cast<sf::RenderWindow*>(engine->getRenderTargetPtr())) {
+        sf::Vector2i pos = sf::Mouse::getPosition(*window);
+        return Py_BuildValue("(ii)", pos.x, pos.y);
+    }
+    
+    // In headless mode, return simulated position (TODO: track this)
+    return Py_BuildValue("(ii)", 0, 0);
+}
+
+// Get screen size
+PyObject* McRFPy_Automation::_size(PyObject* self, PyObject* args) {
+    auto engine = getGameEngine();
+    if (!engine || !engine->getRenderTargetPtr()) {
+        return Py_BuildValue("(ii)", 1024, 768);  // Default size
+    }
+    
+    sf::Vector2u size = engine->getRenderTarget().getSize();
+    return Py_BuildValue("(ii)", size.x, size.y);
+}
+
+// Check if coordinates are on screen
+PyObject* McRFPy_Automation::_onScreen(PyObject* self, PyObject* args) {
+    int x, y;
+    if (!PyArg_ParseTuple(args, "ii", &x, &y)) {
+        return NULL;
+    }
+    
+    auto engine = getGameEngine();
+    if (!engine || !engine->getRenderTargetPtr()) {
+        Py_RETURN_FALSE;
+    }
+    
+    sf::Vector2u size = engine->getRenderTarget().getSize();
+    if (x >= 0 && x < (int)size.x && y >= 0 && y < (int)size.y) {
+        Py_RETURN_TRUE;
+    } else {
+        Py_RETURN_FALSE;
+    }
+}
+
+// Move mouse to position
+PyObject* McRFPy_Automation::_moveTo(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", "duration", NULL};
+    int x, y;
+    float duration = 0.0f;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|f", const_cast<char**>(kwlist), 
+                                     &x, &y, &duration)) {
+        return NULL;
+    }
+    
+    // TODO: Implement smooth movement with duration
+    injectMouseEvent(sf::Event::MouseMoved, x, y);
+    
+    if (duration > 0) {
+        sleep_ms(static_cast<int>(duration * 1000));
+    }
+    
+    Py_RETURN_NONE;
+}
+
+// Move mouse relative
+PyObject* McRFPy_Automation::_moveRel(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"xOffset", "yOffset", "duration", NULL};
+    int xOffset, yOffset;
+    float duration = 0.0f;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|f", const_cast<char**>(kwlist), 
+                                     &xOffset, &yOffset, &duration)) {
+        return NULL;
+    }
+    
+    // Get current position
+    PyObject* pos = _position(self, NULL);
+    if (!pos) return NULL;
+    
+    int currentX, currentY;
+    if (!PyArg_ParseTuple(pos, "ii", &currentX, &currentY)) {
+        Py_DECREF(pos);
+        return NULL;
+    }
+    Py_DECREF(pos);
+    
+    // Move to new position
+    injectMouseEvent(sf::Event::MouseMoved, currentX + xOffset, currentY + yOffset);
+    
+    if (duration > 0) {
+        sleep_ms(static_cast<int>(duration * 1000));
+    }
+    
+    Py_RETURN_NONE;
+}
+
+// Click implementation
+PyObject* McRFPy_Automation::_click(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", "clicks", "interval", "button", NULL};
+    int x = -1, y = -1;
+    int clicks = 1;
+    float interval = 0.0f;
+    const char* button = "left";
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iiifs", const_cast<char**>(kwlist), 
+                                     &x, &y, &clicks, &interval, &button)) {
+        return NULL;
+    }
+    
+    // If no position specified, use current position
+    if (x == -1 || y == -1) {
+        PyObject* pos = _position(self, NULL);
+        if (!pos) return NULL;
+        
+        if (!PyArg_ParseTuple(pos, "ii", &x, &y)) {
+            Py_DECREF(pos);
+            return NULL;
+        }
+        Py_DECREF(pos);
+    }
+    
+    // Determine button
+    sf::Mouse::Button sfButton = sf::Mouse::Left;
+    if (strcmp(button, "right") == 0) {
+        sfButton = sf::Mouse::Right;
+    } else if (strcmp(button, "middle") == 0) {
+        sfButton = sf::Mouse::Middle;
+    }
+    
+    // Move to position first
+    injectMouseEvent(sf::Event::MouseMoved, x, y);
+    
+    // Perform clicks
+    for (int i = 0; i < clicks; i++) {
+        if (i > 0 && interval > 0) {
+            sleep_ms(static_cast<int>(interval * 1000));
+        }
+        
+        injectMouseEvent(sf::Event::MouseButtonPressed, x, y, sfButton);
+        sleep_ms(10);  // Small delay between press and release
+        injectMouseEvent(sf::Event::MouseButtonReleased, x, y, sfButton);
+    }
+    
+    Py_RETURN_NONE;
+}
+
+// Right click
+PyObject* McRFPy_Automation::_rightClick(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", NULL};
+    int x = -1, y = -1;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", const_cast<char**>(kwlist), &x, &y)) {
+        return NULL;
+    }
+    
+    // Build new args with button="right"
+    PyObject* newKwargs = PyDict_New();
+    PyDict_SetItemString(newKwargs, "button", PyUnicode_FromString("right"));
+    if (x != -1) PyDict_SetItemString(newKwargs, "x", PyLong_FromLong(x));
+    if (y != -1) PyDict_SetItemString(newKwargs, "y", PyLong_FromLong(y));
+    
+    PyObject* result = _click(self, PyTuple_New(0), newKwargs);
+    Py_DECREF(newKwargs);
+    return result;
+}
+
+// Double click
+PyObject* McRFPy_Automation::_doubleClick(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", NULL};
+    int x = -1, y = -1;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", const_cast<char**>(kwlist), &x, &y)) {
+        return NULL;
+    }
+    
+    PyObject* newKwargs = PyDict_New();
+    PyDict_SetItemString(newKwargs, "clicks", PyLong_FromLong(2));
+    PyDict_SetItemString(newKwargs, "interval", PyFloat_FromDouble(0.1));
+    if (x != -1) PyDict_SetItemString(newKwargs, "x", PyLong_FromLong(x));
+    if (y != -1) PyDict_SetItemString(newKwargs, "y", PyLong_FromLong(y));
+    
+    PyObject* result = _click(self, PyTuple_New(0), newKwargs);
+    Py_DECREF(newKwargs);
+    return result;
+}
+
+// Type text
+PyObject* McRFPy_Automation::_typewrite(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"message", "interval", NULL};
+    const char* message;
+    float interval = 0.0f;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|f", const_cast<char**>(kwlist), 
+                                     &message, &interval)) {
+        return NULL;
+    }
+    
+    // Type each character
+    for (size_t i = 0; message[i] != '\0'; i++) {
+        if (i > 0 && interval > 0) {
+            sleep_ms(static_cast<int>(interval * 1000));
+        }
+        
+        char c = message[i];
+        
+        // Handle special characters
+        if (c == '\n') {
+            injectKeyEvent(sf::Event::KeyPressed, sf::Keyboard::Enter);
+            injectKeyEvent(sf::Event::KeyReleased, sf::Keyboard::Enter);
+        } else if (c == '\t') {
+            injectKeyEvent(sf::Event::KeyPressed, sf::Keyboard::Tab);
+            injectKeyEvent(sf::Event::KeyReleased, sf::Keyboard::Tab);
+        } else {
+            // For regular characters, send text event
+            injectTextEvent(static_cast<sf::Uint32>(c));
+        }
+    }
+    
+    Py_RETURN_NONE;
+}
+
+// Press and hold key
+PyObject* McRFPy_Automation::_keyDown(PyObject* self, PyObject* args) {
+    const char* keyName;
+    if (!PyArg_ParseTuple(args, "s", &keyName)) {
+        return NULL;
+    }
+    
+    sf::Keyboard::Key key = stringToKey(keyName);
+    if (key == sf::Keyboard::Unknown) {
+        PyErr_Format(PyExc_ValueError, "Unknown key: %s", keyName);
+        return NULL;
+    }
+    
+    injectKeyEvent(sf::Event::KeyPressed, key);
+    Py_RETURN_NONE;
+}
+
+// Release key
+PyObject* McRFPy_Automation::_keyUp(PyObject* self, PyObject* args) {
+    const char* keyName;
+    if (!PyArg_ParseTuple(args, "s", &keyName)) {
+        return NULL;
+    }
+    
+    sf::Keyboard::Key key = stringToKey(keyName);
+    if (key == sf::Keyboard::Unknown) {
+        PyErr_Format(PyExc_ValueError, "Unknown key: %s", keyName);
+        return NULL;
+    }
+    
+    injectKeyEvent(sf::Event::KeyReleased, key);
+    Py_RETURN_NONE;
+}
+
+// Hotkey combination
+PyObject* McRFPy_Automation::_hotkey(PyObject* self, PyObject* args) {
+    // Get all keys as separate arguments
+    Py_ssize_t numKeys = PyTuple_Size(args);
+    if (numKeys == 0) {
+        PyErr_SetString(PyExc_ValueError, "hotkey() requires at least one key");
+        return NULL;
+    }
+    
+    // Press all keys
+    for (Py_ssize_t i = 0; i < numKeys; i++) {
+        PyObject* keyObj = PyTuple_GetItem(args, i);
+        const char* keyName = PyUnicode_AsUTF8(keyObj);
+        if (!keyName) {
+            return NULL;
+        }
+        
+        sf::Keyboard::Key key = stringToKey(keyName);
+        if (key == sf::Keyboard::Unknown) {
+            PyErr_Format(PyExc_ValueError, "Unknown key: %s", keyName);
+            return NULL;
+        }
+        
+        injectKeyEvent(sf::Event::KeyPressed, key);
+        sleep_ms(10);  // Small delay between key presses
+    }
+    
+    // Release all keys in reverse order
+    for (Py_ssize_t i = numKeys - 1; i >= 0; i--) {
+        PyObject* keyObj = PyTuple_GetItem(args, i);
+        const char* keyName = PyUnicode_AsUTF8(keyObj);
+        
+        sf::Keyboard::Key key = stringToKey(keyName);
+        injectKeyEvent(sf::Event::KeyReleased, key);
+        sleep_ms(10);
+    }
+    
+    Py_RETURN_NONE;
+}
+
+// Scroll wheel
+PyObject* McRFPy_Automation::_scroll(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"clicks", "x", "y", NULL};
+    int clicks;
+    int x = -1, y = -1;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii", const_cast<char**>(kwlist), 
+                                     &clicks, &x, &y)) {
+        return NULL;
+    }
+    
+    // If no position specified, use current position
+    if (x == -1 || y == -1) {
+        PyObject* pos = _position(self, NULL);
+        if (!pos) return NULL;
+        
+        if (!PyArg_ParseTuple(pos, "ii", &x, &y)) {
+            Py_DECREF(pos);
+            return NULL;
+        }
+        Py_DECREF(pos);
+    }
+    
+    // Inject scroll event
+    injectMouseEvent(sf::Event::MouseWheelScrolled, clicks, y);
+    
+    Py_RETURN_NONE;
+}
+
+// Other click types using the main click function
+PyObject* McRFPy_Automation::_middleClick(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", NULL};
+    int x = -1, y = -1;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", const_cast<char**>(kwlist), &x, &y)) {
+        return NULL;
+    }
+    
+    PyObject* newKwargs = PyDict_New();
+    PyDict_SetItemString(newKwargs, "button", PyUnicode_FromString("middle"));
+    if (x != -1) PyDict_SetItemString(newKwargs, "x", PyLong_FromLong(x));
+    if (y != -1) PyDict_SetItemString(newKwargs, "y", PyLong_FromLong(y));
+    
+    PyObject* result = _click(self, PyTuple_New(0), newKwargs);
+    Py_DECREF(newKwargs);
+    return result;
+}
+
+PyObject* McRFPy_Automation::_tripleClick(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", NULL};
+    int x = -1, y = -1;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", const_cast<char**>(kwlist), &x, &y)) {
+        return NULL;
+    }
+    
+    PyObject* newKwargs = PyDict_New();
+    PyDict_SetItemString(newKwargs, "clicks", PyLong_FromLong(3));
+    PyDict_SetItemString(newKwargs, "interval", PyFloat_FromDouble(0.1));
+    if (x != -1) PyDict_SetItemString(newKwargs, "x", PyLong_FromLong(x));
+    if (y != -1) PyDict_SetItemString(newKwargs, "y", PyLong_FromLong(y));
+    
+    PyObject* result = _click(self, PyTuple_New(0), newKwargs);
+    Py_DECREF(newKwargs);
+    return result;
+}
+
+// Mouse button press/release
+PyObject* McRFPy_Automation::_mouseDown(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", "button", NULL};
+    int x = -1, y = -1;
+    const char* button = "left";
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iis", const_cast<char**>(kwlist), 
+                                     &x, &y, &button)) {
+        return NULL;
+    }
+    
+    // If no position specified, use current position
+    if (x == -1 || y == -1) {
+        PyObject* pos = _position(self, NULL);
+        if (!pos) return NULL;
+        
+        if (!PyArg_ParseTuple(pos, "ii", &x, &y)) {
+            Py_DECREF(pos);
+            return NULL;
+        }
+        Py_DECREF(pos);
+    }
+    
+    sf::Mouse::Button sfButton = sf::Mouse::Left;
+    if (strcmp(button, "right") == 0) {
+        sfButton = sf::Mouse::Right;
+    } else if (strcmp(button, "middle") == 0) {
+        sfButton = sf::Mouse::Middle;
+    }
+    
+    injectMouseEvent(sf::Event::MouseButtonPressed, x, y, sfButton);
+    Py_RETURN_NONE;
+}
+
+PyObject* McRFPy_Automation::_mouseUp(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", "button", NULL};
+    int x = -1, y = -1;
+    const char* button = "left";
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iis", const_cast<char**>(kwlist), 
+                                     &x, &y, &button)) {
+        return NULL;
+    }
+    
+    // If no position specified, use current position
+    if (x == -1 || y == -1) {
+        PyObject* pos = _position(self, NULL);
+        if (!pos) return NULL;
+        
+        if (!PyArg_ParseTuple(pos, "ii", &x, &y)) {
+            Py_DECREF(pos);
+            return NULL;
+        }
+        Py_DECREF(pos);
+    }
+    
+    sf::Mouse::Button sfButton = sf::Mouse::Left;
+    if (strcmp(button, "right") == 0) {
+        sfButton = sf::Mouse::Right;
+    } else if (strcmp(button, "middle") == 0) {
+        sfButton = sf::Mouse::Middle;
+    }
+    
+    injectMouseEvent(sf::Event::MouseButtonReleased, x, y, sfButton);
+    Py_RETURN_NONE;
+}
+
+// Drag operations
+PyObject* McRFPy_Automation::_dragTo(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"x", "y", "duration", "button", NULL};
+    int x, y;
+    float duration = 0.0f;
+    const char* button = "left";
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|fs", const_cast<char**>(kwlist), 
+                                     &x, &y, &duration, &button)) {
+        return NULL;
+    }
+    
+    // Get current position
+    PyObject* pos = _position(self, NULL);
+    if (!pos) return NULL;
+    
+    int startX, startY;
+    if (!PyArg_ParseTuple(pos, "ii", &startX, &startY)) {
+        Py_DECREF(pos);
+        return NULL;
+    }
+    Py_DECREF(pos);
+    
+    // Mouse down at current position
+    PyObject* downArgs = Py_BuildValue("(ii)", startX, startY);
+    PyObject* downKwargs = PyDict_New();
+    PyDict_SetItemString(downKwargs, "button", PyUnicode_FromString(button));
+    
+    PyObject* downResult = _mouseDown(self, downArgs, downKwargs);
+    Py_DECREF(downArgs);
+    Py_DECREF(downKwargs);
+    if (!downResult) return NULL;
+    Py_DECREF(downResult);
+    
+    // Move to target position
+    if (duration > 0) {
+        // Smooth movement
+        int steps = static_cast<int>(duration * 60);  // 60 FPS
+        for (int i = 1; i <= steps; i++) {
+            int currentX = startX + (x - startX) * i / steps;
+            int currentY = startY + (y - startY) * i / steps;
+            injectMouseEvent(sf::Event::MouseMoved, currentX, currentY);
+            sleep_ms(1000 / 60);  // 60 FPS
+        }
+    } else {
+        injectMouseEvent(sf::Event::MouseMoved, x, y);
+    }
+    
+    // Mouse up at target position
+    PyObject* upArgs = Py_BuildValue("(ii)", x, y);
+    PyObject* upKwargs = PyDict_New();
+    PyDict_SetItemString(upKwargs, "button", PyUnicode_FromString(button));
+    
+    PyObject* upResult = _mouseUp(self, upArgs, upKwargs);
+    Py_DECREF(upArgs);
+    Py_DECREF(upKwargs);
+    if (!upResult) return NULL;
+    Py_DECREF(upResult);
+    
+    Py_RETURN_NONE;
+}
+
+PyObject* McRFPy_Automation::_dragRel(PyObject* self, PyObject* args, PyObject* kwargs) {
+    static const char* kwlist[] = {"xOffset", "yOffset", "duration", "button", NULL};
+    int xOffset, yOffset;
+    float duration = 0.0f;
+    const char* button = "left";
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii|fs", const_cast<char**>(kwlist), 
+                                     &xOffset, &yOffset, &duration, &button)) {
+        return NULL;
+    }
+    
+    // Get current position
+    PyObject* pos = _position(self, NULL);
+    if (!pos) return NULL;
+    
+    int currentX, currentY;
+    if (!PyArg_ParseTuple(pos, "ii", &currentX, &currentY)) {
+        Py_DECREF(pos);
+        return NULL;
+    }
+    Py_DECREF(pos);
+    
+    // Call dragTo with absolute position
+    PyObject* dragArgs = Py_BuildValue("(ii)", currentX + xOffset, currentY + yOffset);
+    PyObject* dragKwargs = PyDict_New();
+    PyDict_SetItemString(dragKwargs, "duration", PyFloat_FromDouble(duration));
+    PyDict_SetItemString(dragKwargs, "button", PyUnicode_FromString(button));
+    
+    PyObject* result = _dragTo(self, dragArgs, dragKwargs);
+    Py_DECREF(dragArgs);
+    Py_DECREF(dragKwargs);
+    
+    return result;
+}
+
+// Method definitions for the automation module
+static PyMethodDef automationMethods[] = {
+    {"screenshot", McRFPy_Automation::_screenshot, METH_VARARGS, 
+     "screenshot(filename) - Save a screenshot to the specified file"},
+    
+    {"position", McRFPy_Automation::_position, METH_NOARGS, 
+     "position() - Get current mouse position as (x, y) tuple"},
+    {"size", McRFPy_Automation::_size, METH_NOARGS, 
+     "size() - Get screen size as (width, height) tuple"},
+    {"onScreen", McRFPy_Automation::_onScreen, METH_VARARGS, 
+     "onScreen(x, y) - Check if coordinates are within screen bounds"},
+    
+    {"moveTo", (PyCFunction)McRFPy_Automation::_moveTo, METH_VARARGS | METH_KEYWORDS, 
+     "moveTo(x, y, duration=0.0) - Move mouse to absolute position"},
+    {"moveRel", (PyCFunction)McRFPy_Automation::_moveRel, METH_VARARGS | METH_KEYWORDS, 
+     "moveRel(xOffset, yOffset, duration=0.0) - Move mouse relative to current position"},
+    {"dragTo", (PyCFunction)McRFPy_Automation::_dragTo, METH_VARARGS | METH_KEYWORDS, 
+     "dragTo(x, y, duration=0.0, button='left') - Drag mouse to position"},
+    {"dragRel", (PyCFunction)McRFPy_Automation::_dragRel, METH_VARARGS | METH_KEYWORDS, 
+     "dragRel(xOffset, yOffset, duration=0.0, button='left') - Drag mouse relative to current position"},
+    
+    {"click", (PyCFunction)McRFPy_Automation::_click, METH_VARARGS | METH_KEYWORDS, 
+     "click(x=None, y=None, clicks=1, interval=0.0, button='left') - Click at position"},
+    {"rightClick", (PyCFunction)McRFPy_Automation::_rightClick, METH_VARARGS | METH_KEYWORDS, 
+     "rightClick(x=None, y=None) - Right click at position"},
+    {"middleClick", (PyCFunction)McRFPy_Automation::_middleClick, METH_VARARGS | METH_KEYWORDS, 
+     "middleClick(x=None, y=None) - Middle click at position"},
+    {"doubleClick", (PyCFunction)McRFPy_Automation::_doubleClick, METH_VARARGS | METH_KEYWORDS, 
+     "doubleClick(x=None, y=None) - Double click at position"},
+    {"tripleClick", (PyCFunction)McRFPy_Automation::_tripleClick, METH_VARARGS | METH_KEYWORDS, 
+     "tripleClick(x=None, y=None) - Triple click at position"},
+    {"scroll", (PyCFunction)McRFPy_Automation::_scroll, METH_VARARGS | METH_KEYWORDS, 
+     "scroll(clicks, x=None, y=None) - Scroll wheel at position"},
+    {"mouseDown", (PyCFunction)McRFPy_Automation::_mouseDown, METH_VARARGS | METH_KEYWORDS, 
+     "mouseDown(x=None, y=None, button='left') - Press mouse button"},
+    {"mouseUp", (PyCFunction)McRFPy_Automation::_mouseUp, METH_VARARGS | METH_KEYWORDS, 
+     "mouseUp(x=None, y=None, button='left') - Release mouse button"},
+    
+    {"typewrite", (PyCFunction)McRFPy_Automation::_typewrite, METH_VARARGS | METH_KEYWORDS, 
+     "typewrite(message, interval=0.0) - Type text with optional interval between keystrokes"},
+    {"hotkey", McRFPy_Automation::_hotkey, METH_VARARGS, 
+     "hotkey(*keys) - Press a hotkey combination (e.g., hotkey('ctrl', 'c'))"},
+    {"keyDown", McRFPy_Automation::_keyDown, METH_VARARGS, 
+     "keyDown(key) - Press and hold a key"},
+    {"keyUp", McRFPy_Automation::_keyUp, METH_VARARGS, 
+     "keyUp(key) - Release a key"},
+    
+    {NULL, NULL, 0, NULL}
+};
+
+// Module definition for mcrfpy.automation
+static PyModuleDef automationModule = {
+    PyModuleDef_HEAD_INIT,
+    "mcrfpy.automation",
+    "Automation API for McRogueFace - PyAutoGUI-compatible interface",
+    -1,
+    automationMethods
+};
+
+// Initialize automation submodule
+PyObject* McRFPy_Automation::init_automation_module() {
+    PyObject* module = PyModule_Create(&automationModule);
+    if (module == NULL) {
+        return NULL;
+    }
+    
+    return module;
+}

src/McRFPy_Automation.h

@@ -0,0 +1,56 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include <SFML/Graphics.hpp>
+#include <SFML/Window.hpp>
+#include <string>
+#include <chrono>
+#include <thread>
+
+class GameEngine;
+
+class McRFPy_Automation {
+public:
+    // Initialize the automation submodule
+    static PyObject* init_automation_module();
+    
+    // Screenshot functionality
+    static PyObject* _screenshot(PyObject* self, PyObject* args);
+    
+    // Mouse position and screen info
+    static PyObject* _position(PyObject* self, PyObject* args);
+    static PyObject* _size(PyObject* self, PyObject* args);
+    static PyObject* _onScreen(PyObject* self, PyObject* args);
+    
+    // Mouse movement
+    static PyObject* _moveTo(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _moveRel(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _dragTo(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _dragRel(PyObject* self, PyObject* args, PyObject* kwargs);
+    
+    // Mouse clicks
+    static PyObject* _click(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _rightClick(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _middleClick(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _doubleClick(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _tripleClick(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _scroll(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _mouseDown(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _mouseUp(PyObject* self, PyObject* args, PyObject* kwargs);
+    
+    // Keyboard
+    static PyObject* _typewrite(PyObject* self, PyObject* args, PyObject* kwargs);
+    static PyObject* _hotkey(PyObject* self, PyObject* args);
+    static PyObject* _keyDown(PyObject* self, PyObject* args);
+    static PyObject* _keyUp(PyObject* self, PyObject* args);
+    
+    // Helper functions
+    static void injectMouseEvent(sf::Event::EventType type, int x, int y, sf::Mouse::Button button = sf::Mouse::Left);
+    static void injectKeyEvent(sf::Event::EventType type, sf::Keyboard::Key key);
+    static void injectTextEvent(sf::Uint32 unicode);
+    static sf::Keyboard::Key stringToKey(const std::string& keyName);
+    static void sleep_ms(int milliseconds);
+    
+private:
+    static GameEngine* getGameEngine();
+};

src/McRFPy_Libtcod.cpp

@@ -0,0 +1,324 @@
+#include "McRFPy_Libtcod.h"
+#include "McRFPy_API.h"
+#include "UIGrid.h"
+#include <vector>
+
+// Helper function to get UIGrid from Python object
+static UIGrid* get_grid_from_pyobject(PyObject* obj) {
+    auto grid_type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Grid");
+    if (!grid_type) {
+        PyErr_SetString(PyExc_RuntimeError, "Could not find Grid type");
+        return nullptr;
+    }
+    
+    if (!PyObject_IsInstance(obj, (PyObject*)grid_type)) {
+        Py_DECREF(grid_type);
+        PyErr_SetString(PyExc_TypeError, "First argument must be a Grid object");
+        return nullptr;
+    }
+    
+    Py_DECREF(grid_type);
+    PyUIGridObject* pygrid = (PyUIGridObject*)obj;
+    return pygrid->data.get();
+}
+
+// Field of View computation
+static PyObject* McRFPy_Libtcod::compute_fov(PyObject* self, PyObject* args) {
+    PyObject* grid_obj;
+    int x, y, radius;
+    int light_walls = 1;
+    int algorithm = FOV_BASIC;
+    
+    if (!PyArg_ParseTuple(args, "Oiii|ii", &grid_obj, &x, &y, &radius, 
+                         &light_walls, &algorithm)) {
+        return NULL;
+    }
+    
+    UIGrid* grid = get_grid_from_pyobject(grid_obj);
+    if (!grid) return NULL;
+    
+    // Compute FOV using grid's method
+    grid->computeFOV(x, y, radius, light_walls, (TCOD_fov_algorithm_t)algorithm);
+    
+    // Return list of visible cells
+    PyObject* visible_list = PyList_New(0);
+    for (int gy = 0; gy < grid->grid_y; gy++) {
+        for (int gx = 0; gx < grid->grid_x; gx++) {
+            if (grid->isInFOV(gx, gy)) {
+                PyObject* pos = Py_BuildValue("(ii)", gx, gy);
+                PyList_Append(visible_list, pos);
+                Py_DECREF(pos);
+            }
+        }
+    }
+    
+    return visible_list;
+}
+
+// A* Pathfinding
+static PyObject* McRFPy_Libtcod::find_path(PyObject* self, PyObject* args) {
+    PyObject* grid_obj;
+    int x1, y1, x2, y2;
+    float diagonal_cost = 1.41f;
+    
+    if (!PyArg_ParseTuple(args, "Oiiii|f", &grid_obj, &x1, &y1, &x2, &y2, &diagonal_cost)) {
+        return NULL;
+    }
+    
+    UIGrid* grid = get_grid_from_pyobject(grid_obj);
+    if (!grid) return NULL;
+    
+    // Get path from grid
+    std::vector<std::pair<int, int>> path = grid->findPath(x1, y1, x2, y2, diagonal_cost);
+    
+    // Convert to Python list
+    PyObject* path_list = PyList_New(path.size());
+    for (size_t i = 0; i < path.size(); i++) {
+        PyObject* pos = Py_BuildValue("(ii)", path[i].first, path[i].second);
+        PyList_SetItem(path_list, i, pos);  // steals reference
+    }
+    
+    return path_list;
+}
+
+// Line drawing algorithm
+static PyObject* McRFPy_Libtcod::line(PyObject* self, PyObject* args) {
+    int x1, y1, x2, y2;
+    
+    if (!PyArg_ParseTuple(args, "iiii", &x1, &y1, &x2, &y2)) {
+        return NULL;
+    }
+    
+    // Use TCOD's line algorithm
+    TCODLine::init(x1, y1, x2, y2);
+    
+    PyObject* line_list = PyList_New(0);
+    int x, y;
+    
+    // Step through line
+    while (!TCODLine::step(&x, &y)) {
+        PyObject* pos = Py_BuildValue("(ii)", x, y);
+        PyList_Append(line_list, pos);
+        Py_DECREF(pos);
+    }
+    
+    return line_list;
+}
+
+// Line iterator (generator-like function)
+static PyObject* McRFPy_Libtcod::line_iter(PyObject* self, PyObject* args) {
+    // For simplicity, just call line() for now
+    // A proper implementation would create an iterator object
+    return line(self, args);
+}
+
+// Dijkstra pathfinding
+static PyObject* McRFPy_Libtcod::dijkstra_new(PyObject* self, PyObject* args) {
+    PyObject* grid_obj;
+    float diagonal_cost = 1.41f;
+    
+    if (!PyArg_ParseTuple(args, "O|f", &grid_obj, &diagonal_cost)) {
+        return NULL;
+    }
+    
+    UIGrid* grid = get_grid_from_pyobject(grid_obj);
+    if (!grid) return NULL;
+    
+    // For now, just return the grid object since Dijkstra is part of the grid
+    Py_INCREF(grid_obj);
+    return grid_obj;
+}
+
+static PyObject* McRFPy_Libtcod::dijkstra_compute(PyObject* self, PyObject* args) {
+    PyObject* grid_obj;
+    int root_x, root_y;
+    
+    if (!PyArg_ParseTuple(args, "Oii", &grid_obj, &root_x, &root_y)) {
+        return NULL;
+    }
+    
+    UIGrid* grid = get_grid_from_pyobject(grid_obj);
+    if (!grid) return NULL;
+    
+    grid->computeDijkstra(root_x, root_y);
+    Py_RETURN_NONE;
+}
+
+static PyObject* McRFPy_Libtcod::dijkstra_get_distance(PyObject* self, PyObject* args) {
+    PyObject* grid_obj;
+    int x, y;
+    
+    if (!PyArg_ParseTuple(args, "Oii", &grid_obj, &x, &y)) {
+        return NULL;
+    }
+    
+    UIGrid* grid = get_grid_from_pyobject(grid_obj);
+    if (!grid) return NULL;
+    
+    float distance = grid->getDijkstraDistance(x, y);
+    if (distance < 0) {
+        Py_RETURN_NONE;
+    }
+    
+    return PyFloat_FromDouble(distance);
+}
+
+static PyObject* McRFPy_Libtcod::dijkstra_path_to(PyObject* self, PyObject* args) {
+    PyObject* grid_obj;
+    int x, y;
+    
+    if (!PyArg_ParseTuple(args, "Oii", &grid_obj, &x, &y)) {
+        return NULL;
+    }
+    
+    UIGrid* grid = get_grid_from_pyobject(grid_obj);
+    if (!grid) return NULL;
+    
+    std::vector<std::pair<int, int>> path = grid->getDijkstraPath(x, y);
+    
+    PyObject* path_list = PyList_New(path.size());
+    for (size_t i = 0; i < path.size(); i++) {
+        PyObject* pos = Py_BuildValue("(ii)", path[i].first, path[i].second);
+        PyList_SetItem(path_list, i, pos);  // steals reference
+    }
+    
+    return path_list;
+}
+
+// Add FOV algorithm constants to module
+static PyObject* McRFPy_Libtcod::add_fov_constants(PyObject* module) {
+    // FOV algorithms
+    PyModule_AddIntConstant(module, "FOV_BASIC", FOV_BASIC);
+    PyModule_AddIntConstant(module, "FOV_DIAMOND", FOV_DIAMOND);
+    PyModule_AddIntConstant(module, "FOV_SHADOW", FOV_SHADOW);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_0", FOV_PERMISSIVE_0);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_1", FOV_PERMISSIVE_1);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_2", FOV_PERMISSIVE_2);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_3", FOV_PERMISSIVE_3);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_4", FOV_PERMISSIVE_4);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_5", FOV_PERMISSIVE_5);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_6", FOV_PERMISSIVE_6);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_7", FOV_PERMISSIVE_7);
+    PyModule_AddIntConstant(module, "FOV_PERMISSIVE_8", FOV_PERMISSIVE_8);
+    PyModule_AddIntConstant(module, "FOV_RESTRICTIVE", FOV_RESTRICTIVE);
+    PyModule_AddIntConstant(module, "FOV_SYMMETRIC_SHADOWCAST", FOV_SYMMETRIC_SHADOWCAST);
+    
+    return module;
+}
+
+// Method definitions
+static PyMethodDef libtcodMethods[] = {
+    {"compute_fov", McRFPy_Libtcod::compute_fov, METH_VARARGS, 
+     "compute_fov(grid, x, y, radius, light_walls=True, algorithm=FOV_BASIC)\n\n"
+     "Compute field of view from a position.\n\n"
+     "Args:\n"
+     "    grid: Grid object to compute FOV on\n"
+     "    x, y: Origin position\n"
+     "    radius: Maximum sight radius\n"
+     "    light_walls: Whether walls are lit when in FOV\n"
+     "    algorithm: FOV algorithm to use (FOV_BASIC, FOV_SHADOW, etc.)\n\n"
+     "Returns:\n"
+     "    List of (x, y) tuples for visible cells"},
+     
+    {"find_path", McRFPy_Libtcod::find_path, METH_VARARGS,
+     "find_path(grid, x1, y1, x2, y2, diagonal_cost=1.41)\n\n"
+     "Find shortest path between two points using A*.\n\n"
+     "Args:\n"
+     "    grid: Grid object to pathfind on\n"
+     "    x1, y1: Starting position\n"
+     "    x2, y2: Target position\n"
+     "    diagonal_cost: Cost of diagonal movement\n\n"
+     "Returns:\n"
+     "    List of (x, y) tuples representing the path, or empty list if no path exists"},
+     
+    {"line", McRFPy_Libtcod::line, METH_VARARGS,
+     "line(x1, y1, x2, y2)\n\n"
+     "Get cells along a line using Bresenham's algorithm.\n\n"
+     "Args:\n"
+     "    x1, y1: Starting position\n"
+     "    x2, y2: Ending position\n\n"
+     "Returns:\n"
+     "    List of (x, y) tuples along the line"},
+     
+    {"line_iter", McRFPy_Libtcod::line_iter, METH_VARARGS,
+     "line_iter(x1, y1, x2, y2)\n\n"
+     "Iterate over cells along a line.\n\n"
+     "Args:\n"
+     "    x1, y1: Starting position\n"
+     "    x2, y2: Ending position\n\n"
+     "Returns:\n"
+     "    Iterator of (x, y) tuples along the line"},
+     
+    {"dijkstra_new", McRFPy_Libtcod::dijkstra_new, METH_VARARGS,
+     "dijkstra_new(grid, diagonal_cost=1.41)\n\n"
+     "Create a Dijkstra pathfinding context for a grid.\n\n"
+     "Args:\n"
+     "    grid: Grid object to use for pathfinding\n"
+     "    diagonal_cost: Cost of diagonal movement\n\n"
+     "Returns:\n"
+     "    Grid object configured for Dijkstra pathfinding"},
+     
+    {"dijkstra_compute", McRFPy_Libtcod::dijkstra_compute, METH_VARARGS,
+     "dijkstra_compute(grid, root_x, root_y)\n\n"
+     "Compute Dijkstra distance map from root position.\n\n"
+     "Args:\n"
+     "    grid: Grid object with Dijkstra context\n"
+     "    root_x, root_y: Root position to compute distances from"},
+     
+    {"dijkstra_get_distance", McRFPy_Libtcod::dijkstra_get_distance, METH_VARARGS,
+     "dijkstra_get_distance(grid, x, y)\n\n"
+     "Get distance from root to a position.\n\n"
+     "Args:\n"
+     "    grid: Grid object with computed Dijkstra map\n"
+     "    x, y: Position to get distance for\n\n"
+     "Returns:\n"
+     "    Float distance or None if position is invalid/unreachable"},
+     
+    {"dijkstra_path_to", McRFPy_Libtcod::dijkstra_path_to, METH_VARARGS,
+     "dijkstra_path_to(grid, x, y)\n\n"
+     "Get shortest path from position to Dijkstra root.\n\n"
+     "Args:\n"
+     "    grid: Grid object with computed Dijkstra map\n"
+     "    x, y: Starting position\n\n"
+     "Returns:\n"
+     "    List of (x, y) tuples representing the path to root"},
+     
+    {NULL, NULL, 0, NULL}
+};
+
+// Module definition
+static PyModuleDef libtcodModule = {
+    PyModuleDef_HEAD_INIT,
+    "mcrfpy.libtcod",
+    "TCOD-compatible algorithms for field of view, pathfinding, and line drawing.\n\n"
+    "This module provides access to TCOD's algorithms integrated with McRogueFace grids.\n"
+    "Unlike the original TCOD, these functions work directly with Grid objects.\n\n"
+    "FOV Algorithms:\n"
+    "    FOV_BASIC - Basic circular FOV\n"
+    "    FOV_SHADOW - Shadow casting (recommended)\n"
+    "    FOV_DIAMOND - Diamond-shaped FOV\n"
+    "    FOV_PERMISSIVE_0 through FOV_PERMISSIVE_8 - Permissive variants\n"
+    "    FOV_RESTRICTIVE - Most restrictive FOV\n"
+    "    FOV_SYMMETRIC_SHADOWCAST - Symmetric shadow casting\n\n"
+    "Example:\n"
+    "    import mcrfpy\n"
+    "    from mcrfpy import libtcod\n\n"
+    "    grid = mcrfpy.Grid(50, 50)\n"
+    "    visible = libtcod.compute_fov(grid, 25, 25, 10)\n"
+    "    path = libtcod.find_path(grid, 0, 0, 49, 49)",
+    -1,
+    libtcodMethods
+};
+
+// Module initialization
+PyObject* McRFPy_Libtcod::init_libtcod_module() {
+    PyObject* m = PyModule_Create(&libtcodModule);
+    if (m == NULL) {
+        return NULL;
+    }
+    
+    // Add FOV algorithm constants
+    add_fov_constants(m);
+    
+    return m;
+}

src/McRFPy_Libtcod.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include <libtcod.h>
+
+namespace McRFPy_Libtcod
+{
+    // Field of View algorithms
+    static PyObject* compute_fov(PyObject* self, PyObject* args);
+    
+    // Pathfinding  
+    static PyObject* find_path(PyObject* self, PyObject* args);
+    static PyObject* dijkstra_new(PyObject* self, PyObject* args);
+    static PyObject* dijkstra_compute(PyObject* self, PyObject* args);
+    static PyObject* dijkstra_get_distance(PyObject* self, PyObject* args);
+    static PyObject* dijkstra_path_to(PyObject* self, PyObject* args);
+    
+    // Line algorithms
+    static PyObject* line(PyObject* self, PyObject* args);
+    static PyObject* line_iter(PyObject* self, PyObject* args);
+    
+    // FOV algorithm constants
+    static PyObject* add_fov_constants(PyObject* module);
+    
+    // Module initialization
+    PyObject* init_libtcod_module();
+}

src/McRogueFaceConfig.h

@@ -0,0 +1,33 @@
+#ifndef MCROGUEFACE_CONFIG_H
+#define MCROGUEFACE_CONFIG_H
+
+#include <string>
+#include <vector>
+#include <filesystem>
+
+struct McRogueFaceConfig {
+    // McRogueFace specific
+    bool headless = false;
+    bool audio_enabled = true;
+    
+    // Python interpreter emulation
+    bool python_mode = false;
+    std::string python_command;      // -c command
+    std::string python_module;       // -m module
+    bool interactive_mode = false;   // -i flag
+    bool show_version = false;       // -V flag
+    bool show_help = false;          // -h flag
+    
+    // Script execution
+    std::filesystem::path script_path;
+    std::vector<std::string> script_args;
+    
+    // Scripts to execute before main script (--exec flag)
+    std::vector<std::filesystem::path> exec_scripts;
+    
+    // Screenshot functionality for headless mode
+    std::string screenshot_path;
+    bool take_screenshot = false;
+};
+
+#endif // MCROGUEFACE_CONFIG_H

src/PyAnimation.cpp

@@ -0,0 +1,273 @@
+#include "PyAnimation.h"
+#include "McRFPy_API.h"
+#include "UIDrawable.h"
+#include "UIFrame.h"
+#include "UICaption.h"
+#include "UISprite.h"
+#include "UIGrid.h"
+#include "UIEntity.h"
+#include "UI.h"  // For the PyTypeObject definitions
+#include <cstring>
+
+PyObject* PyAnimation::create(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+    PyAnimationObject* self = (PyAnimationObject*)type->tp_alloc(type, 0);
+    if (self != NULL) {
+        // Will be initialized in init
+    }
+    return (PyObject*)self;
+}
+
+int PyAnimation::init(PyAnimationObject* self, PyObject* args, PyObject* kwds) {
+    static const char* keywords[] = {"property", "target", "duration", "easing", "delta", "callback", nullptr};
+    
+    const char* property_name;
+    PyObject* target_value;
+    float duration;
+    const char* easing_name = "linear";
+    int delta = 0;
+    PyObject* callback = nullptr;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "sOf|spO", const_cast<char**>(keywords),
+                                      &property_name, &target_value, &duration, &easing_name, &delta, &callback)) {
+        return -1;
+    }
+    
+    // Validate callback is callable if provided
+    if (callback && callback != Py_None && !PyCallable_Check(callback)) {
+        PyErr_SetString(PyExc_TypeError, "callback must be callable");
+        return -1;
+    }
+    
+    // Convert None to nullptr for C++
+    if (callback == Py_None) {
+        callback = nullptr;
+    }
+    
+    // Convert Python target value to AnimationValue
+    AnimationValue animValue;
+    
+    if (PyFloat_Check(target_value)) {
+        animValue = static_cast<float>(PyFloat_AsDouble(target_value));
+    }
+    else if (PyLong_Check(target_value)) {
+        animValue = static_cast<int>(PyLong_AsLong(target_value));
+    }
+    else if (PyList_Check(target_value)) {
+        // List of integers for sprite animation
+        std::vector<int> indices;
+        Py_ssize_t size = PyList_Size(target_value);
+        for (Py_ssize_t i = 0; i < size; i++) {
+            PyObject* item = PyList_GetItem(target_value, i);
+            if (PyLong_Check(item)) {
+                indices.push_back(PyLong_AsLong(item));
+            } else {
+                PyErr_SetString(PyExc_TypeError, "Sprite animation list must contain only integers");
+                return -1;
+            }
+        }
+        animValue = indices;
+    }
+    else if (PyTuple_Check(target_value)) {
+        Py_ssize_t size = PyTuple_Size(target_value);
+        if (size == 2) {
+            // Vector2f
+            float x = PyFloat_AsDouble(PyTuple_GetItem(target_value, 0));
+            float y = PyFloat_AsDouble(PyTuple_GetItem(target_value, 1));
+            animValue = sf::Vector2f(x, y);
+        }
+        else if (size == 3 || size == 4) {
+            // Color (RGB or RGBA)
+            int r = PyLong_AsLong(PyTuple_GetItem(target_value, 0));
+            int g = PyLong_AsLong(PyTuple_GetItem(target_value, 1));
+            int b = PyLong_AsLong(PyTuple_GetItem(target_value, 2));
+            int a = size == 4 ? PyLong_AsLong(PyTuple_GetItem(target_value, 3)) : 255;
+            animValue = sf::Color(r, g, b, a);
+        }
+        else {
+            PyErr_SetString(PyExc_ValueError, "Tuple must have 2 elements (vector) or 3-4 elements (color)");
+            return -1;
+        }
+    }
+    else if (PyUnicode_Check(target_value)) {
+        // String for text animation
+        const char* str = PyUnicode_AsUTF8(target_value);
+        animValue = std::string(str);
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "Target value must be float, int, list, tuple, or string");
+        return -1;
+    }
+    
+    // Get easing function
+    EasingFunction easingFunc = EasingFunctions::getByName(easing_name);
+    
+    // Create the Animation
+    self->data = std::make_shared<Animation>(property_name, animValue, duration, easingFunc, delta != 0, callback);
+    
+    return 0;
+}
+
+void PyAnimation::dealloc(PyAnimationObject* self) {
+    self->data.reset();
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+PyObject* PyAnimation::get_property(PyAnimationObject* self, void* closure) {
+    return PyUnicode_FromString(self->data->getTargetProperty().c_str());
+}
+
+PyObject* PyAnimation::get_duration(PyAnimationObject* self, void* closure) {
+    return PyFloat_FromDouble(self->data->getDuration());
+}
+
+PyObject* PyAnimation::get_elapsed(PyAnimationObject* self, void* closure) {
+    return PyFloat_FromDouble(self->data->getElapsed());
+}
+
+PyObject* PyAnimation::get_is_complete(PyAnimationObject* self, void* closure) {
+    return PyBool_FromLong(self->data->isComplete());
+}
+
+PyObject* PyAnimation::get_is_delta(PyAnimationObject* self, void* closure) {
+    return PyBool_FromLong(self->data->isDelta());
+}
+
+PyObject* PyAnimation::start(PyAnimationObject* self, PyObject* args) {
+    PyObject* target_obj;
+    if (!PyArg_ParseTuple(args, "O", &target_obj)) {
+        return NULL;
+    }
+    
+    // Check type by comparing type names
+    const char* type_name = Py_TYPE(target_obj)->tp_name;
+    
+    if (strcmp(type_name, "mcrfpy.Frame") == 0) {
+        PyUIFrameObject* frame = (PyUIFrameObject*)target_obj;
+        if (frame->data) {
+            self->data->start(frame->data);
+            AnimationManager::getInstance().addAnimation(self->data);
+        }
+    }
+    else if (strcmp(type_name, "mcrfpy.Caption") == 0) {
+        PyUICaptionObject* caption = (PyUICaptionObject*)target_obj;
+        if (caption->data) {
+            self->data->start(caption->data);
+            AnimationManager::getInstance().addAnimation(self->data);
+        }
+    }
+    else if (strcmp(type_name, "mcrfpy.Sprite") == 0) {
+        PyUISpriteObject* sprite = (PyUISpriteObject*)target_obj;
+        if (sprite->data) {
+            self->data->start(sprite->data);
+            AnimationManager::getInstance().addAnimation(self->data);
+        }
+    }
+    else if (strcmp(type_name, "mcrfpy.Grid") == 0) {
+        PyUIGridObject* grid = (PyUIGridObject*)target_obj;
+        if (grid->data) {
+            self->data->start(grid->data);
+            AnimationManager::getInstance().addAnimation(self->data);
+        }
+    }
+    else if (strcmp(type_name, "mcrfpy.Entity") == 0) {
+        // Special handling for Entity since it doesn't inherit from UIDrawable
+        PyUIEntityObject* entity = (PyUIEntityObject*)target_obj;
+        if (entity->data) {
+            self->data->startEntity(entity->data);
+            AnimationManager::getInstance().addAnimation(self->data);
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "Target must be a Frame, Caption, Sprite, Grid, or Entity");
+        return NULL;
+    }
+    
+    Py_RETURN_NONE;
+}
+
+PyObject* PyAnimation::update(PyAnimationObject* self, PyObject* args) {
+    float deltaTime;
+    if (!PyArg_ParseTuple(args, "f", &deltaTime)) {
+        return NULL;
+    }
+    
+    bool still_running = self->data->update(deltaTime);
+    return PyBool_FromLong(still_running);
+}
+
+PyObject* PyAnimation::get_current_value(PyAnimationObject* self, PyObject* args) {
+    AnimationValue value = self->data->getCurrentValue();
+    
+    // Convert AnimationValue back to Python
+    return std::visit([](const auto& val) -> PyObject* {
+        using T = std::decay_t<decltype(val)>;
+        
+        if constexpr (std::is_same_v<T, float>) {
+            return PyFloat_FromDouble(val);
+        }
+        else if constexpr (std::is_same_v<T, int>) {
+            return PyLong_FromLong(val);
+        }
+        else if constexpr (std::is_same_v<T, std::vector<int>>) {
+            // This shouldn't happen as we interpolate to int
+            return PyLong_FromLong(0);
+        }
+        else if constexpr (std::is_same_v<T, sf::Color>) {
+            return Py_BuildValue("(iiii)", val.r, val.g, val.b, val.a);
+        }
+        else if constexpr (std::is_same_v<T, sf::Vector2f>) {
+            return Py_BuildValue("(ff)", val.x, val.y);
+        }
+        else if constexpr (std::is_same_v<T, std::string>) {
+            return PyUnicode_FromString(val.c_str());
+        }
+        
+        Py_RETURN_NONE;
+    }, value);
+}
+
+PyObject* PyAnimation::complete(PyAnimationObject* self, PyObject* args) {
+    if (self->data) {
+        self->data->complete();
+    }
+    Py_RETURN_NONE;
+}
+
+PyObject* PyAnimation::has_valid_target(PyAnimationObject* self, PyObject* args) {
+    if (self->data && self->data->hasValidTarget()) {
+        Py_RETURN_TRUE;
+    }
+    Py_RETURN_FALSE;
+}
+
+PyGetSetDef PyAnimation::getsetters[] = {
+    {"property", (getter)get_property, NULL, "Target property name", NULL},
+    {"duration", (getter)get_duration, NULL, "Animation duration in seconds", NULL},
+    {"elapsed", (getter)get_elapsed, NULL, "Elapsed time in seconds", NULL},
+    {"is_complete", (getter)get_is_complete, NULL, "Whether animation is complete", NULL},
+    {"is_delta", (getter)get_is_delta, NULL, "Whether animation uses delta mode", NULL},
+    {NULL}
+};
+
+PyMethodDef PyAnimation::methods[] = {
+    {"start", (PyCFunction)start, METH_VARARGS,
+     "start(target) -> None\n\n"
+     "Start the animation on a target UI element.\n\n"
+     "Args:\n"
+     "    target: The UI element to animate (Frame, Caption, Sprite, Grid, or Entity)\n\n"
+     "Note:\n"
+     "    The animation will automatically stop if the target is destroyed."},
+    {"update", (PyCFunction)update, METH_VARARGS,
+     "Update the animation by deltaTime (returns True if still running)"},
+    {"get_current_value", (PyCFunction)get_current_value, METH_NOARGS,
+     "Get the current interpolated value"},
+    {"complete", (PyCFunction)complete, METH_NOARGS,
+     "complete() -> None\n\n"
+     "Complete the animation immediately by jumping to the final value."},
+    {"hasValidTarget", (PyCFunction)has_valid_target, METH_NOARGS,
+     "hasValidTarget() -> bool\n\n"
+     "Check if the animation still has a valid target.\n\n"
+     "Returns:\n"
+     "    True if the target still exists, False if it was destroyed."},
+    {NULL}
+};

src/PyAnimation.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "Common.h"
+#include "Python.h"
+#include "structmember.h"
+#include "Animation.h"
+#include <memory>
+
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<Animation> data;
+} PyAnimationObject;
+
+class PyAnimation {
+public:
+    static PyObject* create(PyTypeObject* type, PyObject* args, PyObject* kwds);
+    static int init(PyAnimationObject* self, PyObject* args, PyObject* kwds);
+    static void dealloc(PyAnimationObject* self);
+    
+    // Properties
+    static PyObject* get_property(PyAnimationObject* self, void* closure);
+    static PyObject* get_duration(PyAnimationObject* self, void* closure);
+    static PyObject* get_elapsed(PyAnimationObject* self, void* closure);
+    static PyObject* get_is_complete(PyAnimationObject* self, void* closure);
+    static PyObject* get_is_delta(PyAnimationObject* self, void* closure);
+    
+    // Methods
+    static PyObject* start(PyAnimationObject* self, PyObject* args);
+    static PyObject* update(PyAnimationObject* self, PyObject* args);
+    static PyObject* get_current_value(PyAnimationObject* self, PyObject* args);
+    static PyObject* complete(PyAnimationObject* self, PyObject* args);
+    static PyObject* has_valid_target(PyAnimationObject* self, PyObject* args);
+    
+    static PyGetSetDef getsetters[];
+    static PyMethodDef methods[];
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PyAnimationType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .tp_name = "mcrfpy.Animation",
+        .tp_basicsize = sizeof(PyAnimationObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)PyAnimation::dealloc,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+        .tp_doc = PyDoc_STR("Animation object for animating UI properties"),
+        .tp_methods = PyAnimation::methods,
+        .tp_getset = PyAnimation::getsetters,
+        .tp_init = (initproc)PyAnimation::init,
+        .tp_new = PyAnimation::create,
+    };
+}

src/PyCallable.cpp

@@ -5,6 +5,21 @@ PyCallable::PyCallable(PyObject* _target)
     target = Py_XNewRef(_target);
 }
 
+PyCallable::PyCallable(const PyCallable& other)
+{
+    target = Py_XNewRef(other.target);
+}
+
+PyCallable& PyCallable::operator=(const PyCallable& other)
+{
+    if (this != &other) {
+        PyObject* old_target = target;
+        target = Py_XNewRef(other.target);
+        Py_XDECREF(old_target);
+    }
+    return *this;
+}
+
 PyCallable::~PyCallable()
 {
     if (target)
@@ -16,49 +31,11 @@ PyObject* PyCallable::call(PyObject* args, PyObject* kwargs)
     return PyObject_Call(target, args, kwargs);
 }
 
-bool PyCallable::isNone()
+bool PyCallable::isNone() const
 {
     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)

src/PyCallable.h

@@ -6,24 +6,15 @@ class PyCallable
 {
 protected:
     PyObject* target;
+    
+public:
     PyCallable(PyObject*);
+    PyCallable(const PyCallable& other);
+    PyCallable& operator=(const PyCallable& other);
     ~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();
+    bool isNone() const;
+    PyObject* borrow() const { return target; }
 };
 
 class PyClickCallable: public PyCallable
@@ -33,6 +24,11 @@ public:
     PyObject* borrow();
     PyClickCallable(PyObject*);
     PyClickCallable();
+    PyClickCallable(const PyClickCallable& other) : PyCallable(other) {}
+    PyClickCallable& operator=(const PyClickCallable& other) { 
+        PyCallable::operator=(other); 
+        return *this; 
+    }
 };
 
 class PyKeyCallable: public PyCallable

src/PyColor.cpp

@@ -0,0 +1,330 @@
+#include "PyColor.h"
+#include "McRFPy_API.h"
+#include "PyObjectUtils.h"
+#include "PyRAII.h"
+#include <string>
+#include <cstdio>
+
+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}
+};
+
+PyMethodDef PyColor::methods[] = {
+    {"from_hex", (PyCFunction)PyColor::from_hex, METH_VARARGS | METH_CLASS, "Create Color from hex string (e.g., '#FF0000' or 'FF0000')"},
+    {"to_hex", (PyCFunction)PyColor::to_hex, METH_NOARGS, "Convert Color to hex string"},
+    {"lerp", (PyCFunction)PyColor::lerp, METH_VARARGS, "Linearly interpolate between this color and another"},
+    {NULL}
+};
+
+PyColor::PyColor(sf::Color target)
+:data(target) {}
+
+PyObject* PyColor::pyObject()
+{
+    PyTypeObject* type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color");
+    if (!type) return nullptr;
+    
+    PyColorObject* obj = (PyColorObject*)type->tp_alloc(type, 0);
+    Py_DECREF(type);
+    
+    if (obj) {
+        obj->data = data;
+    }
+    return (PyObject*)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)
+{
+    PyColorObject* self = (PyColorObject*)obj;
+    long member = (long)closure;
+    
+    switch (member) {
+        case 0: // r
+            return PyLong_FromLong(self->data.r);
+        case 1: // g
+            return PyLong_FromLong(self->data.g);
+        case 2: // b
+            return PyLong_FromLong(self->data.b);
+        case 3: // a
+            return PyLong_FromLong(self->data.a);
+        default:
+            PyErr_SetString(PyExc_AttributeError, "Invalid color member");
+            return NULL;
+    }
+}
+
+int PyColor::set_member(PyObject* obj, PyObject* value, void* closure)
+{
+    PyColorObject* self = (PyColorObject*)obj;
+    long member = (long)closure;
+    
+    if (!PyLong_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "Color values must be integers");
+        return -1;
+    }
+    
+    long val = PyLong_AsLong(value);
+    if (val < 0 || val > 255) {
+        PyErr_SetString(PyExc_ValueError, "Color values must be between 0 and 255");
+        return -1;
+    }
+    
+    switch (member) {
+        case 0: // r
+            self->data.r = static_cast<sf::Uint8>(val);
+            break;
+        case 1: // g
+            self->data.g = static_cast<sf::Uint8>(val);
+            break;
+        case 2: // b
+            self->data.b = static_cast<sf::Uint8>(val);
+            break;
+        case 3: // a
+            self->data.a = static_cast<sf::Uint8>(val);
+            break;
+        default:
+            PyErr_SetString(PyExc_AttributeError, "Invalid color member");
+            return -1;
+    }
+    
+    return 0;
+}
+
+PyColorObject* PyColor::from_arg(PyObject* args)
+{
+    // Use RAII for type reference management
+    PyRAII::PyTypeRef type("Color", McRFPy_API::mcrf_module);
+    if (!type) {
+        return NULL;
+    }
+    
+    // Check if args is already a Color instance
+    if (PyObject_IsInstance(args, (PyObject*)type.get())) {
+        return (PyColorObject*)args;
+    }
+    
+    // Create new Color object using RAII
+    PyRAII::PyObjectRef obj(type->tp_alloc(type.get(), 0), true);
+    if (!obj) {
+        return NULL;
+    }
+    
+    // Initialize the object
+    int err = init((PyColorObject*)obj.get(), args, NULL);
+    if (err) {
+        // obj will be automatically cleaned up when it goes out of scope
+        return NULL;
+    }
+    
+    // Release ownership and return
+    return (PyColorObject*)obj.release();
+}
+
+// Color helper method implementations
+PyObject* PyColor::from_hex(PyObject* cls, PyObject* args)
+{
+    const char* hex_str;
+    if (!PyArg_ParseTuple(args, "s", &hex_str)) {
+        return NULL;
+    }
+    
+    std::string hex(hex_str);
+    
+    // Remove # if present
+    if (hex.length() > 0 && hex[0] == '#') {
+        hex = hex.substr(1);
+    }
+    
+    // Validate hex string
+    if (hex.length() != 6 && hex.length() != 8) {
+        PyErr_SetString(PyExc_ValueError, "Hex string must be 6 or 8 characters (RGB or RGBA)");
+        return NULL;
+    }
+    
+    // Parse hex values
+    try {
+        unsigned int r = std::stoul(hex.substr(0, 2), nullptr, 16);
+        unsigned int g = std::stoul(hex.substr(2, 2), nullptr, 16);
+        unsigned int b = std::stoul(hex.substr(4, 2), nullptr, 16);
+        unsigned int a = 255;
+        
+        if (hex.length() == 8) {
+            a = std::stoul(hex.substr(6, 2), nullptr, 16);
+        }
+        
+        // Create new Color object
+        PyTypeObject* type = (PyTypeObject*)cls;
+        PyColorObject* color = (PyColorObject*)type->tp_alloc(type, 0);
+        if (color) {
+            color->data = sf::Color(r, g, b, a);
+        }
+        return (PyObject*)color;
+        
+    } catch (const std::exception& e) {
+        PyErr_SetString(PyExc_ValueError, "Invalid hex string");
+        return NULL;
+    }
+}
+
+PyObject* PyColor::to_hex(PyColorObject* self, PyObject* Py_UNUSED(ignored))
+{
+    char hex[10];  // #RRGGBBAA + null terminator
+    
+    // Include alpha only if not fully opaque
+    if (self->data.a < 255) {
+        snprintf(hex, sizeof(hex), "#%02X%02X%02X%02X", 
+                 self->data.r, self->data.g, self->data.b, self->data.a);
+    } else {
+        snprintf(hex, sizeof(hex), "#%02X%02X%02X", 
+                 self->data.r, self->data.g, self->data.b);
+    }
+    
+    return PyUnicode_FromString(hex);
+}
+
+PyObject* PyColor::lerp(PyColorObject* self, PyObject* args)
+{
+    PyObject* other_obj;
+    float t;
+    
+    if (!PyArg_ParseTuple(args, "Of", &other_obj, &t)) {
+        return NULL;
+    }
+    
+    // Validate other color
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Color");
+    if (!PyObject_IsInstance(other_obj, (PyObject*)type)) {
+        Py_DECREF(type);
+        PyErr_SetString(PyExc_TypeError, "First argument must be a Color");
+        return NULL;
+    }
+    
+    PyColorObject* other = (PyColorObject*)other_obj;
+    
+    // Clamp t to [0, 1]
+    if (t < 0.0f) t = 0.0f;
+    if (t > 1.0f) t = 1.0f;
+    
+    // Perform linear interpolation
+    sf::Uint8 r = static_cast<sf::Uint8>(self->data.r + (other->data.r - self->data.r) * t);
+    sf::Uint8 g = static_cast<sf::Uint8>(self->data.g + (other->data.g - self->data.g) * t);
+    sf::Uint8 b = static_cast<sf::Uint8>(self->data.b + (other->data.b - self->data.b) * t);
+    sf::Uint8 a = static_cast<sf::Uint8>(self->data.a + (other->data.a - self->data.a) * t);
+    
+    // Create new Color object
+    PyColorObject* result = (PyColorObject*)type->tp_alloc(type, 0);
+    Py_DECREF(type);
+    
+    if (result) {
+        result->data = sf::Color(r, g, b, a);
+    }
+    
+    return (PyObject*)result;
+}

src/PyColor.h

@@ -0,0 +1,56 @@
+#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*);
+    
+    // Color helper methods
+    static PyObject* from_hex(PyObject* cls, PyObject* args);
+    static PyObject* to_hex(PyColorObject* self, PyObject* Py_UNUSED(ignored));
+    static PyObject* lerp(PyColorObject* self, PyObject* args);
+    
+    static PyGetSetDef getsetters[];
+    static PyMethodDef methods[];
+    static PyColorObject* from_arg(PyObject*);
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PyColorType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .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_methods = PyColor::methods,
+        .tp_getset = PyColor::getsetters,
+        .tp_init = (initproc)PyColor::init,
+        .tp_new = PyColor::pynew,
+    };
+}

src/PyDrawable.cpp

@@ -0,0 +1,179 @@
+#include "PyDrawable.h"
+#include "McRFPy_API.h"
+
+// Click property getter
+static PyObject* PyDrawable_get_click(PyDrawableObject* self, void* closure)
+{
+    if (!self->data->click_callable) 
+        Py_RETURN_NONE;
+    
+    PyObject* ptr = self->data->click_callable->borrow();
+    if (ptr && ptr != Py_None)
+        return ptr;
+    else
+        Py_RETURN_NONE;
+}
+
+// Click property setter
+static int PyDrawable_set_click(PyDrawableObject* self, PyObject* value, void* closure)
+{
+    if (value == Py_None) {
+        self->data->click_unregister();
+    } else if (PyCallable_Check(value)) {
+        self->data->click_register(value);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "click must be callable or None");
+        return -1;
+    }
+    return 0;
+}
+
+// Z-index property getter
+static PyObject* PyDrawable_get_z_index(PyDrawableObject* self, void* closure)
+{
+    return PyLong_FromLong(self->data->z_index);
+}
+
+// Z-index property setter  
+static int PyDrawable_set_z_index(PyDrawableObject* self, PyObject* value, void* closure)
+{
+    if (!PyLong_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "z_index must be an integer");
+        return -1;
+    }
+    
+    int val = PyLong_AsLong(value);
+    self->data->z_index = val;
+    
+    // Mark scene as needing resort
+    self->data->notifyZIndexChanged();
+    
+    return 0;
+}
+
+// Visible property getter (new for #87)
+static PyObject* PyDrawable_get_visible(PyDrawableObject* self, void* closure)
+{
+    return PyBool_FromLong(self->data->visible);
+}
+
+// Visible property setter (new for #87)
+static int PyDrawable_set_visible(PyDrawableObject* self, PyObject* value, void* closure)
+{
+    if (!PyBool_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "visible must be a boolean");
+        return -1;
+    }
+    
+    self->data->visible = (value == Py_True);
+    return 0;
+}
+
+// Opacity property getter (new for #88)
+static PyObject* PyDrawable_get_opacity(PyDrawableObject* self, void* closure)
+{
+    return PyFloat_FromDouble(self->data->opacity);
+}
+
+// Opacity property setter (new for #88)
+static int PyDrawable_set_opacity(PyDrawableObject* self, PyObject* value, void* closure)
+{
+    float val;
+    if (PyFloat_Check(value)) {
+        val = PyFloat_AsDouble(value);
+    } else if (PyLong_Check(value)) {
+        val = PyLong_AsLong(value);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "opacity must be a number");
+        return -1;
+    }
+    
+    // Clamp to valid range
+    if (val < 0.0f) val = 0.0f;
+    if (val > 1.0f) val = 1.0f;
+    
+    self->data->opacity = val;
+    return 0;
+}
+
+// GetSetDef array for properties
+static PyGetSetDef PyDrawable_getsetters[] = {
+    {"click", (getter)PyDrawable_get_click, (setter)PyDrawable_set_click, 
+     "Callable executed when object is clicked", NULL},
+    {"z_index", (getter)PyDrawable_get_z_index, (setter)PyDrawable_set_z_index,
+     "Z-order for rendering (lower values rendered first)", NULL},
+    {"visible", (getter)PyDrawable_get_visible, (setter)PyDrawable_set_visible,
+     "Whether the object is visible", NULL},
+    {"opacity", (getter)PyDrawable_get_opacity, (setter)PyDrawable_set_opacity,
+     "Opacity level (0.0 = transparent, 1.0 = opaque)", NULL},
+    {NULL}  // Sentinel
+};
+
+// get_bounds method implementation (#89)
+static PyObject* PyDrawable_get_bounds(PyDrawableObject* self, PyObject* Py_UNUSED(args))
+{
+    auto bounds = self->data->get_bounds();
+    return Py_BuildValue("(ffff)", bounds.left, bounds.top, bounds.width, bounds.height);
+}
+
+// move method implementation (#98)
+static PyObject* PyDrawable_move(PyDrawableObject* self, PyObject* args)
+{
+    float dx, dy;
+    if (!PyArg_ParseTuple(args, "ff", &dx, &dy)) {
+        return NULL;
+    }
+    
+    self->data->move(dx, dy);
+    Py_RETURN_NONE;
+}
+
+// resize method implementation (#98)
+static PyObject* PyDrawable_resize(PyDrawableObject* self, PyObject* args)
+{
+    float w, h;
+    if (!PyArg_ParseTuple(args, "ff", &w, &h)) {
+        return NULL;
+    }
+    
+    self->data->resize(w, h);
+    Py_RETURN_NONE;
+}
+
+// Method definitions
+static PyMethodDef PyDrawable_methods[] = {
+    {"get_bounds", (PyCFunction)PyDrawable_get_bounds, METH_NOARGS,
+     "Get bounding box as (x, y, width, height)"},
+    {"move", (PyCFunction)PyDrawable_move, METH_VARARGS,
+     "Move by relative offset (dx, dy)"},
+    {"resize", (PyCFunction)PyDrawable_resize, METH_VARARGS,
+     "Resize to new dimensions (width, height)"},
+    {NULL}  // Sentinel
+};
+
+// Type initialization
+static int PyDrawable_init(PyDrawableObject* self, PyObject* args, PyObject* kwds)
+{
+    PyErr_SetString(PyExc_TypeError, "Drawable is an abstract base class and cannot be instantiated directly");
+    return -1;
+}
+
+namespace mcrfpydef {
+    PyTypeObject PyDrawableType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .tp_name = "mcrfpy.Drawable",
+        .tp_basicsize = sizeof(PyDrawableObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)[](PyObject* self) {
+            PyDrawableObject* obj = (PyDrawableObject*)self;
+            obj->data.reset();
+            Py_TYPE(self)->tp_free(self);
+        },
+        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+        .tp_doc = PyDoc_STR("Base class for all drawable UI elements"),
+        .tp_methods = PyDrawable_methods,
+        .tp_getset = PyDrawable_getsetters,
+        .tp_init = (initproc)PyDrawable_init,
+        .tp_new = PyType_GenericNew,
+    };
+}

src/PyDrawable.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include "UIDrawable.h"
+
+// Python object structure for UIDrawable base class
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UIDrawable> data;
+} PyDrawableObject;
+
+// Declare the Python type for Drawable base class
+namespace mcrfpydef {
+    extern PyTypeObject PyDrawableType;
+}

src/PyFont.cpp

@@ -0,0 +1,79 @@
+#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);
+}
+
+PyObject* PyFont::get_family(PyFontObject* self, void* closure)
+{
+    return PyUnicode_FromString(self->data->font.getInfo().family.c_str());
+}
+
+PyObject* PyFont::get_source(PyFontObject* self, void* closure)
+{
+    return PyUnicode_FromString(self->data->source.c_str());
+}
+
+PyGetSetDef PyFont::getsetters[] = {
+    {"family", (getter)PyFont::get_family, NULL, "Font family name", NULL},
+    {"source", (getter)PyFont::get_source, NULL, "Source filename of the font", NULL},
+    {NULL}  // Sentinel
+};

src/PyFont.h

@@ -0,0 +1,47 @@
+#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);
+    
+    // Getters for properties
+    static PyObject* get_family(PyFontObject* self, void* closure);
+    static PyObject* get_source(PyFontObject* self, void* closure);
+    
+    static PyGetSetDef getsetters[];
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PyFontType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .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_getset = PyFont::getsetters,
+        //.tp_base = &PyBaseObject_Type,
+        .tp_init = (initproc)PyFont::init,
+        .tp_new = PyType_GenericNew, //PyFont::pynew,
+    };
+}

src/PyObjectUtils.h

@@ -0,0 +1,76 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include "McRFPy_API.h"
+#include "PyRAII.h"
+
+namespace PyObjectUtils {
+    
+    // Template for getting Python type object from module
+    template<typename T>
+    PyTypeObject* getPythonType(const char* typeName) {
+        PyTypeObject* type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, typeName);
+        if (!type) {
+            PyErr_Format(PyExc_RuntimeError, "Could not find %s type in module", typeName);
+        }
+        return type;
+    }
+    
+    // Generic function to create a Python object of given type
+    inline PyObject* createPyObjectGeneric(const char* typeName) {
+        PyTypeObject* type = getPythonType<void>(typeName);
+        if (!type) return nullptr;
+        
+        PyObject* obj = type->tp_alloc(type, 0);
+        Py_DECREF(type);
+        
+        return obj;
+    }
+    
+    // Helper function to allocate and initialize a Python object with data
+    template<typename PyObjType, typename DataType>
+    PyObject* createPyObjectWithData(const char* typeName, DataType data) {
+        PyTypeObject* type = getPythonType<void>(typeName);
+        if (!type) return nullptr;
+        
+        PyObjType* obj = (PyObjType*)type->tp_alloc(type, 0);
+        Py_DECREF(type);
+        
+        if (obj) {
+            obj->data = data;
+        }
+        return (PyObject*)obj;
+    }
+    
+    // Function to convert UIDrawable to appropriate Python object
+    // This is moved to UICollection.cpp to avoid circular dependencies
+    
+    // RAII-based object creation example
+    inline PyObject* createPyObjectGenericRAII(const char* typeName) {
+        PyRAII::PyTypeRef type(typeName, McRFPy_API::mcrf_module);
+        if (!type) {
+            PyErr_Format(PyExc_RuntimeError, "Could not find %s type in module", typeName);
+            return nullptr;
+        }
+        
+        PyObject* obj = type->tp_alloc(type.get(), 0);
+        // Return the new reference (caller owns it)
+        return obj;
+    }
+    
+    // Example of using PyObjectRef for safer reference management
+    template<typename PyObjType, typename DataType>
+    PyObject* createPyObjectWithDataRAII(const char* typeName, DataType data) {
+        PyRAII::PyObjectRef obj = PyRAII::createObject<PyObjType>(typeName, McRFPy_API::mcrf_module);
+        if (!obj) {
+            PyErr_Format(PyExc_RuntimeError, "Could not create %s object", typeName);
+            return nullptr;
+        }
+        
+        // Access the object through the RAII wrapper
+        ((PyObjType*)obj.get())->data = data;
+        
+        // Release ownership to return to Python
+        return obj.release();
+    }
+}

src/PyPositionHelper.h

@@ -0,0 +1,164 @@
+#pragma once
+#include "Python.h"
+#include "PyVector.h"
+#include "McRFPy_API.h"
+
+// Helper class for standardized position argument parsing across UI classes
+class PyPositionHelper {
+public:
+    // Template structure for parsing results
+    struct ParseResult {
+        float x = 0.0f;
+        float y = 0.0f;
+        bool has_position = false;
+    };
+    
+    struct ParseResultInt {
+        int x = 0;
+        int y = 0;
+        bool has_position = false;
+    };
+    
+    // Parse position from multiple formats for UI class constructors
+    // Supports: (x, y), x=x, y=y, ((x,y)), (pos=(x,y)), (Vector), pos=Vector
+    static ParseResult parse_position(PyObject* args, PyObject* kwds, 
+                                      int* arg_index = nullptr) 
+    {
+        ParseResult result;
+        float x = 0.0f, y = 0.0f;
+        PyObject* pos_obj = nullptr;
+        int start_index = arg_index ? *arg_index : 0;
+        
+        // Check for positional tuple (x, y) first
+        if (!kwds && PyTuple_Size(args) > start_index + 1) {
+            PyObject* first = PyTuple_GetItem(args, start_index);
+            PyObject* second = PyTuple_GetItem(args, start_index + 1);
+            
+            // Check if both are numbers
+            if ((PyFloat_Check(first) || PyLong_Check(first)) &&
+                (PyFloat_Check(second) || PyLong_Check(second))) {
+                x = PyFloat_Check(first) ? PyFloat_AsDouble(first) : PyLong_AsLong(first);
+                y = PyFloat_Check(second) ? PyFloat_AsDouble(second) : PyLong_AsLong(second);
+                result.x = x;
+                result.y = y;
+                result.has_position = true;
+                if (arg_index) *arg_index += 2;
+                return result;
+            }
+        }
+        
+        // Check for single positional argument that might be tuple or Vector
+        if (!kwds && PyTuple_Size(args) > start_index) {
+            PyObject* first = PyTuple_GetItem(args, start_index);
+            PyVectorObject* vec = PyVector::from_arg(first);
+            if (vec) {
+                result.x = vec->data.x;
+                result.y = vec->data.y;
+                result.has_position = true;
+                if (arg_index) *arg_index += 1;
+                return result;
+            }
+        }
+        
+        // Try keyword arguments
+        if (kwds) {
+            PyObject* x_obj = PyDict_GetItemString(kwds, "x");
+            PyObject* y_obj = PyDict_GetItemString(kwds, "y");
+            PyObject* pos_kw = PyDict_GetItemString(kwds, "pos");
+            
+            if (x_obj && y_obj) {
+                if ((PyFloat_Check(x_obj) || PyLong_Check(x_obj)) &&
+                    (PyFloat_Check(y_obj) || PyLong_Check(y_obj))) {
+                    result.x = PyFloat_Check(x_obj) ? PyFloat_AsDouble(x_obj) : PyLong_AsLong(x_obj);
+                    result.y = PyFloat_Check(y_obj) ? PyFloat_AsDouble(y_obj) : PyLong_AsLong(y_obj);
+                    result.has_position = true;
+                    return result;
+                }
+            }
+            
+            if (pos_kw) {
+                PyVectorObject* vec = PyVector::from_arg(pos_kw);
+                if (vec) {
+                    result.x = vec->data.x;
+                    result.y = vec->data.y;
+                    result.has_position = true;
+                    return result;
+                }
+            }
+        }
+        
+        return result;
+    }
+    
+    // Parse integer position for Grid.at() and similar
+    static ParseResultInt parse_position_int(PyObject* args, PyObject* kwds) 
+    {
+        ParseResultInt result;
+        
+        // Check for positional tuple (x, y) first
+        if (!kwds && PyTuple_Size(args) >= 2) {
+            PyObject* first = PyTuple_GetItem(args, 0);
+            PyObject* second = PyTuple_GetItem(args, 1);
+            
+            if (PyLong_Check(first) && PyLong_Check(second)) {
+                result.x = PyLong_AsLong(first);
+                result.y = PyLong_AsLong(second);
+                result.has_position = true;
+                return result;
+            }
+        }
+        
+        // Check for single tuple argument
+        if (!kwds && PyTuple_Size(args) == 1) {
+            PyObject* first = PyTuple_GetItem(args, 0);
+            if (PyTuple_Check(first) && PyTuple_Size(first) == 2) {
+                PyObject* x_obj = PyTuple_GetItem(first, 0);
+                PyObject* y_obj = PyTuple_GetItem(first, 1);
+                if (PyLong_Check(x_obj) && PyLong_Check(y_obj)) {
+                    result.x = PyLong_AsLong(x_obj);
+                    result.y = PyLong_AsLong(y_obj);
+                    result.has_position = true;
+                    return result;
+                }
+            }
+        }
+        
+        // Try keyword arguments
+        if (kwds) {
+            PyObject* x_obj = PyDict_GetItemString(kwds, "x");
+            PyObject* y_obj = PyDict_GetItemString(kwds, "y");
+            PyObject* pos_obj = PyDict_GetItemString(kwds, "pos");
+            
+            if (x_obj && y_obj && PyLong_Check(x_obj) && PyLong_Check(y_obj)) {
+                result.x = PyLong_AsLong(x_obj);
+                result.y = PyLong_AsLong(y_obj);
+                result.has_position = true;
+                return result;
+            }
+            
+            if (pos_obj && PyTuple_Check(pos_obj) && PyTuple_Size(pos_obj) == 2) {
+                PyObject* x_val = PyTuple_GetItem(pos_obj, 0);
+                PyObject* y_val = PyTuple_GetItem(pos_obj, 1);
+                if (PyLong_Check(x_val) && PyLong_Check(y_val)) {
+                    result.x = PyLong_AsLong(x_val);
+                    result.y = PyLong_AsLong(y_val);
+                    result.has_position = true;
+                    return result;
+                }
+            }
+        }
+        
+        return result;
+    }
+    
+    // Error message helper
+    static void set_position_error() {
+        PyErr_SetString(PyExc_TypeError,
+            "Position can be specified as: (x, y), x=x, y=y, ((x,y)), pos=(x,y), or pos=Vector");
+    }
+    
+    static void set_position_int_error() {
+        PyErr_SetString(PyExc_TypeError,
+            "Position must be specified as: (x, y), x=x, y=y, ((x,y)), or pos=(x,y) with integer values");
+    }
+};

src/PyRAII.h

@@ -0,0 +1,138 @@
+#pragma once
+#include "Python.h"
+#include <utility>
+
+namespace PyRAII {
+    
+    // RAII wrapper for PyObject* that automatically manages reference counting
+    class PyObjectRef {
+    private:
+        PyObject* ptr;
+        
+    public:
+        // Constructors
+        PyObjectRef() : ptr(nullptr) {}
+        
+        explicit PyObjectRef(PyObject* p, bool steal_ref = false) : ptr(p) {
+            if (ptr && !steal_ref) {
+                Py_INCREF(ptr);
+            }
+        }
+        
+        // Copy constructor
+        PyObjectRef(const PyObjectRef& other) : ptr(other.ptr) {
+            if (ptr) {
+                Py_INCREF(ptr);
+            }
+        }
+        
+        // Move constructor  
+        PyObjectRef(PyObjectRef&& other) noexcept : ptr(other.ptr) {
+            other.ptr = nullptr;
+        }
+        
+        // Destructor
+        ~PyObjectRef() {
+            Py_XDECREF(ptr);
+        }
+        
+        // Copy assignment
+        PyObjectRef& operator=(const PyObjectRef& other) {
+            if (this != &other) {
+                Py_XDECREF(ptr);
+                ptr = other.ptr;
+                if (ptr) {
+                    Py_INCREF(ptr);
+                }
+            }
+            return *this;
+        }
+        
+        // Move assignment
+        PyObjectRef& operator=(PyObjectRef&& other) noexcept {
+            if (this != &other) {
+                Py_XDECREF(ptr);
+                ptr = other.ptr;
+                other.ptr = nullptr;
+            }
+            return *this;
+        }
+        
+        // Access operators
+        PyObject* get() const { return ptr; }
+        PyObject* operator->() const { return ptr; }
+        PyObject& operator*() const { return *ptr; }
+        operator bool() const { return ptr != nullptr; }
+        
+        // Release ownership (for returning to Python)
+        PyObject* release() {
+            PyObject* temp = ptr;
+            ptr = nullptr;
+            return temp;
+        }
+        
+        // Reset with new pointer
+        void reset(PyObject* p = nullptr, bool steal_ref = false) {
+            if (p != ptr) {
+                Py_XDECREF(ptr);
+                ptr = p;
+                if (ptr && !steal_ref) {
+                    Py_INCREF(ptr);
+                }
+            }
+        }
+    };
+    
+    // Helper class for managing PyTypeObject* references from module lookups
+    class PyTypeRef {
+    private:
+        PyTypeObject* type;
+        
+    public:
+        PyTypeRef() : type(nullptr) {}
+        
+        explicit PyTypeRef(const char* typeName, PyObject* module) {
+            type = (PyTypeObject*)PyObject_GetAttrString(module, typeName);
+            // GetAttrString returns a new reference, so we own it
+        }
+        
+        ~PyTypeRef() {
+            Py_XDECREF((PyObject*)type);
+        }
+        
+        // Delete copy operations to prevent accidental reference issues
+        PyTypeRef(const PyTypeRef&) = delete;
+        PyTypeRef& operator=(const PyTypeRef&) = delete;
+        
+        // Allow move operations
+        PyTypeRef(PyTypeRef&& other) noexcept : type(other.type) {
+            other.type = nullptr;
+        }
+        
+        PyTypeRef& operator=(PyTypeRef&& other) noexcept {
+            if (this != &other) {
+                Py_XDECREF((PyObject*)type);
+                type = other.type;
+                other.type = nullptr;
+            }
+            return *this;
+        }
+        
+        PyTypeObject* get() const { return type; }
+        PyTypeObject* operator->() const { return type; }
+        operator bool() const { return type != nullptr; }
+    };
+    
+    // Convenience function to create a new object with RAII
+    template<typename PyObjType>
+    PyObjectRef createObject(const char* typeName, PyObject* module) {
+        PyTypeRef type(typeName, module);
+        if (!type) {
+            return PyObjectRef();
+        }
+        
+        PyObject* obj = type->tp_alloc(type.get(), 0);
+        // tp_alloc returns a new reference, so we steal it
+        return PyObjectRef(obj, true);
+    }
+}

src/PyScene.cpp

@@ -2,6 +2,7 @@
 #include "ActionCode.h"
 #include "Resources.h"
 #include "PyCallable.h"
+#include <algorithm>
 
 PyScene::PyScene(GameEngine* g) : Scene(g)
 {
@@ -11,7 +12,8 @@ PyScene::PyScene(GameEngine* g) : Scene(g)
     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");
+    // console (` / ~ key) - don't hard code.
+    //registerAction(ActionCode::KEY + sf::Keyboard::Grave, "debug_menu");
 }
 
 void PyScene::update()
@@ -20,38 +22,39 @@ void PyScene::update()
 
 void PyScene::do_mouse_input(std::string button, std::string type)
 {
+    // In headless mode, mouse input is not available
+    if (game->isHeadless()) {
+        return;
+    }
+    
     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;
-            }
-            */
+    // Convert window coordinates to game coordinates using the viewport
+    auto mousepos = game->windowToGameCoords(sf::Vector2f(unscaledmousepos));
+    
+    // Only sort if z_index values have changed
+    if (ui_elements_need_sort) {
+        // Sort in ascending order (same as render)
+        std::sort(ui_elements->begin(), ui_elements->end(),
+            [](const auto& a, const auto& b) { return a->z_index < b->z_index; });
+        ui_elements_need_sort = false;
+    }
+    
+    // Check elements in reverse z-order (highest z_index first, top to bottom)
+    // Use reverse iterators to go from end to beginning
+    for (auto it = ui_elements->rbegin(); it != ui_elements->rend(); ++it) {
+        const auto& element = *it;
+        if (!element->visible) continue;
+        
+        if (auto target = element->click_at(sf::Vector2f(mousepos))) {
             target->click_callable->call(mousepos, button, type);
+            return; // Stop after first handler
         }
     }
 }
 
 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) {
+    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") {
@@ -59,16 +62,33 @@ void PyScene::doAction(std::string name, std::string type)
     }
 }
 
-void PyScene::sRender()
+void PyScene::render()
 {
-    game->getWindow().clear();
+    game->getRenderTarget().clear();
     
-    auto vec = *ui_elements;
-    for (auto e: vec)
-    {
-        if (e)
-            e->render();
+    // Only sort if z_index values have changed
+    if (ui_elements_need_sort) {
+        std::sort(ui_elements->begin(), ui_elements->end(), 
+            [](const std::shared_ptr<UIDrawable>& a, const std::shared_ptr<UIDrawable>& b) {
+                return a->z_index < b->z_index;
+            });
+        ui_elements_need_sort = false;
     }
     
-    game->getWindow().display();
+    // Render in sorted order (no need to copy anymore)
+    for (auto e: *ui_elements)
+    {
+        if (e) {
+            // Track metrics
+            game->metrics.uiElements++;
+            if (e->visible) {
+                game->metrics.visibleElements++;
+                // Count this as a draw call (each visible element = 1+ draw calls)
+                game->metrics.drawCalls++;
+            }
+            e->render();
+        }
+    }
+    
+    // Display is handled by GameEngine
 }

src/PyScene.h

@@ -11,7 +11,10 @@ public:
     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);
+    
+    // Dirty flag for z_index sorting optimization
+    bool ui_elements_need_sort = true;
 };

src/PySceneObject.cpp

@@ -0,0 +1,268 @@
+#include "PySceneObject.h"
+#include "PyScene.h"
+#include "GameEngine.h"
+#include "McRFPy_API.h"
+#include <iostream>
+
+// Static map to store Python scene objects by name
+static std::map<std::string, PySceneObject*> python_scenes;
+
+PyObject* PySceneClass::__new__(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+    PySceneObject* self = (PySceneObject*)type->tp_alloc(type, 0);
+    if (self) {
+        self->initialized = false;
+        // Don't create C++ scene yet - wait for __init__
+    }
+    return (PyObject*)self;
+}
+
+int PySceneClass::__init__(PySceneObject* self, PyObject* args, PyObject* kwds)
+{
+    static const char* keywords[] = {"name", nullptr};
+    const char* name = nullptr;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", const_cast<char**>(keywords), &name)) {
+        return -1;
+    }
+    
+    // Check if scene with this name already exists
+    if (python_scenes.count(name) > 0) {
+        PyErr_Format(PyExc_ValueError, "Scene with name '%s' already exists", name);
+        return -1;
+    }
+    
+    self->name = name;
+    
+    // Create the C++ PyScene
+    McRFPy_API::game->createScene(name);
+    
+    // Get reference to the created scene
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    // Store this Python object in our registry
+    python_scenes[name] = self;
+    Py_INCREF(self);  // Keep a reference
+    
+    // Create a Python function that routes to on_keypress
+    // We'll register this after the object is fully initialized
+    
+    self->initialized = true;
+    
+    return 0;
+}
+
+void PySceneClass::__dealloc(PyObject* self_obj)
+{
+    PySceneObject* self = (PySceneObject*)self_obj;
+    
+    // Remove from registry
+    if (python_scenes.count(self->name) > 0 && python_scenes[self->name] == self) {
+        python_scenes.erase(self->name);
+    }
+    
+    // Call Python object destructor
+    Py_TYPE(self)->tp_free(self);
+}
+
+PyObject* PySceneClass::__repr__(PySceneObject* self)
+{
+    return PyUnicode_FromFormat("<Scene '%s'>", self->name.c_str());
+}
+
+PyObject* PySceneClass::activate(PySceneObject* self, PyObject* args)
+{
+    // Call the static method from McRFPy_API
+    PyObject* py_args = Py_BuildValue("(s)", self->name.c_str());
+    PyObject* result = McRFPy_API::_setScene(NULL, py_args);
+    Py_DECREF(py_args);
+    return result;
+}
+
+PyObject* PySceneClass::get_ui(PySceneObject* self, PyObject* args)
+{
+    // Call the static method from McRFPy_API
+    PyObject* py_args = Py_BuildValue("(s)", self->name.c_str());
+    PyObject* result = McRFPy_API::_sceneUI(NULL, py_args);
+    Py_DECREF(py_args);
+    return result;
+}
+
+PyObject* PySceneClass::register_keyboard(PySceneObject* self, PyObject* args)
+{
+    PyObject* callable;
+    if (!PyArg_ParseTuple(args, "O", &callable)) {
+        return NULL;
+    }
+    
+    if (!PyCallable_Check(callable)) {
+        PyErr_SetString(PyExc_TypeError, "Argument must be callable");
+        return NULL;
+    }
+    
+    // Store the callable
+    Py_INCREF(callable);
+    
+    // Get the current scene and set its key_callable
+    GameEngine* game = McRFPy_API::game;
+    if (game) {
+        // We need to be on the right scene first
+        std::string old_scene = game->scene;
+        game->scene = self->name;
+        game->currentScene()->key_callable = std::make_unique<PyKeyCallable>(callable);
+        game->scene = old_scene;
+    }
+    
+    Py_DECREF(callable);
+    Py_RETURN_NONE;
+}
+
+PyObject* PySceneClass::get_name(PySceneObject* self, void* closure)
+{
+    return PyUnicode_FromString(self->name.c_str());
+}
+
+PyObject* PySceneClass::get_active(PySceneObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        Py_RETURN_FALSE;
+    }
+    
+    return PyBool_FromLong(game->scene == self->name);
+}
+
+// Lifecycle callbacks
+void PySceneClass::call_on_enter(PySceneObject* self)
+{
+    PyObject* method = PyObject_GetAttrString((PyObject*)self, "on_enter");
+    if (method && PyCallable_Check(method)) {
+        PyObject* result = PyObject_CallNoArgs(method);
+        if (result) {
+            Py_DECREF(result);
+        } else {
+            PyErr_Print();
+        }
+    }
+    Py_XDECREF(method);
+}
+
+void PySceneClass::call_on_exit(PySceneObject* self)
+{
+    PyObject* method = PyObject_GetAttrString((PyObject*)self, "on_exit");
+    if (method && PyCallable_Check(method)) {
+        PyObject* result = PyObject_CallNoArgs(method);
+        if (result) {
+            Py_DECREF(result);
+        } else {
+            PyErr_Print();
+        }
+    }
+    Py_XDECREF(method);
+}
+
+void PySceneClass::call_on_keypress(PySceneObject* self, std::string key, std::string action)
+{
+    PyGILState_STATE gstate = PyGILState_Ensure();
+    
+    PyObject* method = PyObject_GetAttrString((PyObject*)self, "on_keypress");
+    if (method && PyCallable_Check(method)) {
+        PyObject* result = PyObject_CallFunction(method, "ss", key.c_str(), action.c_str());
+        if (result) {
+            Py_DECREF(result);
+        } else {
+            PyErr_Print();
+        }
+    }
+    Py_XDECREF(method);
+    
+    PyGILState_Release(gstate);
+}
+
+void PySceneClass::call_update(PySceneObject* self, float dt)
+{
+    PyObject* method = PyObject_GetAttrString((PyObject*)self, "update");
+    if (method && PyCallable_Check(method)) {
+        PyObject* result = PyObject_CallFunction(method, "f", dt);
+        if (result) {
+            Py_DECREF(result);
+        } else {
+            PyErr_Print();
+        }
+    }
+    Py_XDECREF(method);
+}
+
+void PySceneClass::call_on_resize(PySceneObject* self, int width, int height)
+{
+    PyObject* method = PyObject_GetAttrString((PyObject*)self, "on_resize");
+    if (method && PyCallable_Check(method)) {
+        PyObject* result = PyObject_CallFunction(method, "ii", width, height);
+        if (result) {
+            Py_DECREF(result);
+        } else {
+            PyErr_Print();
+        }
+    }
+    Py_XDECREF(method);
+}
+
+// Properties
+PyGetSetDef PySceneClass::getsetters[] = {
+    {"name", (getter)get_name, NULL, "Scene name", NULL},
+    {"active", (getter)get_active, NULL, "Whether this scene is currently active", NULL},
+    {NULL}
+};
+
+// Methods
+PyMethodDef PySceneClass::methods[] = {
+    {"activate", (PyCFunction)activate, METH_NOARGS,
+     "Make this the active scene"},
+    {"get_ui", (PyCFunction)get_ui, METH_NOARGS,
+     "Get the UI element collection for this scene"},
+    {"register_keyboard", (PyCFunction)register_keyboard, METH_VARARGS,
+     "Register a keyboard handler function (alternative to overriding on_keypress)"},
+    {NULL}
+};
+
+// Helper function to trigger lifecycle events
+void McRFPy_API::triggerSceneChange(const std::string& from_scene, const std::string& to_scene)
+{
+    // Call on_exit for the old scene
+    if (!from_scene.empty() && python_scenes.count(from_scene) > 0) {
+        PySceneClass::call_on_exit(python_scenes[from_scene]);
+    }
+    
+    // Call on_enter for the new scene
+    if (!to_scene.empty() && python_scenes.count(to_scene) > 0) {
+        PySceneClass::call_on_enter(python_scenes[to_scene]);
+    }
+}
+
+// Helper function to update Python scenes
+void McRFPy_API::updatePythonScenes(float dt)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) return;
+    
+    // Only update the active scene
+    if (python_scenes.count(game->scene) > 0) {
+        PySceneClass::call_update(python_scenes[game->scene], dt);
+    }
+}
+
+// Helper function to trigger resize events on Python scenes
+void McRFPy_API::triggerResize(int width, int height)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) return;
+    
+    // Only notify the active scene
+    if (python_scenes.count(game->scene) > 0) {
+        PySceneClass::call_on_resize(python_scenes[game->scene], width, height);
+    }
+}

src/PySceneObject.h

@@ -0,0 +1,63 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include <string>
+#include <memory>
+
+// Forward declarations
+class PyScene;
+
+// Python object structure for Scene
+typedef struct {
+    PyObject_HEAD
+    std::string name;
+    std::shared_ptr<PyScene> scene;  // Reference to the C++ scene
+    bool initialized;
+} PySceneObject;
+
+// C++ interface for Python Scene class
+class PySceneClass
+{
+public:
+    // Type methods
+    static PyObject* __new__(PyTypeObject* type, PyObject* args, PyObject* kwds);
+    static int __init__(PySceneObject* self, PyObject* args, PyObject* kwds);
+    static void __dealloc(PyObject* self);
+    static PyObject* __repr__(PySceneObject* self);
+    
+    // Scene methods
+    static PyObject* activate(PySceneObject* self, PyObject* args);
+    static PyObject* get_ui(PySceneObject* self, PyObject* args);
+    static PyObject* register_keyboard(PySceneObject* self, PyObject* args);
+    
+    // Properties
+    static PyObject* get_name(PySceneObject* self, void* closure);
+    static PyObject* get_active(PySceneObject* self, void* closure);
+    
+    // Lifecycle callbacks (called from C++)
+    static void call_on_enter(PySceneObject* self);
+    static void call_on_exit(PySceneObject* self);
+    static void call_on_keypress(PySceneObject* self, std::string key, std::string action);
+    static void call_update(PySceneObject* self, float dt);
+    static void call_on_resize(PySceneObject* self, int width, int height);
+    
+    static PyGetSetDef getsetters[];
+    static PyMethodDef methods[];
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PySceneType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .tp_name = "mcrfpy.Scene",
+        .tp_basicsize = sizeof(PySceneObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)PySceneClass::__dealloc,
+        .tp_repr = (reprfunc)PySceneClass::__repr__,
+        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  // Allow subclassing
+        .tp_doc = PyDoc_STR("Base class for object-oriented scenes"),
+        .tp_methods = nullptr,  // Set in McRFPy_API.cpp
+        .tp_getset = nullptr,   // Set in McRFPy_API.cpp
+        .tp_init = (initproc)PySceneClass::__init__,
+        .tp_new = PySceneClass::__new__,
+    };
+}

src/PyTexture.cpp

@@ -0,0 +1,141 @@
+#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), sheet_width(0), sheet_height(0)
+{
+    texture = sf::Texture();
+    if (!texture.loadFromFile(source)) {
+        // Failed to load texture - leave sheet dimensions as 0
+        // This will be checked in init()
+        return;
+    }
+    texture.setSmooth(false);  // Disable smoothing for pixel art
+    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)
+{
+    // Protect against division by zero if texture failed to load
+    if (sheet_width == 0 || sheet_height == 0) {
+        // Return an empty sprite
+        return sf::Sprite();
+    }
+    
+    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()
+{
+    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;
+    
+    // Create the texture object
+    self->data = std::make_shared<PyTexture>(filename, sprite_width, sprite_height);
+    
+    // Check if the texture failed to load (sheet dimensions will be 0)
+    if (self->data->sheet_width == 0 || self->data->sheet_height == 0) {
+        PyErr_Format(PyExc_IOError, "Failed to load texture from file: %s", filename);
+        return -1;
+    }
+    
+    return 0;
+}
+
+PyObject* PyTexture::pynew(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+    return (PyObject*)type->tp_alloc(type, 0);
+}
+
+PyObject* PyTexture::get_sprite_width(PyTextureObject* self, void* closure)
+{
+    return PyLong_FromLong(self->data->sprite_width);
+}
+
+PyObject* PyTexture::get_sprite_height(PyTextureObject* self, void* closure)
+{
+    return PyLong_FromLong(self->data->sprite_height);
+}
+
+PyObject* PyTexture::get_sheet_width(PyTextureObject* self, void* closure)
+{
+    return PyLong_FromLong(self->data->sheet_width);
+}
+
+PyObject* PyTexture::get_sheet_height(PyTextureObject* self, void* closure)
+{
+    return PyLong_FromLong(self->data->sheet_height);
+}
+
+PyObject* PyTexture::get_sprite_count(PyTextureObject* self, void* closure)
+{
+    return PyLong_FromLong(self->data->getSpriteCount());
+}
+
+PyObject* PyTexture::get_source(PyTextureObject* self, void* closure)
+{
+    return PyUnicode_FromString(self->data->source.c_str());
+}
+
+PyGetSetDef PyTexture::getsetters[] = {
+    {"sprite_width", (getter)PyTexture::get_sprite_width, NULL, "Width of each sprite in pixels", NULL},
+    {"sprite_height", (getter)PyTexture::get_sprite_height, NULL, "Height of each sprite in pixels", NULL},
+    {"sheet_width", (getter)PyTexture::get_sheet_width, NULL, "Number of sprite columns in the texture", NULL},
+    {"sheet_height", (getter)PyTexture::get_sheet_height, NULL, "Number of sprite rows in the texture", NULL},
+    {"sprite_count", (getter)PyTexture::get_sprite_count, NULL, "Total number of sprites in the texture", NULL},
+    {"source", (getter)PyTexture::get_source, NULL, "Source filename of the texture", NULL},
+    {NULL}  // Sentinel
+};

src/PyTexture.h

@@ -0,0 +1,56 @@
+#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));
+    int getSpriteCount() const { return sheet_width * sheet_height; }
+
+    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);
+    
+    // Getters for properties
+    static PyObject* get_sprite_width(PyTextureObject* self, void* closure);
+    static PyObject* get_sprite_height(PyTextureObject* self, void* closure);
+    static PyObject* get_sheet_width(PyTextureObject* self, void* closure);
+    static PyObject* get_sheet_height(PyTextureObject* self, void* closure);
+    static PyObject* get_sprite_count(PyTextureObject* self, void* closure);
+    static PyObject* get_source(PyTextureObject* self, void* closure);
+    
+    static PyGetSetDef getsetters[];
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PyTextureType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .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_getset = PyTexture::getsetters,
+        //.tp_base = &PyBaseObject_Type,
+        .tp_init = (initproc)PyTexture::init,
+        .tp_new = PyType_GenericNew, //PyTexture::pynew,
+    };
+}

src/PyTimer.cpp

@@ -0,0 +1,344 @@
+#include "PyTimer.h"
+#include "Timer.h"
+#include "GameEngine.h"
+#include "Resources.h"
+#include "PythonObjectCache.h"
+#include <sstream>
+
+PyObject* PyTimer::repr(PyObject* self) {
+    PyTimerObject* timer = (PyTimerObject*)self;
+    std::ostringstream oss;
+    oss << "<Timer name='" << timer->name << "' ";
+    
+    if (timer->data) {
+        oss << "interval=" << timer->data->getInterval() << "ms ";
+        if (timer->data->isOnce()) {
+            oss << "once=True ";
+        }
+        if (timer->data->isPaused()) {
+            oss << "paused";
+            // Get current time to show remaining
+            int current_time = 0;
+            if (Resources::game) {
+                current_time = Resources::game->runtime.getElapsedTime().asMilliseconds();
+            }
+            oss << " (remaining=" << timer->data->getRemaining(current_time) << "ms)";
+        } else if (timer->data->isActive()) {
+            oss << "active";
+        } else {
+            oss << "cancelled";
+        }
+    } else {
+        oss << "uninitialized";
+    }
+    oss << ">";
+    
+    return PyUnicode_FromString(oss.str().c_str());
+}
+
+PyObject* PyTimer::pynew(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+    PyTimerObject* self = (PyTimerObject*)type->tp_alloc(type, 0);
+    if (self) {
+        new(&self->name) std::string();  // Placement new for std::string
+        self->data = nullptr;
+        self->weakreflist = nullptr;  // Initialize weakref list
+    }
+    return (PyObject*)self;
+}
+
+int PyTimer::init(PyTimerObject* self, PyObject* args, PyObject* kwds) {
+    static const char* kwlist[] = {"name", "callback", "interval", "once", NULL};
+    const char* name = nullptr;
+    PyObject* callback = nullptr;
+    int interval = 0;
+    int once = 0;  // Use int for bool parameter
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "sOi|p", const_cast<char**>(kwlist), 
+                                     &name, &callback, &interval, &once)) {
+        return -1;
+    }
+    
+    if (!PyCallable_Check(callback)) {
+        PyErr_SetString(PyExc_TypeError, "callback must be callable");
+        return -1;
+    }
+    
+    if (interval <= 0) {
+        PyErr_SetString(PyExc_ValueError, "interval must be positive");
+        return -1;
+    }
+    
+    self->name = name;
+    
+    // Get current time from game engine
+    int current_time = 0;
+    if (Resources::game) {
+        current_time = Resources::game->runtime.getElapsedTime().asMilliseconds();
+    }
+    
+    // Create the timer
+    self->data = std::make_shared<Timer>(callback, interval, current_time, (bool)once);
+    
+    // Register in Python object cache
+    if (self->data->serial_number == 0) {
+        self->data->serial_number = PythonObjectCache::getInstance().assignSerial();
+        PyObject* weakref = PyWeakref_NewRef((PyObject*)self, NULL);
+        if (weakref) {
+            PythonObjectCache::getInstance().registerObject(self->data->serial_number, weakref);
+            Py_DECREF(weakref);  // Cache owns the reference now
+        }
+    }
+    
+    // Register with game engine
+    if (Resources::game) {
+        Resources::game->timers[self->name] = self->data;
+    }
+    
+    return 0;
+}
+
+void PyTimer::dealloc(PyTimerObject* self) {
+    // Clear weakrefs first
+    if (self->weakreflist != nullptr) {
+        PyObject_ClearWeakRefs((PyObject*)self);
+    }
+    
+    // Remove from game engine if still registered
+    if (Resources::game && !self->name.empty()) {
+        auto it = Resources::game->timers.find(self->name);
+        if (it != Resources::game->timers.end() && it->second == self->data) {
+            Resources::game->timers.erase(it);
+        }
+    }
+    
+    // Explicitly destroy std::string
+    self->name.~basic_string();
+    
+    // Clear shared_ptr
+    self->data.reset();
+    
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+// Timer control methods
+PyObject* PyTimer::pause(PyTimerObject* self, PyObject* Py_UNUSED(ignored)) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    int current_time = 0;
+    if (Resources::game) {
+        current_time = Resources::game->runtime.getElapsedTime().asMilliseconds();
+    }
+    
+    self->data->pause(current_time);
+    Py_RETURN_NONE;
+}
+
+PyObject* PyTimer::resume(PyTimerObject* self, PyObject* Py_UNUSED(ignored)) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    int current_time = 0;
+    if (Resources::game) {
+        current_time = Resources::game->runtime.getElapsedTime().asMilliseconds();
+    }
+    
+    self->data->resume(current_time);
+    Py_RETURN_NONE;
+}
+
+PyObject* PyTimer::cancel(PyTimerObject* self, PyObject* Py_UNUSED(ignored)) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    // Remove from game engine
+    if (Resources::game && !self->name.empty()) {
+        auto it = Resources::game->timers.find(self->name);
+        if (it != Resources::game->timers.end() && it->second == self->data) {
+            Resources::game->timers.erase(it);
+        }
+    }
+    
+    self->data->cancel();
+    self->data.reset();
+    Py_RETURN_NONE;
+}
+
+PyObject* PyTimer::restart(PyTimerObject* self, PyObject* Py_UNUSED(ignored)) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    int current_time = 0;
+    if (Resources::game) {
+        current_time = Resources::game->runtime.getElapsedTime().asMilliseconds();
+    }
+    
+    self->data->restart(current_time);
+    Py_RETURN_NONE;
+}
+
+// Property getters/setters
+PyObject* PyTimer::get_interval(PyTimerObject* self, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    return PyLong_FromLong(self->data->getInterval());
+}
+
+int PyTimer::set_interval(PyTimerObject* self, PyObject* value, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return -1;
+    }
+    
+    if (!PyLong_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "interval must be an integer");
+        return -1;
+    }
+    
+    long interval = PyLong_AsLong(value);
+    if (interval <= 0) {
+        PyErr_SetString(PyExc_ValueError, "interval must be positive");
+        return -1;
+    }
+    
+    self->data->setInterval(interval);
+    return 0;
+}
+
+PyObject* PyTimer::get_remaining(PyTimerObject* self, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    int current_time = 0;
+    if (Resources::game) {
+        current_time = Resources::game->runtime.getElapsedTime().asMilliseconds();
+    }
+    
+    return PyLong_FromLong(self->data->getRemaining(current_time));
+}
+
+PyObject* PyTimer::get_paused(PyTimerObject* self, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    return PyBool_FromLong(self->data->isPaused());
+}
+
+PyObject* PyTimer::get_active(PyTimerObject* self, void* closure) {
+    if (!self->data) {
+        return Py_False;
+    }
+    
+    return PyBool_FromLong(self->data->isActive());
+}
+
+PyObject* PyTimer::get_callback(PyTimerObject* self, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    PyObject* callback = self->data->getCallback();
+    if (!callback) {
+        Py_RETURN_NONE;
+    }
+    
+    Py_INCREF(callback);
+    return callback;
+}
+
+int PyTimer::set_callback(PyTimerObject* self, PyObject* value, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return -1;
+    }
+    
+    if (!PyCallable_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "callback must be callable");
+        return -1;
+    }
+    
+    self->data->setCallback(value);
+    return 0;
+}
+
+PyObject* PyTimer::get_once(PyTimerObject* self, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return nullptr;
+    }
+    
+    return PyBool_FromLong(self->data->isOnce());
+}
+
+int PyTimer::set_once(PyTimerObject* self, PyObject* value, void* closure) {
+    if (!self->data) {
+        PyErr_SetString(PyExc_RuntimeError, "Timer not initialized");
+        return -1;
+    }
+    
+    if (!PyBool_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "once must be a boolean");
+        return -1;
+    }
+    
+    self->data->setOnce(PyObject_IsTrue(value));
+    return 0;
+}
+
+PyObject* PyTimer::get_name(PyTimerObject* self, void* closure) {
+    return PyUnicode_FromString(self->name.c_str());
+}
+
+PyGetSetDef PyTimer::getsetters[] = {
+    {"name", (getter)PyTimer::get_name, NULL,
+     "Timer name (read-only)", NULL},
+    {"interval", (getter)PyTimer::get_interval, (setter)PyTimer::set_interval,
+     "Timer interval in milliseconds", NULL},
+    {"remaining", (getter)PyTimer::get_remaining, NULL,
+     "Time remaining until next trigger in milliseconds", NULL},
+    {"paused", (getter)PyTimer::get_paused, NULL,
+     "Whether the timer is paused", NULL},
+    {"active", (getter)PyTimer::get_active, NULL,
+     "Whether the timer is active and not paused", NULL},
+    {"callback", (getter)PyTimer::get_callback, (setter)PyTimer::set_callback,
+     "The callback function to be called", NULL},
+    {"once", (getter)PyTimer::get_once, (setter)PyTimer::set_once,
+     "Whether the timer stops after firing once", NULL},
+    {NULL}
+};
+
+PyMethodDef PyTimer::methods[] = {
+    {"pause", (PyCFunction)PyTimer::pause, METH_NOARGS,
+     "pause() -> None\n\n"
+     "Pause the timer, preserving the time remaining until next trigger.\n"
+     "The timer can be resumed later with resume()."},
+    {"resume", (PyCFunction)PyTimer::resume, METH_NOARGS,
+     "resume() -> None\n\n"
+     "Resume a paused timer from where it left off.\n"
+     "Has no effect if the timer is not paused."},
+    {"cancel", (PyCFunction)PyTimer::cancel, METH_NOARGS,
+     "cancel() -> None\n\n"
+     "Cancel the timer and remove it from the timer system.\n"
+     "The timer will no longer fire and cannot be restarted."},
+    {"restart", (PyCFunction)PyTimer::restart, METH_NOARGS,
+     "restart() -> None\n\n"
+     "Restart the timer from the beginning.\n"
+     "Resets the timer to fire after a full interval from now."},
+    {NULL}
+};

src/PyTimer.h

@@ -0,0 +1,90 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include <memory>
+#include <string>
+
+class Timer;
+
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<Timer> data;
+    std::string name;
+    PyObject* weakreflist;  // Weak reference support
+} PyTimerObject;
+
+class PyTimer
+{
+public:
+    // Python type methods
+    static PyObject* repr(PyObject* self);
+    static int init(PyTimerObject* self, PyObject* args, PyObject* kwds);
+    static PyObject* pynew(PyTypeObject* type, PyObject* args=NULL, PyObject* kwds=NULL);
+    static void dealloc(PyTimerObject* self);
+    
+    // Timer control methods
+    static PyObject* pause(PyTimerObject* self, PyObject* Py_UNUSED(ignored));
+    static PyObject* resume(PyTimerObject* self, PyObject* Py_UNUSED(ignored));
+    static PyObject* cancel(PyTimerObject* self, PyObject* Py_UNUSED(ignored));
+    static PyObject* restart(PyTimerObject* self, PyObject* Py_UNUSED(ignored));
+    
+    // Timer property getters
+    static PyObject* get_name(PyTimerObject* self, void* closure);
+    static PyObject* get_interval(PyTimerObject* self, void* closure);
+    static int set_interval(PyTimerObject* self, PyObject* value, void* closure);
+    static PyObject* get_remaining(PyTimerObject* self, void* closure);
+    static PyObject* get_paused(PyTimerObject* self, void* closure);
+    static PyObject* get_active(PyTimerObject* self, void* closure);
+    static PyObject* get_callback(PyTimerObject* self, void* closure);
+    static int set_callback(PyTimerObject* self, PyObject* value, void* closure);
+    static PyObject* get_once(PyTimerObject* self, void* closure);
+    static int set_once(PyTimerObject* self, PyObject* value, void* closure);
+    
+    static PyGetSetDef getsetters[];
+    static PyMethodDef methods[];
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PyTimerType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .tp_name = "mcrfpy.Timer",
+        .tp_basicsize = sizeof(PyTimerObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)PyTimer::dealloc,
+        .tp_repr = PyTimer::repr,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+        .tp_doc = PyDoc_STR("Timer(name, callback, interval, once=False)\n\n"
+                            "Create a timer that calls a function at regular intervals.\n\n"
+                            "Args:\n"
+                            "    name (str): Unique identifier for the timer\n"
+                            "    callback (callable): Function to call - receives (timer, runtime) args\n"
+                            "    interval (int): Time between calls in milliseconds\n"
+                            "    once (bool): If True, timer stops after first call. Default: False\n\n"
+                            "Attributes:\n"
+                            "    interval (int): Time between calls in milliseconds\n"
+                            "    remaining (int): Time until next call in milliseconds (read-only)\n"
+                            "    paused (bool): Whether timer is paused (read-only)\n"
+                            "    active (bool): Whether timer is active and not paused (read-only)\n"
+                            "    callback (callable): The callback function\n"
+                            "    once (bool): Whether timer stops after firing once\n\n"
+                            "Methods:\n"
+                            "    pause(): Pause the timer, preserving time remaining\n"
+                            "    resume(): Resume a paused timer\n"
+                            "    cancel(): Stop and remove the timer\n"
+                            "    restart(): Reset timer to start from beginning\n\n"
+                            "Example:\n"
+                            "    def on_timer(timer, runtime):\n"
+                            "        print(f'Timer {timer} fired at {runtime}ms')\n"
+                            "        if runtime > 5000:\n"
+                            "            timer.cancel()\n"
+                            "    \n"
+                            "    timer = mcrfpy.Timer('my_timer', on_timer, 1000)\n"
+                            "    timer.pause()  # Pause timer\n"
+                            "    timer.resume() # Resume timer\n"
+                            "    timer.once = True  # Make it one-shot"),
+        .tp_methods = PyTimer::methods,
+        .tp_getset = PyTimer::getsetters,
+        .tp_init = (initproc)PyTimer::init,
+        .tp_new = PyTimer::pynew,
+    };
+}

src/PyVector.cpp

@@ -0,0 +1,465 @@
+#include "PyVector.h"
+#include "PyObjectUtils.h"
+#include <cmath>
+
+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}
+};
+
+PyMethodDef PyVector::methods[] = {
+    {"magnitude", (PyCFunction)PyVector::magnitude, METH_NOARGS, "Return the length of the vector"},
+    {"magnitude_squared", (PyCFunction)PyVector::magnitude_squared, METH_NOARGS, "Return the squared length of the vector"},
+    {"normalize", (PyCFunction)PyVector::normalize, METH_NOARGS, "Return a unit vector in the same direction"},
+    {"dot", (PyCFunction)PyVector::dot, METH_O, "Return the dot product with another vector"},
+    {"distance_to", (PyCFunction)PyVector::distance_to, METH_O, "Return the distance to another vector"},
+    {"angle", (PyCFunction)PyVector::angle, METH_NOARGS, "Return the angle in radians from the positive X axis"},
+    {"copy", (PyCFunction)PyVector::copy, METH_NOARGS, "Return a copy of this vector"},
+    {NULL}
+};
+
+namespace mcrfpydef {
+    PyNumberMethods PyVector_as_number = {
+        .nb_add = PyVector::add,
+        .nb_subtract = PyVector::subtract,
+        .nb_multiply = PyVector::multiply,
+        .nb_remainder = 0,
+        .nb_divmod = 0,
+        .nb_power = 0,
+        .nb_negative = PyVector::negative,
+        .nb_positive = 0,
+        .nb_absolute = PyVector::absolute,
+        .nb_bool = PyVector::bool_check,
+        .nb_invert = 0,
+        .nb_lshift = 0,
+        .nb_rshift = 0,
+        .nb_and = 0,
+        .nb_xor = 0,
+        .nb_or = 0,
+        .nb_int = 0,
+        .nb_reserved = 0,
+        .nb_float = 0,
+        .nb_inplace_add = 0,
+        .nb_inplace_subtract = 0,
+        .nb_inplace_multiply = 0,
+        .nb_inplace_remainder = 0,
+        .nb_inplace_power = 0,
+        .nb_inplace_lshift = 0,
+        .nb_inplace_rshift = 0,
+        .nb_inplace_and = 0,
+        .nb_inplace_xor = 0,
+        .nb_inplace_or = 0,
+        .nb_floor_divide = 0,
+        .nb_true_divide = PyVector::divide,
+        .nb_inplace_floor_divide = 0,
+        .nb_inplace_true_divide = 0,
+        .nb_index = 0,
+        .nb_matrix_multiply = 0,
+        .nb_inplace_matrix_multiply = 0
+    };
+}
+
+PyVector::PyVector(sf::Vector2f target)
+:data(target) {}
+
+PyObject* PyVector::pyObject()
+{
+    PyTypeObject* type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    if (!type) return nullptr;
+    
+    PyVectorObject* obj = (PyVectorObject*)type->tp_alloc(type, 0);
+    Py_DECREF(type);
+    
+    if (obj) {
+        obj->data = data;
+    }
+    return (PyObject*)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)
+{
+    PyVectorObject* self = (PyVectorObject*)obj;
+    if (reinterpret_cast<long>(closure) == 0) {
+        // x
+        return PyFloat_FromDouble(self->data.x);
+    } else {
+        // y
+        return PyFloat_FromDouble(self->data.y);
+    }
+}
+
+int PyVector::set_member(PyObject* obj, PyObject* value, void* closure)
+{
+    PyVectorObject* self = (PyVectorObject*)obj;
+    float val;
+    
+    if (PyFloat_Check(value)) {
+        val = PyFloat_AsDouble(value);
+    } else if (PyLong_Check(value)) {
+        val = PyLong_AsDouble(value);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "Vector members must be numeric");
+        return -1;
+    }
+    
+    if (reinterpret_cast<long>(closure) == 0) {
+        // x
+        self->data.x = val;
+    } else {
+        // y
+        self->data.y = val;
+    }
+    return 0;
+}
+
+PyVectorObject* PyVector::from_arg(PyObject* args)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    if (PyObject_IsInstance(args, (PyObject*)type)) return (PyVectorObject*)args;
+    
+    auto obj = (PyVectorObject*)type->tp_alloc(type, 0);
+    
+    // Handle different input types
+    if (PyTuple_Check(args)) {
+        // It's already a tuple, pass it directly to init
+        int err = init(obj, args, NULL);
+        if (err) {
+            Py_DECREF(obj);
+            return NULL;
+        }
+    } else {
+        // Wrap single argument in a tuple for init
+        PyObject* tuple = PyTuple_Pack(1, args);
+        if (!tuple) {
+            Py_DECREF(obj);
+            return NULL;
+        }
+        int err = init(obj, tuple, NULL);
+        Py_DECREF(tuple);
+        if (err) {
+            Py_DECREF(obj);
+            return NULL;
+        }
+    }
+    
+    return obj;
+}
+
+// Arithmetic operations
+PyObject* PyVector::add(PyObject* left, PyObject* right)
+{
+    // Check if both operands are vectors
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    PyVectorObject* vec1 = nullptr;
+    PyVectorObject* vec2 = nullptr;
+    
+    if (PyObject_IsInstance(left, (PyObject*)type) && PyObject_IsInstance(right, (PyObject*)type)) {
+        vec1 = (PyVectorObject*)left;
+        vec2 = (PyVectorObject*)right;
+    } else {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    if (result) {
+        result->data = sf::Vector2f(vec1->data.x + vec2->data.x, vec1->data.y + vec2->data.y);
+    }
+    return (PyObject*)result;
+}
+
+PyObject* PyVector::subtract(PyObject* left, PyObject* right)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    PyVectorObject* vec1 = nullptr;
+    PyVectorObject* vec2 = nullptr;
+    
+    if (PyObject_IsInstance(left, (PyObject*)type) && PyObject_IsInstance(right, (PyObject*)type)) {
+        vec1 = (PyVectorObject*)left;
+        vec2 = (PyVectorObject*)right;
+    } else {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    if (result) {
+        result->data = sf::Vector2f(vec1->data.x - vec2->data.x, vec1->data.y - vec2->data.y);
+    }
+    return (PyObject*)result;
+}
+
+PyObject* PyVector::multiply(PyObject* left, PyObject* right)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    PyVectorObject* vec = nullptr;
+    double scalar = 0.0;
+    
+    // Check for Vector * scalar
+    if (PyObject_IsInstance(left, (PyObject*)type) && (PyFloat_Check(right) || PyLong_Check(right))) {
+        vec = (PyVectorObject*)left;
+        scalar = PyFloat_AsDouble(right);
+    }
+    // Check for scalar * Vector
+    else if ((PyFloat_Check(left) || PyLong_Check(left)) && PyObject_IsInstance(right, (PyObject*)type)) {
+        scalar = PyFloat_AsDouble(left);
+        vec = (PyVectorObject*)right;
+    }
+    else {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    if (result) {
+        result->data = sf::Vector2f(vec->data.x * scalar, vec->data.y * scalar);
+    }
+    return (PyObject*)result;
+}
+
+PyObject* PyVector::divide(PyObject* left, PyObject* right)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    // Only support Vector / scalar
+    if (!PyObject_IsInstance(left, (PyObject*)type) || (!PyFloat_Check(right) && !PyLong_Check(right))) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    
+    PyVectorObject* vec = (PyVectorObject*)left;
+    double scalar = PyFloat_AsDouble(right);
+    
+    if (scalar == 0.0) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "Vector division by zero");
+        return NULL;
+    }
+    
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    if (result) {
+        result->data = sf::Vector2f(vec->data.x / scalar, vec->data.y / scalar);
+    }
+    return (PyObject*)result;
+}
+
+PyObject* PyVector::negative(PyObject* self)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    PyVectorObject* vec = (PyVectorObject*)self;
+    
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    if (result) {
+        result->data = sf::Vector2f(-vec->data.x, -vec->data.y);
+    }
+    return (PyObject*)result;
+}
+
+PyObject* PyVector::absolute(PyObject* self)
+{
+    PyVectorObject* vec = (PyVectorObject*)self;
+    return PyFloat_FromDouble(std::sqrt(vec->data.x * vec->data.x + vec->data.y * vec->data.y));
+}
+
+int PyVector::bool_check(PyObject* self)
+{
+    PyVectorObject* vec = (PyVectorObject*)self;
+    return (vec->data.x != 0.0f || vec->data.y != 0.0f) ? 1 : 0;
+}
+
+PyObject* PyVector::richcompare(PyObject* left, PyObject* right, int op)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    if (!PyObject_IsInstance(left, (PyObject*)type) || !PyObject_IsInstance(right, (PyObject*)type)) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    
+    PyVectorObject* vec1 = (PyVectorObject*)left;
+    PyVectorObject* vec2 = (PyVectorObject*)right;
+    
+    bool result = false;
+    
+    switch (op) {
+        case Py_EQ:
+            result = (vec1->data.x == vec2->data.x && vec1->data.y == vec2->data.y);
+            break;
+        case Py_NE:
+            result = (vec1->data.x != vec2->data.x || vec1->data.y != vec2->data.y);
+            break;
+        default:
+            Py_INCREF(Py_NotImplemented);
+            return Py_NotImplemented;
+    }
+    
+    if (result)
+        Py_RETURN_TRUE;
+    else
+        Py_RETURN_FALSE;
+}
+
+// Vector-specific methods
+PyObject* PyVector::magnitude(PyVectorObject* self, PyObject* Py_UNUSED(ignored))
+{
+    float mag = std::sqrt(self->data.x * self->data.x + self->data.y * self->data.y);
+    return PyFloat_FromDouble(mag);
+}
+
+PyObject* PyVector::magnitude_squared(PyVectorObject* self, PyObject* Py_UNUSED(ignored))
+{
+    float mag_sq = self->data.x * self->data.x + self->data.y * self->data.y;
+    return PyFloat_FromDouble(mag_sq);
+}
+
+PyObject* PyVector::normalize(PyVectorObject* self, PyObject* Py_UNUSED(ignored))
+{
+    float mag = std::sqrt(self->data.x * self->data.x + self->data.y * self->data.y);
+    
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    
+    if (result) {
+        if (mag > 0.0f) {
+            result->data = sf::Vector2f(self->data.x / mag, self->data.y / mag);
+        } else {
+            // Zero vector remains zero
+            result->data = sf::Vector2f(0.0f, 0.0f);
+        }
+    }
+    
+    return (PyObject*)result;
+}
+
+PyObject* PyVector::dot(PyVectorObject* self, PyObject* other)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    if (!PyObject_IsInstance(other, (PyObject*)type)) {
+        PyErr_SetString(PyExc_TypeError, "Argument must be a Vector");
+        return NULL;
+    }
+    
+    PyVectorObject* vec2 = (PyVectorObject*)other;
+    float dot_product = self->data.x * vec2->data.x + self->data.y * vec2->data.y;
+    
+    return PyFloat_FromDouble(dot_product);
+}
+
+PyObject* PyVector::distance_to(PyVectorObject* self, PyObject* other)
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    
+    if (!PyObject_IsInstance(other, (PyObject*)type)) {
+        PyErr_SetString(PyExc_TypeError, "Argument must be a Vector");
+        return NULL;
+    }
+    
+    PyVectorObject* vec2 = (PyVectorObject*)other;
+    float dx = self->data.x - vec2->data.x;
+    float dy = self->data.y - vec2->data.y;
+    float distance = std::sqrt(dx * dx + dy * dy);
+    
+    return PyFloat_FromDouble(distance);
+}
+
+PyObject* PyVector::angle(PyVectorObject* self, PyObject* Py_UNUSED(ignored))
+{
+    float angle_rad = std::atan2(self->data.y, self->data.x);
+    return PyFloat_FromDouble(angle_rad);
+}
+
+PyObject* PyVector::copy(PyVectorObject* self, PyObject* Py_UNUSED(ignored))
+{
+    auto type = (PyTypeObject*)PyObject_GetAttrString(McRFPy_API::mcrf_module, "Vector");
+    auto result = (PyVectorObject*)type->tp_alloc(type, 0);
+    
+    if (result) {
+        result->data = self->data;
+    }
+    
+    return (PyObject*)result;
+}

src/PyVector.h

@@ -0,0 +1,73 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+#include "McRFPy_API.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 PyVectorObject* from_arg(PyObject*);
+    
+    // Arithmetic operations
+    static PyObject* add(PyObject*, PyObject*);
+    static PyObject* subtract(PyObject*, PyObject*);
+    static PyObject* multiply(PyObject*, PyObject*);
+    static PyObject* divide(PyObject*, PyObject*);
+    static PyObject* negative(PyObject*);
+    static PyObject* absolute(PyObject*);
+    static int bool_check(PyObject*);
+    
+    // Comparison operations
+    static PyObject* richcompare(PyObject*, PyObject*, int);
+    
+    // Vector operations
+    static PyObject* magnitude(PyVectorObject*, PyObject*);
+    static PyObject* magnitude_squared(PyVectorObject*, PyObject*);
+    static PyObject* normalize(PyVectorObject*, PyObject*);
+    static PyObject* dot(PyVectorObject*, PyObject*);
+    static PyObject* distance_to(PyVectorObject*, PyObject*);
+    static PyObject* angle(PyVectorObject*, PyObject*);
+    static PyObject* copy(PyVectorObject*, PyObject*);
+    
+    static PyGetSetDef getsetters[];
+    static PyMethodDef methods[];
+};
+
+namespace mcrfpydef {
+    // Forward declare the PyNumberMethods structure
+    extern PyNumberMethods PyVector_as_number;
+    
+    static PyTypeObject PyVectorType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .tp_name = "mcrfpy.Vector",
+        .tp_basicsize = sizeof(PyVectorObject),
+        .tp_itemsize = 0,
+        .tp_repr = PyVector::repr,
+        .tp_as_number = &PyVector_as_number,
+        .tp_hash = PyVector::hash,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+        .tp_doc = PyDoc_STR("SFML Vector Object"),
+        .tp_richcompare = PyVector::richcompare,
+        .tp_methods = PyVector::methods,
+        .tp_getset = PyVector::getsetters,
+        .tp_init = (initproc)PyVector::init,
+        .tp_new = PyVector::pynew,
+    };
+}

src/PyWindow.cpp

@@ -0,0 +1,514 @@
+#include "PyWindow.h"
+#include "GameEngine.h"
+#include "McRFPy_API.h"
+#include <SFML/Graphics.hpp>
+#include <cstring>
+
+// Singleton instance - static variable, not a class member
+static PyWindowObject* window_instance = nullptr;
+
+PyObject* PyWindow::get(PyObject* cls, PyObject* args)
+{
+    // Create singleton instance if it doesn't exist
+    if (!window_instance) {
+        // Use the class object passed as first argument
+        PyTypeObject* type = (PyTypeObject*)cls;
+        
+        if (!type->tp_alloc) {
+            PyErr_SetString(PyExc_RuntimeError, "Window type not properly initialized");
+            return NULL;
+        }
+        
+        window_instance = (PyWindowObject*)type->tp_alloc(type, 0);
+        if (!window_instance) {
+            return NULL;
+        }
+    }
+    
+    Py_INCREF(window_instance);
+    return (PyObject*)window_instance;
+}
+
+PyObject* PyWindow::repr(PyWindowObject* self)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        return PyUnicode_FromString("<Window [no game engine]>");
+    }
+    
+    if (game->isHeadless()) {
+        return PyUnicode_FromString("<Window [headless mode]>");
+    }
+    
+    auto& window = game->getWindow();
+    auto size = window.getSize();
+    
+    return PyUnicode_FromFormat("<Window %dx%d>", size.x, size.y);
+}
+
+// Property getters and setters
+
+PyObject* PyWindow::get_resolution(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    if (game->isHeadless()) {
+        // Return headless renderer size
+        return Py_BuildValue("(ii)", 1024, 768);  // Default headless size
+    }
+    
+    auto& window = game->getWindow();
+    auto size = window.getSize();
+    return Py_BuildValue("(ii)", size.x, size.y);
+}
+
+int PyWindow::set_resolution(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    if (game->isHeadless()) {
+        PyErr_SetString(PyExc_RuntimeError, "Cannot change resolution in headless mode");
+        return -1;
+    }
+    
+    int width, height;
+    if (!PyArg_ParseTuple(value, "ii", &width, &height)) {
+        PyErr_SetString(PyExc_TypeError, "Resolution must be a tuple of two integers (width, height)");
+        return -1;
+    }
+    
+    if (width <= 0 || height <= 0) {
+        PyErr_SetString(PyExc_ValueError, "Resolution dimensions must be positive");
+        return -1;
+    }
+    
+    auto& window = game->getWindow();
+    
+    // Get current window settings
+    auto style = sf::Style::Titlebar | sf::Style::Close;
+    if (window.getSize() == sf::Vector2u(sf::VideoMode::getDesktopMode().width, 
+                                         sf::VideoMode::getDesktopMode().height)) {
+        style = sf::Style::Fullscreen;
+    }
+    
+    // Recreate window with new size
+    window.create(sf::VideoMode(width, height), game->getWindowTitle(), style);
+    
+    // Restore vsync and framerate settings
+    // Note: We'll need to store these settings in GameEngine
+    window.setFramerateLimit(60);  // Default for now
+    
+    return 0;
+}
+
+PyObject* PyWindow::get_fullscreen(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    if (game->isHeadless()) {
+        Py_RETURN_FALSE;
+    }
+    
+    auto& window = game->getWindow();
+    auto size = window.getSize();
+    auto desktop = sf::VideoMode::getDesktopMode();
+    
+    // Check if window size matches desktop size (rough fullscreen check)
+    bool fullscreen = (size.x == desktop.width && size.y == desktop.height);
+    
+    return PyBool_FromLong(fullscreen);
+}
+
+int PyWindow::set_fullscreen(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    if (game->isHeadless()) {
+        PyErr_SetString(PyExc_RuntimeError, "Cannot change fullscreen in headless mode");
+        return -1;
+    }
+    
+    if (!PyBool_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "Fullscreen must be a boolean");
+        return -1;
+    }
+    
+    bool fullscreen = PyObject_IsTrue(value);
+    auto& window = game->getWindow();
+    
+    if (fullscreen) {
+        // Switch to fullscreen
+        auto desktop = sf::VideoMode::getDesktopMode();
+        window.create(desktop, game->getWindowTitle(), sf::Style::Fullscreen);
+    } else {
+        // Switch to windowed mode
+        window.create(sf::VideoMode(1024, 768), game->getWindowTitle(), 
+                     sf::Style::Titlebar | sf::Style::Close);
+    }
+    
+    // Restore settings
+    window.setFramerateLimit(60);
+    
+    return 0;
+}
+
+PyObject* PyWindow::get_vsync(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    return PyBool_FromLong(game->getVSync());
+}
+
+int PyWindow::set_vsync(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    if (game->isHeadless()) {
+        PyErr_SetString(PyExc_RuntimeError, "Cannot change vsync in headless mode");
+        return -1;
+    }
+    
+    if (!PyBool_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "vsync must be a boolean");
+        return -1;
+    }
+    
+    bool vsync = PyObject_IsTrue(value);
+    game->setVSync(vsync);
+    
+    return 0;
+}
+
+PyObject* PyWindow::get_title(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    return PyUnicode_FromString(game->getWindowTitle().c_str());
+}
+
+int PyWindow::set_title(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    if (game->isHeadless()) {
+        // Silently ignore in headless mode
+        return 0;
+    }
+    
+    const char* title = PyUnicode_AsUTF8(value);
+    if (!title) {
+        PyErr_SetString(PyExc_TypeError, "Title must be a string");
+        return -1;
+    }
+    
+    game->setWindowTitle(title);
+    
+    return 0;
+}
+
+PyObject* PyWindow::get_visible(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    if (game->isHeadless()) {
+        Py_RETURN_FALSE;
+    }
+    
+    auto& window = game->getWindow();
+    bool visible = window.isOpen();  // Best approximation
+    
+    return PyBool_FromLong(visible);
+}
+
+int PyWindow::set_visible(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    if (game->isHeadless()) {
+        // Silently ignore in headless mode
+        return 0;
+    }
+    
+    if (!PyBool_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "visible must be a boolean");
+        return -1;
+    }
+    
+    bool visible = PyObject_IsTrue(value);
+    auto& window = game->getWindow();
+    window.setVisible(visible);
+    
+    return 0;
+}
+
+PyObject* PyWindow::get_framerate_limit(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    return PyLong_FromLong(game->getFramerateLimit());
+}
+
+int PyWindow::set_framerate_limit(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    if (game->isHeadless()) {
+        // Silently ignore in headless mode
+        return 0;
+    }
+    
+    long limit = PyLong_AsLong(value);
+    if (PyErr_Occurred()) {
+        PyErr_SetString(PyExc_TypeError, "framerate_limit must be an integer");
+        return -1;
+    }
+    
+    if (limit < 0) {
+        PyErr_SetString(PyExc_ValueError, "framerate_limit must be non-negative (0 for unlimited)");
+        return -1;
+    }
+    
+    game->setFramerateLimit(limit);
+    
+    return 0;
+}
+
+// Methods
+
+PyObject* PyWindow::center(PyWindowObject* self, PyObject* args)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    if (game->isHeadless()) {
+        PyErr_SetString(PyExc_RuntimeError, "Cannot center window in headless mode");
+        return NULL;
+    }
+    
+    auto& window = game->getWindow();
+    auto size = window.getSize();
+    auto desktop = sf::VideoMode::getDesktopMode();
+    
+    int x = (desktop.width - size.x) / 2;
+    int y = (desktop.height - size.y) / 2;
+    
+    window.setPosition(sf::Vector2i(x, y));
+    
+    Py_RETURN_NONE;
+}
+
+PyObject* PyWindow::screenshot(PyWindowObject* self, PyObject* args, PyObject* kwds)
+{
+    static const char* keywords[] = {"filename", NULL};
+    const char* filename = nullptr;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s", const_cast<char**>(keywords), &filename)) {
+        return NULL;
+    }
+    
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    // Get the render target pointer
+    sf::RenderTarget* target = game->getRenderTargetPtr();
+    if (!target) {
+        PyErr_SetString(PyExc_RuntimeError, "No render target available");
+        return NULL;
+    }
+    
+    sf::Image screenshot;
+    
+    // For RenderWindow
+    if (auto* window = dynamic_cast<sf::RenderWindow*>(target)) {
+        sf::Vector2u windowSize = window->getSize();
+        sf::Texture texture;
+        texture.create(windowSize.x, windowSize.y);
+        texture.update(*window);
+        screenshot = texture.copyToImage();
+    }
+    // For RenderTexture (headless mode)
+    else if (auto* renderTexture = dynamic_cast<sf::RenderTexture*>(target)) {
+        screenshot = renderTexture->getTexture().copyToImage();
+    }
+    else {
+        PyErr_SetString(PyExc_RuntimeError, "Unknown render target type");
+        return NULL;
+    }
+    
+    // Save to file if filename provided
+    if (filename) {
+        if (!screenshot.saveToFile(filename)) {
+            PyErr_SetString(PyExc_IOError, "Failed to save screenshot");
+            return NULL;
+        }
+        Py_RETURN_NONE;
+    }
+    
+    // Otherwise return as bytes
+    auto pixels = screenshot.getPixelsPtr();
+    auto size = screenshot.getSize();
+    
+    return PyBytes_FromStringAndSize((const char*)pixels, size.x * size.y * 4);
+}
+
+PyObject* PyWindow::get_game_resolution(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    auto resolution = game->getGameResolution();
+    return Py_BuildValue("(ii)", resolution.x, resolution.y);
+}
+
+int PyWindow::set_game_resolution(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    int width, height;
+    if (!PyArg_ParseTuple(value, "ii", &width, &height)) {
+        PyErr_SetString(PyExc_TypeError, "game_resolution must be a tuple of two integers (width, height)");
+        return -1;
+    }
+    
+    if (width <= 0 || height <= 0) {
+        PyErr_SetString(PyExc_ValueError, "Game resolution dimensions must be positive");
+        return -1;
+    }
+    
+    game->setGameResolution(width, height);
+    return 0;
+}
+
+PyObject* PyWindow::get_scaling_mode(PyWindowObject* self, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return NULL;
+    }
+    
+    return PyUnicode_FromString(game->getViewportModeString().c_str());
+}
+
+int PyWindow::set_scaling_mode(PyWindowObject* self, PyObject* value, void* closure)
+{
+    GameEngine* game = McRFPy_API::game;
+    if (!game) {
+        PyErr_SetString(PyExc_RuntimeError, "No game engine initialized");
+        return -1;
+    }
+    
+    const char* mode_str = PyUnicode_AsUTF8(value);
+    if (!mode_str) {
+        PyErr_SetString(PyExc_TypeError, "scaling_mode must be a string");
+        return -1;
+    }
+    
+    GameEngine::ViewportMode mode;
+    if (strcmp(mode_str, "center") == 0) {
+        mode = GameEngine::ViewportMode::Center;
+    } else if (strcmp(mode_str, "stretch") == 0) {
+        mode = GameEngine::ViewportMode::Stretch;
+    } else if (strcmp(mode_str, "fit") == 0) {
+        mode = GameEngine::ViewportMode::Fit;
+    } else {
+        PyErr_SetString(PyExc_ValueError, "scaling_mode must be 'center', 'stretch', or 'fit'");
+        return -1;
+    }
+    
+    game->setViewportMode(mode);
+    return 0;
+}
+
+// Property definitions
+PyGetSetDef PyWindow::getsetters[] = {
+    {"resolution", (getter)get_resolution, (setter)set_resolution, 
+     "Window resolution as (width, height) tuple", NULL},
+    {"fullscreen", (getter)get_fullscreen, (setter)set_fullscreen,
+     "Window fullscreen state", NULL},
+    {"vsync", (getter)get_vsync, (setter)set_vsync,
+     "Vertical sync enabled state", NULL},
+    {"title", (getter)get_title, (setter)set_title,
+     "Window title string", NULL},
+    {"visible", (getter)get_visible, (setter)set_visible,
+     "Window visibility state", NULL},
+    {"framerate_limit", (getter)get_framerate_limit, (setter)set_framerate_limit,
+     "Frame rate limit (0 for unlimited)", NULL},
+    {"game_resolution", (getter)get_game_resolution, (setter)set_game_resolution,
+     "Fixed game resolution as (width, height) tuple", NULL},
+    {"scaling_mode", (getter)get_scaling_mode, (setter)set_scaling_mode,
+     "Viewport scaling mode: 'center', 'stretch', or 'fit'", NULL},
+    {NULL}
+};
+
+// Method definitions
+PyMethodDef PyWindow::methods[] = {
+    {"get", (PyCFunction)PyWindow::get, METH_VARARGS | METH_CLASS,
+     "Get the Window singleton instance"},
+    {"center", (PyCFunction)PyWindow::center, METH_NOARGS,
+     "Center the window on the screen"},
+    {"screenshot", (PyCFunction)PyWindow::screenshot, METH_VARARGS | METH_KEYWORDS,
+     "Take a screenshot. Pass filename to save to file, or get raw bytes if no filename."},
+    {NULL}
+};

src/PyWindow.h

@@ -0,0 +1,69 @@
+#pragma once
+#include "Common.h"
+#include "Python.h"
+
+// Forward declarations
+class GameEngine;
+
+// Python object structure for Window singleton
+typedef struct {
+    PyObject_HEAD
+    // No data - Window is a singleton that accesses GameEngine
+} PyWindowObject;
+
+// C++ interface for the Window singleton
+class PyWindow
+{
+public:
+    // Static methods for Python type
+    static PyObject* get(PyObject* cls, PyObject* args);
+    static PyObject* repr(PyWindowObject* self);
+    
+    // Getters and setters for window properties
+    static PyObject* get_resolution(PyWindowObject* self, void* closure);
+    static int set_resolution(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_fullscreen(PyWindowObject* self, void* closure);
+    static int set_fullscreen(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_vsync(PyWindowObject* self, void* closure);
+    static int set_vsync(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_title(PyWindowObject* self, void* closure);
+    static int set_title(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_visible(PyWindowObject* self, void* closure);
+    static int set_visible(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_framerate_limit(PyWindowObject* self, void* closure);
+    static int set_framerate_limit(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_game_resolution(PyWindowObject* self, void* closure);
+    static int set_game_resolution(PyWindowObject* self, PyObject* value, void* closure);
+    static PyObject* get_scaling_mode(PyWindowObject* self, void* closure);
+    static int set_scaling_mode(PyWindowObject* self, PyObject* value, void* closure);
+    
+    // Methods
+    static PyObject* center(PyWindowObject* self, PyObject* args);
+    static PyObject* screenshot(PyWindowObject* self, PyObject* args, PyObject* kwds);
+    
+    static PyGetSetDef getsetters[];
+    static PyMethodDef methods[];
+    
+};
+
+namespace mcrfpydef {
+    static PyTypeObject PyWindowType = {
+        .ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0},
+        .tp_name = "mcrfpy.Window",
+        .tp_basicsize = sizeof(PyWindowObject),
+        .tp_itemsize = 0,
+        .tp_dealloc = (destructor)[](PyObject* self) {
+            // Don't delete the singleton instance
+            Py_TYPE(self)->tp_free(self);
+        },
+        .tp_repr = (reprfunc)PyWindow::repr,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+        .tp_doc = PyDoc_STR("Window singleton for accessing and modifying the game window properties"),
+        .tp_methods = nullptr,  // Set in McRFPy_API.cpp after definition
+        .tp_getset = nullptr,   // Set in McRFPy_API.cpp after definition
+        .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject* {
+            PyErr_SetString(PyExc_TypeError, "Cannot instantiate Window. Use Window.get() to access the singleton.");
+            return NULL;
+        }
+    };
+}

src/PythonObjectCache.cpp

@@ -0,0 +1,85 @@
+#include "PythonObjectCache.h"
+#include <iostream>
+
+PythonObjectCache* PythonObjectCache::instance = nullptr;
+
+PythonObjectCache& PythonObjectCache::getInstance() {
+    if (!instance) {
+        instance = new PythonObjectCache();
+    }
+    return *instance;
+}
+
+PythonObjectCache::~PythonObjectCache() {
+    clear();
+}
+
+uint64_t PythonObjectCache::assignSerial() {
+    return next_serial.fetch_add(1, std::memory_order_relaxed);
+}
+
+void PythonObjectCache::registerObject(uint64_t serial, PyObject* weakref) {
+    if (!weakref || serial == 0) return;
+    
+    std::lock_guard<std::mutex> lock(serial_mutex);
+    
+    // Clean up any existing entry
+    auto it = cache.find(serial);
+    if (it != cache.end()) {
+        Py_DECREF(it->second);
+    }
+    
+    // Store the new weak reference
+    Py_INCREF(weakref);
+    cache[serial] = weakref;
+}
+
+PyObject* PythonObjectCache::lookup(uint64_t serial) {
+    if (serial == 0) return nullptr;
+    
+    // No mutex needed for read - GIL protects PyWeakref_GetObject
+    auto it = cache.find(serial);
+    if (it != cache.end()) {
+        PyObject* obj = PyWeakref_GetObject(it->second);
+        if (obj && obj != Py_None) {
+            Py_INCREF(obj);
+            return obj;
+        }
+    }
+    return nullptr;
+}
+
+void PythonObjectCache::remove(uint64_t serial) {
+    if (serial == 0) return;
+    
+    std::lock_guard<std::mutex> lock(serial_mutex);
+    auto it = cache.find(serial);
+    if (it != cache.end()) {
+        Py_DECREF(it->second);
+        cache.erase(it);
+    }
+}
+
+void PythonObjectCache::cleanup() {
+    std::lock_guard<std::mutex> lock(serial_mutex);
+    
+    auto it = cache.begin();
+    while (it != cache.end()) {
+        PyObject* obj = PyWeakref_GetObject(it->second);
+        if (!obj || obj == Py_None) {
+            Py_DECREF(it->second);
+            it = cache.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+void PythonObjectCache::clear() {
+    std::lock_guard<std::mutex> lock(serial_mutex);
+    
+    for (auto& pair : cache) {
+        Py_DECREF(pair.second);
+    }
+    cache.clear();
+}

src/PythonObjectCache.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <Python.h>
+#include <unordered_map>
+#include <mutex>
+#include <atomic>
+#include <cstdint>
+
+class PythonObjectCache {
+private:
+    static PythonObjectCache* instance;
+    std::mutex serial_mutex;
+    std::atomic<uint64_t> next_serial{1};
+    std::unordered_map<uint64_t, PyObject*> cache;
+    
+    PythonObjectCache() = default;
+    ~PythonObjectCache();
+
+public:
+    static PythonObjectCache& getInstance();
+    
+    // Assign a new serial number
+    uint64_t assignSerial();
+    
+    // Register a Python object with a serial number
+    void registerObject(uint64_t serial, PyObject* weakref);
+    
+    // Lookup a Python object by serial number
+    // Returns new reference or nullptr
+    PyObject* lookup(uint64_t serial);
+    
+    // Remove an entry from the cache
+    void remove(uint64_t serial);
+    
+    // Clean up dead weak references
+    void cleanup();
+    
+    // Clear entire cache (for module cleanup)
+    void clear();
+};

src/Scene.cpp

@@ -30,16 +30,6 @@ std::string Scene::action(int code)
     return actions[code];
 }
 
-bool Scene::registerActionInjected(int code, std::string name)
-{
-    std::cout << "Inject registered action - default implementation\n";
-    return false;
-}
-
-bool Scene::unregisterActionInjected(int code, std::string name)
-{
-    return false;
-}
 
 void Scene::key_register(PyObject* callable)
 {

src/Scene.h

@@ -4,7 +4,6 @@
 #define ACTION(X, Y) (name.compare(X) == 0 && type.compare(Y) == 0)
 #define ACTIONONCE(X) ((name.compare(X) == 0 && type.compare("start") == 0 && !actionState[name]))
 #define ACTIONAFTER(X) ((name.compare(X) == 0 && type.compare("end") == 0))
-#define ACTIONPY ((name.size() > 3 && name.compare(name.size() - 3, 3, "_py") == 0))
 
 #include "Common.h"
 #include <list>
@@ -31,14 +30,12 @@ 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);
     std::string action(int);
     
-    virtual bool registerActionInjected(int, std::string);
-    virtual bool unregisterActionInjected(int, std::string);
     
     std::shared_ptr<std::vector<std::shared_ptr<UIDrawable>>> ui_elements;
 

src/SceneTransition.cpp

@@ -0,0 +1,85 @@
+#include "SceneTransition.h"
+
+void SceneTransition::start(TransitionType t, const std::string& from, const std::string& to, float dur) {
+    type = t;
+    fromScene = from;
+    toScene = to;
+    duration = dur;
+    elapsed = 0.0f;
+    
+    // Initialize render textures if needed
+    if (!oldSceneTexture) {
+        oldSceneTexture = std::make_unique<sf::RenderTexture>();
+        oldSceneTexture->create(1024, 768);
+    }
+    if (!newSceneTexture) {
+        newSceneTexture = std::make_unique<sf::RenderTexture>();
+        newSceneTexture->create(1024, 768);
+    }
+}
+
+void SceneTransition::update(float dt) {
+    if (type == TransitionType::None) return;
+    elapsed += dt;
+}
+
+void SceneTransition::render(sf::RenderTarget& target) {
+    if (type == TransitionType::None) return;
+    
+    float progress = getProgress();
+    float easedProgress = easeInOut(progress);
+    
+    // Update sprites with current textures
+    oldSprite.setTexture(oldSceneTexture->getTexture());
+    newSprite.setTexture(newSceneTexture->getTexture());
+    
+    switch (type) {
+        case TransitionType::Fade:
+            // Fade out old scene, fade in new scene
+            oldSprite.setColor(sf::Color(255, 255, 255, 255 * (1.0f - easedProgress)));
+            newSprite.setColor(sf::Color(255, 255, 255, 255 * easedProgress));
+            target.draw(oldSprite);
+            target.draw(newSprite);
+            break;
+            
+        case TransitionType::SlideLeft:
+            // Old scene slides out to left, new scene slides in from right
+            oldSprite.setPosition(-1024 * easedProgress, 0);
+            newSprite.setPosition(1024 * (1.0f - easedProgress), 0);
+            target.draw(oldSprite);
+            target.draw(newSprite);
+            break;
+            
+        case TransitionType::SlideRight:
+            // Old scene slides out to right, new scene slides in from left
+            oldSprite.setPosition(1024 * easedProgress, 0);
+            newSprite.setPosition(-1024 * (1.0f - easedProgress), 0);
+            target.draw(oldSprite);
+            target.draw(newSprite);
+            break;
+            
+        case TransitionType::SlideUp:
+            // Old scene slides up, new scene slides in from bottom
+            oldSprite.setPosition(0, -768 * easedProgress);
+            newSprite.setPosition(0, 768 * (1.0f - easedProgress));
+            target.draw(oldSprite);
+            target.draw(newSprite);
+            break;
+            
+        case TransitionType::SlideDown:
+            // Old scene slides down, new scene slides in from top
+            oldSprite.setPosition(0, 768 * easedProgress);
+            newSprite.setPosition(0, -768 * (1.0f - easedProgress));
+            target.draw(oldSprite);
+            target.draw(newSprite);
+            break;
+            
+        default:
+            break;
+    }
+}
+
+float SceneTransition::easeInOut(float t) {
+    // Smooth ease-in-out curve
+    return t < 0.5f ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}

src/SceneTransition.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "Common.h"
+#include <SFML/Graphics.hpp>
+#include <string>
+#include <memory>
+
+enum class TransitionType {
+    None,
+    Fade,
+    SlideLeft,
+    SlideRight,
+    SlideUp,
+    SlideDown
+};
+
+class SceneTransition {
+public:
+    TransitionType type = TransitionType::None;
+    float duration = 0.0f;
+    float elapsed = 0.0f;
+    std::string fromScene;
+    std::string toScene;
+    
+    // Render textures for transition
+    std::unique_ptr<sf::RenderTexture> oldSceneTexture;
+    std::unique_ptr<sf::RenderTexture> newSceneTexture;
+    
+    // Sprites for rendering textures
+    sf::Sprite oldSprite;
+    sf::Sprite newSprite;
+    
+    SceneTransition() = default;
+    
+    void start(TransitionType t, const std::string& from, const std::string& to, float dur);
+    void update(float dt);
+    void render(sf::RenderTarget& target);
+    bool isComplete() const { return elapsed >= duration; }
+    float getProgress() const { return duration > 0 ? std::min(elapsed / duration, 1.0f) : 1.0f; }
+    
+    // Easing function for smooth transitions
+    static float easeInOut(float t);
+};

src/Timer.cpp

@@ -1,31 +1,140 @@
 #include "Timer.h"
+#include "PythonObjectCache.h"
+#include "PyCallable.h"
 
-Timer::Timer(PyObject* _target, int _interval, int now)
-: target(_target), interval(_interval), last_ran(now)
+Timer::Timer(PyObject* _target, int _interval, int now, bool _once)
+: callback(std::make_shared<PyCallable>(_target)), interval(_interval), last_ran(now),
+  paused(false), pause_start_time(0), total_paused_time(0), once(_once)
 {}
 
 Timer::Timer()
-: target(Py_None), interval(0), last_ran(0)
+: callback(std::make_shared<PyCallable>(Py_None)), interval(0), last_ran(0),
+  paused(false), pause_start_time(0), total_paused_time(0), once(false)
 {}
 
+Timer::~Timer() {
+    if (serial_number != 0) {
+        PythonObjectCache::getInstance().remove(serial_number);
+    }
+}
+
+bool Timer::hasElapsed(int now) const
+{
+    if (paused) return false;
+    return now >= last_ran + interval;
+}
+
 bool Timer::test(int now)
 {
-    if (!target || target == Py_None) return false;
-    if (now > last_ran + interval)
+    if (!callback || callback->isNone()) return false;
+    
+    if (hasElapsed(now))
     {
         last_ran = now;
-        PyObject* args = Py_BuildValue("(i)", now);
-        PyObject* retval = PyObject_Call(target, args, NULL);
+        
+        // Get the PyTimer wrapper from cache to pass to callback
+        PyObject* timer_obj = nullptr;
+        if (serial_number != 0) {
+            timer_obj = PythonObjectCache::getInstance().lookup(serial_number);
+        }
+        
+        // Build args: (timer, runtime) or just (runtime) if no wrapper found
+        PyObject* args;
+        if (timer_obj) {
+            args = Py_BuildValue("(Oi)", timer_obj, now);
+        } else {
+            // Fallback to old behavior if no wrapper found
+            args = Py_BuildValue("(i)", now);
+        }
+        
+        PyObject* retval = callback->call(args, NULL);
+        Py_DECREF(args);
+        
         if (!retval)
         {   
-            std::cout << "timer has raised an exception. It's going to STDERR and being dropped:" << std::endl;
+            std::cout << "Timer callback 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;
+            std::cout << "Timer returned a non-None value. It's not an error, it's just not being saved or used." << std::endl;
+            Py_DECREF(retval);
         }
+        
+        // Handle one-shot timers
+        if (once) {
+            cancel();
+        }
+        
         return true;
     }
     return false;
 }
+
+void Timer::pause(int current_time)
+{
+    if (!paused) {
+        paused = true;
+        pause_start_time = current_time;
+    }
+}
+
+void Timer::resume(int current_time)
+{
+    if (paused) {
+        paused = false;
+        int paused_duration = current_time - pause_start_time;
+        total_paused_time += paused_duration;
+        // Adjust last_ran to account for the pause
+        last_ran += paused_duration;
+    }
+}
+
+void Timer::restart(int current_time)
+{
+    last_ran = current_time;
+    paused = false;
+    pause_start_time = 0;
+    total_paused_time = 0;
+}
+
+void Timer::cancel()
+{
+    // Cancel by setting callback to None
+    callback = std::make_shared<PyCallable>(Py_None);
+}
+
+bool Timer::isActive() const
+{
+    return callback && !callback->isNone() && !paused;
+}
+
+int Timer::getRemaining(int current_time) const
+{
+    if (paused) {
+        // When paused, calculate time remaining from when it was paused
+        int elapsed_when_paused = pause_start_time - last_ran;
+        return interval - elapsed_when_paused;
+    }
+    int elapsed = current_time - last_ran;
+    return interval - elapsed;
+}
+
+int Timer::getElapsed(int current_time) const
+{
+    if (paused) {
+        return pause_start_time - last_ran;
+    }
+    return current_time - last_ran;
+}
+
+PyObject* Timer::getCallback()
+{
+    if (!callback) return Py_None;
+    return callback->borrow();
+}
+
+void Timer::setCallback(PyObject* new_callback)
+{
+    callback = std::make_shared<PyCallable>(new_callback);
+}

src/Timer.h

@@ -1,15 +1,54 @@
 #pragma once
 #include "Common.h"
 #include "Python.h"
+#include <memory>
+
+class PyCallable;
 class GameEngine; // forward declare
 
 class Timer
 {
-public:
-    PyObject* target;
+private:
+    std::shared_ptr<PyCallable> callback;
     int interval;
     int last_ran;
+    
+    // Pause/resume support
+    bool paused;
+    int pause_start_time;
+    int total_paused_time;
+    
+    // One-shot timer support
+    bool once;
+    
+public:
+    uint64_t serial_number = 0;  // For Python object cache
+    
     Timer(); // for map to build
-    Timer(PyObject*, int, int);
-    bool test(int);
+    Timer(PyObject* target, int interval, int now, bool once = false);
+    ~Timer();
+    
+    // Core timer functionality
+    bool test(int now);
+    bool hasElapsed(int now) const;
+    
+    // Timer control methods
+    void pause(int current_time);
+    void resume(int current_time);
+    void restart(int current_time);
+    void cancel();
+    
+    // Timer state queries
+    bool isPaused() const { return paused; }
+    bool isActive() const;
+    int getInterval() const { return interval; }
+    void setInterval(int new_interval) { interval = new_interval; }
+    int getRemaining(int current_time) const;
+    int getElapsed(int current_time) const;
+    bool isOnce() const { return once; }
+    void setOnce(bool value) { once = value; }
+    
+    // Callback management
+    PyObject* getCallback();
+    void setCallback(PyObject* new_callback);
 };

src/UI.cpp

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

src/UIBase.h

@@ -0,0 +1,139 @@
+#pragma once
+#include "Python.h"
+#include <memory>
+
+class UIEntity;
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UIEntity> data;
+    PyObject* weakreflist;  // Weak reference support
+} PyUIEntityObject;
+
+class UIFrame;
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UIFrame> data;
+    PyObject* weakreflist;  // Weak reference support
+} PyUIFrameObject;
+
+class UICaption;
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UICaption> data;
+    PyObject* font;
+    PyObject* weakreflist;  // Weak reference support
+} PyUICaptionObject;
+
+class UIGrid;
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UIGrid> data;
+    PyObject* weakreflist;  // Weak reference support
+} PyUIGridObject;
+
+class UISprite;
+typedef struct {
+    PyObject_HEAD
+    std::shared_ptr<UISprite> data;
+    PyObject* weakreflist;  // Weak reference support
+} PyUISpriteObject;
+
+// Common Python method implementations for UIDrawable-derived classes
+// These template functions provide shared functionality for Python bindings
+
+// get_bounds method implementation (#89)
+template<typename T>
+static PyObject* UIDrawable_get_bounds(T* self, PyObject* Py_UNUSED(args))
+{
+    auto bounds = self->data->get_bounds();
+    return Py_BuildValue("(ffff)", bounds.left, bounds.top, bounds.width, bounds.height);
+}
+
+// move method implementation (#98)
+template<typename T>
+static PyObject* UIDrawable_move(T* self, PyObject* args)
+{
+    float dx, dy;
+    if (!PyArg_ParseTuple(args, "ff", &dx, &dy)) {
+        return NULL;
+    }
+    
+    self->data->move(dx, dy);
+    Py_RETURN_NONE;
+}
+
+// resize method implementation (#98)
+template<typename T>
+static PyObject* UIDrawable_resize(T* self, PyObject* args)
+{
+    float w, h;
+    if (!PyArg_ParseTuple(args, "ff", &w, &h)) {
+        return NULL;
+    }
+    
+    self->data->resize(w, h);
+    Py_RETURN_NONE;
+}
+
+// Macro to add common UIDrawable methods to a method array
+#define UIDRAWABLE_METHODS \
+    {"get_bounds", (PyCFunction)UIDrawable_get_bounds<PyObjectType>, METH_NOARGS, \
+     "Get bounding box as (x, y, width, height)"}, \
+    {"move", (PyCFunction)UIDrawable_move<PyObjectType>, METH_VARARGS, \
+     "Move by relative offset (dx, dy)"}, \
+    {"resize", (PyCFunction)UIDrawable_resize<PyObjectType>, METH_VARARGS, \
+     "Resize to new dimensions (width, height)"}
+
+// Property getters/setters for visible and opacity
+template<typename T>
+static PyObject* UIDrawable_get_visible(T* self, void* closure)
+{
+    return PyBool_FromLong(self->data->visible);
+}
+
+template<typename T>
+static int UIDrawable_set_visible(T* self, PyObject* value, void* closure)
+{
+    if (!PyBool_Check(value)) {
+        PyErr_SetString(PyExc_TypeError, "visible must be a boolean");
+        return -1;
+    }
+    self->data->visible = PyObject_IsTrue(value);
+    return 0;
+}
+
+template<typename T>
+static PyObject* UIDrawable_get_opacity(T* self, void* closure)
+{
+    return PyFloat_FromDouble(self->data->opacity);
+}
+
+template<typename T>
+static int UIDrawable_set_opacity(T* self, PyObject* value, void* closure)
+{
+    float opacity;
+    if (PyFloat_Check(value)) {
+        opacity = PyFloat_AsDouble(value);
+    } else if (PyLong_Check(value)) {
+        opacity = PyLong_AsDouble(value);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "opacity must be a number");
+        return -1;
+    }
+    
+    // Clamp to valid range
+    if (opacity < 0.0f) opacity = 0.0f;
+    if (opacity > 1.0f) opacity = 1.0f;
+    
+    self->data->opacity = opacity;
+    return 0;
+}
+
+// Macro to add common UIDrawable properties to a getsetters array
+#define UIDRAWABLE_GETSETTERS \
+    {"visible", (getter)UIDrawable_get_visible<PyObjectType>, (setter)UIDrawable_set_visible<PyObjectType>, \
+     "Visibility flag", NULL}, \
+    {"opacity", (getter)UIDrawable_get_opacity<PyObjectType>, (setter)UIDrawable_set_opacity<PyObjectType>, \
+     "Opacity (0.0 = transparent, 1.0 = opaque)", NULL}
+
+// UIEntity specializations are defined in UIEntity.cpp after UIEntity class is complete