* Field of View, Pathing courtesy of libtcod
* python-tcod emulation at `mcrfpy.libtcod` - partial implementation
* documentation, tutorial drafts: in middling to good shape
┌────────────┬────────────────────┬───────────┬────────────┬───────────────┬────────────────┬────────────────┬─────────────┐
│ Date │ Models │ Input │ Output │ Cache Create │ Cache Read │ Total Tokens │ Cost (USD) │
├────────────┼────────────────────┼───────────┼────────────┼───────────────┼────────────────┼────────────────┼─────────────┤
│ 2025-07-05 │ - opus-4 │ 13,630 │ 159,500 │ 3,854,900 │ 84,185,034 │ 88,213,064 │ $210.72 │
├────────────┼────────────────────┼───────────┼────────────┼───────────────┼────────────────┼────────────────┼─────────────┤
│ 2025-07-06 │ - opus-4 │ 5,814 │ 113,190 │ 4,242,407 │ 150,191,183 │ 154,552,594 │ $313.41 │
├────────────┼────────────────────┼───────────┼────────────┼───────────────┼────────────────┼────────────────┼─────────────┤
│ 2025-07-07 │ - opus-4 │ 7,244 │ 104,599 │ 3,894,453 │ 81,781,179 │ 85,787,475 │ $184.46 │
│ │ - sonnet-4 │ │ │ │ │ │ │
├────────────┼────────────────────┼───────────┼────────────┼───────────────┼────────────────┼────────────────┼─────────────┤
│ 2025-07-08 │ - opus-4 │ 50,312 │ 158,599 │ 5,021,189 │ 60,028,561 │ 65,258,661 │ $167.05 │
│ │ - sonnet-4 │ │ │ │ │ │ │
├────────────┼────────────────────┼───────────┼────────────┼───────────────┼────────────────┼────────────────┼─────────────┤
│ 2025-07-09 │ - opus-4 │ 6,311 │ 109,653 │ 4,171,140 │ 80,092,875 │ 84,379,979 │ $193.09 │
│ │ - sonnet-4 │ │ │ │ │ │ │
└────────────┴────────────────────┴───────────┴────────────┴───────────────┴────────────────┴────────────────┴─────────────┘
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
Author: John McCardle <mccardle.john@gmail.com>
Draft tutorials
Author: John McCardle <mccardle.john@gmail.com>
docs: update ROADMAP with FOV, A* pathfinding, and GUI text widget completions
- Mark TCOD Integration Sprint as complete
- Document FOV system with perspective rendering implementation
- Update UIEntity pathfinding status to complete with A* and caching
- Add comprehensive achievement entry for July 10 work
- Reflect current engine capabilities accurately
The engine now has all core roguelike mechanics:
- Field of View with per-entity visibility
- Pathfinding (both Dijkstra and A*)
- Text input for in-game consoles
- Performance optimizations throughout
Author: John McCardle <mccardle.john@gmail.com>
feat(engine): implement perspective FOV, pathfinding, and GUI text widgets
Major Engine Enhancements:
- Complete FOV (Field of View) system with perspective rendering
- UIGrid.perspective property for entity-based visibility
- Three-layer overlay colors (unexplored, explored, visible)
- Per-entity visibility state tracking
- Perfect knowledge updates only for explored areas
- Advanced Pathfinding Integration
- A* pathfinding implementation in UIGrid
- Entity.path_to() method for direct pathfinding
- Dijkstra maps for multi-target pathfinding
- Path caching for performance optimization
- GUI Text Input Widgets
- TextInputWidget class with cursor, selection, scrolling
- Improved widget with proper text rendering and input handling
- Example showcase of multiple text input fields
- Foundation for in-game console and chat systems
- Performance & Architecture Improvements
- PyTexture copy operations optimized
- GameEngine update cycle refined
- UIEntity property handling enhanced
- UITestScene modernized
Test Suite:
- Interactive visibility demos showing FOV in action
- Pathfinding comparison (A* vs Dijkstra)
- Debug utilities for visibility and empty path handling
- Sizzle reel demo combining pathfinding and vision
- Multiple text input test scenarios
This commit brings McRogueFace closer to a complete roguelike engine
with essential features like line-of-sight, intelligent pathfinding,
and interactive text input capabilities.
Author: John McCardle <mccardle.john@gmail.com>
feat(demos): enhance interactive pathfinding demos with entity.path_to()
- dijkstra_interactive_enhanced.py: Animation along paths with smooth movement
- M key to start movement animation
- P to pause/resume
- R to reset positions
- Visual path gradient for better clarity
- pathfinding_showcase.py: Advanced multi-entity behaviors
- Chase mode: enemies pursue player
- Flee mode: enemies avoid player
- Patrol mode: entities follow waypoints
- WASD player movement
- Dijkstra distance field visualization (D key)
- Larger dungeon map with multiple rooms
- Both demos use new entity.path_to() method
- Smooth interpolated movement animations
- Real-time pathfinding recalculation
- Comprehensive test coverage
These demos showcase the power of integrated pathfinding for game AI.
Author: John McCardle <mccardle.john@gmail.com>
feat(entity): implement path_to() method for entity pathfinding
- Add path_to(target_x, target_y) method to UIEntity class
- Uses existing Dijkstra pathfinding implementation from UIGrid
- Returns list of (x, y) coordinate tuples for complete path
- Supports both positional and keyword argument formats
- Proper error handling for out-of-bounds and no-grid scenarios
- Comprehensive test suite covering normal and edge cases
Part of TCOD integration sprint - gives entities immediate pathfinding capabilities.
Author: John McCardle <mccardle.john@gmail.com>
docs: update roadmap with Dijkstra pathfinding progress
- Mark UIGrid TCOD Integration as completed
- Document critical PyArg bug fix achievement
- Update UIEntity Pathfinding to 50% complete
- Add detailed progress notes for July 9 sprint work
Author: John McCardle <mccardle.john@gmail.com>
feat(tcod): complete Dijkstra pathfinding implementation with critical PyArg fix
- Add complete Dijkstra pathfinding to UIGrid class
- compute_dijkstra(), get_dijkstra_distance(), get_dijkstra_path()
- Full TCODMap and TCODDijkstra integration
- Proper memory management in constructors/destructors
- Create mcrfpy.libtcod submodule with Python bindings
- dijkstra_compute(), dijkstra_get_distance(), dijkstra_get_path()
- line() function for drawing corridors
- Foundation for future FOV and pathfinding algorithms
- Fix critical PyArg bug in UIGridPoint color setter
- PyObject_to_sfColor() now handles both Color objects and tuples
- Prevents "SystemError: new style getargs format but argument is not a tuple"
- Proper error handling and exception propagation
- Add comprehensive test suite
- test_dijkstra_simple.py validates all pathfinding operations
- dijkstra_test.py for headless testing with screenshots
- dijkstra_interactive.py for full user interaction demos
- Consolidate and clean up test files
- Removed 6 duplicate/broken demo attempts
- Two clean versions: headless test + interactive demo
Part of TCOD integration sprint for RoguelikeDev Tutorial Event.
Author: John McCardle <mccardle.john@gmail.com>
Roguelike Tutorial Planning + Prep
Author: John McCardle <mccardle.john@gmail.com>
feat(docs): complete markdown API documentation export
- Created comprehensive markdown documentation matching HTML completeness
- Documented all 75 functions, 20 classes, 56 methods, and 20 automation methods
- Zero ellipsis instances - complete coverage with no missing documentation
- Added proper markdown formatting with code blocks and navigation
- Included full parameter documentation, return values, and examples
Key features:
- 23KB GitHub-compatible markdown documentation
- 47 argument sections with detailed parameters
- 35 return value specifications
- 23 code examples with syntax highlighting
- 38 explanatory notes and 10 exception specifications
- Full table of contents with anchor links
- Professional markdown formatting
Both export formats now available:
- HTML: docs/api_reference_complete.html (54KB, rich styling)
- Markdown: docs/API_REFERENCE_COMPLETE.md (23KB, GitHub-compatible)
Author: John McCardle <mccardle.john@gmail.com>
feat(docs): complete API documentation with zero missing methods
- Eliminated ALL ellipsis instances (0 remaining)
- Documented 40 functions with complete signatures and examples
- Documented 21 classes with full method and property documentation
- Added 56 method descriptions with detailed parameters and return values
- Included 15 complete property specifications
- Added 24 code examples and 38 explanatory notes
- Comprehensive coverage of all collection methods, system classes, and functions
Key highlights:
- EntityCollection/UICollection: Complete method docs (append, remove, extend, count, index)
- Animation: Full property and method documentation with examples
- Color: All manipulation methods (from_hex, to_hex, lerp) with examples
- Vector: Complete mathematical operations (magnitude, normalize, dot, distance_to, angle, copy)
- Scene: All management methods including register_keyboard
- Timer: Complete control methods (pause, resume, cancel, restart)
- Window: All management methods (get, center, screenshot)
- System functions: Complete audio, scene, UI, and system function documentation
Author: John McCardle <mccardle.john@gmail.com>
feat(docs): create professional HTML API documentation
- Fixed all formatting issues from original HTML output
- Added comprehensive constructor documentation for all classes
- Enhanced visual design with modern styling and typography
- Fixed literal newline display and markdown link conversion
- Added proper semantic HTML structure and navigation
- Includes detailed documentation for Entity, collections, and system types
Author: John McCardle <mccardle.john@gmail.com>
feat: complete API reference generator and finish Phase 7 documentation
Implemented comprehensive API documentation generator that:
- Introspects live mcrfpy module for accurate documentation
- Generates organized Markdown reference (docs/API_REFERENCE.md)
- Categorizes classes and functions by type
- Includes full automation module documentation
- Provides summary statistics
Results:
- 20 classes documented
- 19 module functions documented
- 20 automation methods documented
- 100% coverage of public API
- Clean, readable Markdown output
Phase 7 Summary:
- Completed 4/5 tasks (1 cancelled as architecturally inappropriate)
- All documentation tasks successful
- Type stubs, docstrings, and API reference all complete
Author: John McCardle <mccardle.john@gmail.com>
docs: cancel PyPI wheel task and add future vision for Python extension architecture
Task #70 Analysis:
- Discovered fundamental incompatibility with PyPI distribution
- McRogueFace embeds CPython rather than being loaded by it
- Traditional wheels expect to extend existing Python interpreter
- Current architecture is application-with-embedded-Python
Decisions:
- Cancelled PyPI wheel preparation as out of scope for Alpha
- Cleaned up attempted packaging files (pyproject.toml, setup.py, etc.)
- Identified better distribution methods (installers, package managers)
Added Future Vision:
- Comprehensive plan for pure Python extension architecture
- Would allow true "pip install mcrogueface" experience
- Requires major refactoring to invert control flow
- Python would drive main loop with C++ performance extensions
- Unscheduled but documented as long-term possibility
This clarifies the architectural boundaries and sets realistic
expectations for distribution methods while preserving the vision
of what McRogueFace could become with significant rework.
Author: John McCardle <mccardle.john@gmail.com>
feat: generate comprehensive .pyi type stubs for IDE support (#108)
Created complete type stub files for the mcrfpy module to enable:
- Full IntelliSense/autocomplete in IDEs
- Static type checking with mypy/pyright
- Better documentation tooltips
- Parameter hints and return types
Implementation details:
- Manually crafted stubs for accuracy (15KB, 533 lines)
- Complete coverage: 19 classes, 112 functions/methods
- Proper type annotations using typing module
- @overload decorators for multiple signatures
- Type aliases for common patterns (UIElement union)
- Preserved all docstrings for IDE help
- Automation module fully typed
- PEP 561 compliant with py.typed marker
Testing:
- Validated Python syntax with ast.parse()
- Verified all expected classes and functions
- Confirmed type annotations are well-formed
- Checked docstring preservation (80 docstrings)
Usage:
- VS Code: Add stubs/ to python.analysis.extraPaths
- PyCharm: Mark stubs/ directory as Sources Root
- Other IDEs will auto-detect .pyi files
This significantly improves the developer experience when using
McRogueFace as a Python game engine.
Author: John McCardle <mccardle.john@gmail.com>
docs: add comprehensive parameter documentation to all API methods (#86)
Enhanced documentation for the mcrfpy module with:
- Detailed docstrings for all API methods
- Type hints in documentation (name: type format)
- Return type specifications
- Exception documentation where applicable
- Usage examples for complex methods
- Module-level documentation with overview and example code
Specific improvements:
- Audio API: Added parameter types and return values
- Scene API: Documented transition types and error conditions
- Timer API: Clarified handler signature and runtime parameter
- UI Search: Added wildcard pattern examples for findAll()
- Metrics API: Documented all dictionary keys returned
Also fixed method signatures:
- Changed METH_VARARGS to METH_NOARGS for parameterless methods
- Ensures proper Python calling conventions
Test coverage included - all documentation is accessible via Python's
__doc__ attributes and shows correctly formatted information.
Author: John McCardle <mccardle.john@gmail.com>
docs: mark issue #85 as completed in Phase 7
Author: John McCardle <mccardle.john@gmail.com>
docs: replace all 'docstring' placeholders with comprehensive documentation (#85)
Added proper Python docstrings for all UI component classes:
UIFrame:
- Container element that can hold child drawables
- Documents position, size, colors, outline, and clip_children
- Includes constructor signature with all parameters
UICaption:
- Text display element with font and styling
- Documents text content, position, font, colors, outline
- Notes that w/h are computed from text content
UISprite:
- Texture/sprite display element
- Documents position, texture, sprite_index, scale
- Notes that w/h are computed from texture and scale
UIGrid:
- Tile-based grid for game worlds
- Documents grid dimensions, tile size, texture atlas
- Includes entities collection and background_color
All docstrings follow consistent format:
- Constructor signature with defaults
- Brief description
- Args section with types and defaults
- Attributes section with all properties
This completes Phase 7 task #85 for documentation improvements.
Author: John McCardle <mccardle.john@gmail.com>
docs: update ROADMAP with PyArgHelpers infrastructure completion
Author: John McCardle <mccardle.john@gmail.com>
refactor: implement PyArgHelpers for standardized Python argument parsing
This major refactoring standardizes how position, size, and other arguments
are parsed across all UI components. PyArgHelpers provides consistent handling
for various argument patterns:
- Position as (x, y) tuple or separate x, y args
- Size as (w, h) tuple or separate width, height args
- Grid position and size with proper validation
- Color parsing with PyColorObject support
Changes across UI components:
- UICaption: Migrated to PyArgHelpers, improved resize() for future multiline support
- UIFrame: Uses standardized position parsing
- UISprite: Consistent position handling
- UIGrid: Grid-specific position/size helpers
- UIEntity: Unified argument parsing
Also includes:
- Improved error messages for type mismatches (int or float accepted)
- Reduced code duplication across constructors
- Better handling of keyword/positional argument conflicts
- Maintains backward compatibility with existing API
This addresses the inconsistent argument handling patterns discovered during
the inheritance hierarchy work and prepares for Phase 7 documentation.
Author: John McCardle <mccardle.john@gmail.com>
feat(Python): establish proper inheritance hierarchy for UI types
All UIDrawable-derived Python types now properly inherit from the Drawable
base class in Python, matching the C++ inheritance structure.
Changes:
- Add Py_TPFLAGS_BASETYPE to PyDrawableType to allow inheritance
- Set tp_base = &mcrfpydef::PyDrawableType for all UI types
- Add PyDrawable.h include to UI type headers
- Rename _Drawable to Drawable and update error message
This enables proper Python inheritance: Frame, Caption, Sprite, Grid,
and Entity all inherit from Drawable, allowing shared functionality
and isinstance() checks.
Author: John McCardle <mccardle.john@gmail.com>
refactor: move position property to UIDrawable base class (UISprite)
- Update UISprite to use base class position instead of sprite position
- Synchronize sprite position with base class position for rendering
- Implement onPositionChanged() for position synchronization
- Update all UISprite methods to use base position consistently
- Add comprehensive test coverage for UISprite position handling
This is part 3 of moving position to the base class. UIGrid is the final
class that needs to be updated.
Author: John McCardle <mccardle.john@gmail.com>
refactor: move position property to UIDrawable base class (UICaption)
- Update UICaption to use base class position instead of text position
- Synchronize text position with base class position for rendering
- Add onPositionChanged() virtual method for position synchronization
- Update all UICaption methods to use base position consistently
- Add comprehensive test coverage for UICaption position handling
This is part 2 of moving position to the base class. UISprite and UIGrid
will be updated in subsequent commits.
Author: John McCardle <mccardle.john@gmail.com>
refactor: move position property to UIDrawable base class (UIFrame)
- Add position member to UIDrawable base class
- Add common position getters/setters (x, y, pos) to base class
- Update UIFrame to use base class position instead of box position
- Synchronize box position with base class position for rendering
- Update all UIFrame methods to use base position consistently
- Add comprehensive test coverage for UIFrame position handling
This is part 1 of moving position to the base class. Other derived classes
(UICaption, UISprite, UIGrid) will be updated in subsequent commits.
Author: John McCardle <mccardle.john@gmail.com>
refactor: remove UIEntity collision_pos field
- Remove redundant collision_pos field from UIEntity
- Update position getters/setters to use integer-cast position when needed
- Remove all collision_pos synchronization code
- Simplify entity position handling to use single float position field
- Add comprehensive test coverage proving functionality is preserved
This removes technical debt and simplifies the codebase without changing API behavior.
Author: John McCardle <mccardle.john@gmail.com>
feat: add PyArgHelpers infrastructure for standardized argument parsing
- Create PyArgHelpers.h with parsing functions for position, size, grid coordinates, and color
- Support tuple-based vector arguments with conflict detection
- Provide consistent error messages and validation
- Add comprehensive test coverage for infrastructure
This sets the foundation for standardizing all Python API constructors.
Author: John McCardle <mccardle.john@gmail.com>
docs: mark Phase 6 (Rendering Revolution) as complete
Phase 6 is now complete with all core rendering features implemented:
Completed Features:
- Grid background colors (#50) - customizable backgrounds with animation
- RenderTexture overhaul (#6) - UIFrame clipping with opt-in architecture
- Viewport-based rendering (#8) - three scaling modes with coordinate transform
Strategic Decisions:
- UIGrid already has optimal RenderTexture implementation for its viewport needs
- UICaption/UISprite clipping deemed unnecessary (no children to clip)
- Effects/Shader/Particle systems deferred to post-Phase 7 for focused delivery
The rendering foundation is now solid and ready for Phase 7: Documentation & Distribution.
Author: John McCardle <mccardle.john@gmail.com>
feat(viewport): complete viewport-based rendering system (#8)
Implements a comprehensive viewport system that allows fixed game resolution
with flexible window scaling, addressing the primary wishes for issues #34, #49, and #8.
Key Features:
- Fixed game resolution independent of window size (window.game_resolution property)
- Three scaling modes accessible via window.scaling_mode:
- "center": 1:1 pixels, viewport centered in window
- "stretch": viewport fills window, ignores aspect ratio
- "fit": maintains aspect ratio with black bars
- Automatic window-to-game coordinate transformation for mouse input
- Full Python API integration with PyWindow properties
Technical Implementation:
- GameEngine::ViewportMode enum with Center, Stretch, Fit modes
- SFML View system for efficient GPU-based viewport scaling
- updateViewport() recalculates on window resize or mode change
- windowToGameCoords() transforms mouse coordinates correctly
- PyScene mouse input automatically uses transformed coordinates
Tests:
- test_viewport_simple.py: Basic API functionality
- test_viewport_visual.py: Visual verification with screenshots
- test_viewport_scaling.py: Interactive mode switching and resizing
This completes the viewport-based rendering task and provides the foundation
for resolution-independent game development as requested for Crypt of Sokoban.
Author: John McCardle <mccardle.john@gmail.com>
docs: update ROADMAP for Phase 6 progress
- Marked Phase 6 as IN PROGRESS
- Updated RenderTexture overhaul (#6) as PARTIALLY COMPLETE
- Marked Grid background colors (#50) as COMPLETED
- Added technical notes from implementation experience
- Identified viewport rendering (#8) as next priority
Author: John McCardle <mccardle.john@gmail.com>
feat(rendering): implement RenderTexture base infrastructure and UIFrame clipping (#6)
- Added RenderTexture support to UIDrawable base class
- std::unique_ptr<sf::RenderTexture> for opt-in rendering
- Dirty flag system for optimization
- enableRenderTexture() and markDirty() methods
- Implemented clip_children property for UIFrame
- Python-accessible boolean property
- Automatic RenderTexture creation when enabled
- Proper coordinate transformation for nested frames
- Updated UIFrame::render() for clipping support
- Renders to RenderTexture when clip_children=true
- Handles nested clipping correctly
- Only re-renders when dirty flag is set
- Added comprehensive dirty flag propagation
- All property setters mark frame as dirty
- Size changes recreate RenderTexture
- Animation system integration
- Created tests for clipping functionality
- Basic clipping test with visual verification
- Advanced nested clipping test
- Dynamic resize handling test
This is Phase 1 of the RenderTexture overhaul, providing the foundation
for advanced rendering effects like blur, glow, and viewport rendering.
Author: John McCardle <mccardle.john@gmail.com>
docs: create RenderTexture overhaul design document
- Comprehensive design for Issue #6 implementation
- Opt-in architecture to maintain backward compatibility
- Phased implementation plan with clear milestones
- Performance considerations and risk mitigation
- API design for clipping and future effects
Also includes Grid background color test
Author: John McCardle <mccardle.john@gmail.com>
feat(Grid): add customizable background_color property (#50)
- Added sf::Color background_color member with default dark gray
- Python property getter/setter for background_color
- Animation support for individual color components (r/g/b/a)
- Replaces hardcoded clear color in render method
- Test demonstrates color changes and property access
Closes#50
Author: John McCardle <mccardle.john@gmail.com>
docs: update roadmap for Phase 6 preparation
- Mark Phase 5 (Window/Scene Architecture) as complete
- Update issue statuses (#34, #61, #1, #105 completed)
- Add Phase 6 implementation strategy for RenderTexture overhaul
- Archive Phase 5 test files to .archive/
- Identify quick wins and technical approach for rendering work
Author: John McCardle <mccardle.john@gmail.com>
feat(Phase 5): Complete Window/Scene Architecture
- Window singleton with properties (resolution, fullscreen, vsync, title)
- OOP Scene support with lifecycle methods (on_enter, on_exit, on_keypress, update)
- Window resize events trigger scene.on_resize callbacks
- Scene transitions (fade, slide_left/right/up/down) with smooth animations
- Full integration of Python Scene objects with C++ engine
All Phase 5 tasks (#34, #1, #61, #105) completed successfully.
Author: John McCardle <mccardle.john@gmail.com>
research: SFML 3.0 migration analysis
- Analyzed SFML 3.0 breaking changes (event system, scoped enums, C++17)
- Assessed migration impact on McRogueFace (40+ files affected)
- Evaluated timing relative to mcrfpy.sfml module plans
- Recommended deferring migration until after mcrfpy.sfml implementation
- Created SFML_3_MIGRATION_RESEARCH.md with comprehensive strategy
Author: John McCardle <mccardle.john@gmail.com>
research: SFML exposure options analysis (#14)
- Analyzed current SFML 2.6.1 usage throughout codebase
- Evaluated python-sfml (abandoned, only supports SFML 2.3.2)
- Recommended direct integration as mcrfpy.sfml module
- Created comprehensive SFML_EXPOSURE_RESEARCH.md with implementation plan
- Identified opportunity to provide modern SFML 2.6+ Python bindings
Author: John McCardle <mccardle.john@gmail.com>
feat: add basic profiling/metrics system (#104)
- Add ProfilingMetrics struct to track performance data
- Track frame time (current and 60-frame rolling average)
- Calculate FPS from average frame time
- Count draw calls, UI elements, and visible elements per frame
- Track total runtime and current frame number
- PyScene counts elements during render
- Expose metrics via mcrfpy.getMetrics() returning dict
This provides basic performance monitoring capabilities for
identifying bottlenecks and optimizing rendering performance.
Author: John McCardle <mccardle.john@gmail.com>
fix: improve click handling with proper z-order and coordinate transforms
- UIFrame: Fix coordinate transformation (subtract parent pos, not add)
- UIFrame: Check children in reverse order (highest z-index first)
- UIFrame: Skip invisible elements entirely
- PyScene: Sort elements by z-index before checking clicks
- PyScene: Stop at first element that handles the click
- UIGrid: Implement entity click detection with grid coordinate transform
- UIGrid: Check entities in reverse order, return sprite as target
Click events now correctly respect z-order (top elements get priority),
handle coordinate transforms for nested frames, and support clicking
on grid entities. Elements without click handlers are transparent to
clicks, allowing elements below to receive them.
Note: Click testing requires non-headless mode due to PyScene limitation.
feat: implement name system for finding UI elements (#39/40/41)
- Add 'name' property to UIDrawable base class
- All UI elements (Frame, Caption, Sprite, Grid, Entity) support .name
- Entity delegates name to its sprite member
- Add find(name, scene=None) function for exact match search
- Add findAll(pattern, scene=None) with wildcard support (* matches any sequence)
- Both functions search recursively through Frame children and Grid entities
- Comprehensive test coverage for all functionality
This provides a simple way to find UI elements by name in Python scripts,
supporting both exact matches and wildcard patterns.
Author: John McCardle <mccardle.john@gmail.com>
fix: prevent segfault when closing window via X button
- Add cleanup() method to GameEngine to clear Python references before destruction
- Clear timers and McRFPy_API references in proper order
- Call cleanup() at end of run loop and in destructor
- Ensure cleanup is only called once per GameEngine instance
Also includes:
- Fix audio ::stop() calls (already in place, OpenAL warning is benign)
- Add Caption support for x, y keywords (e.g. Caption("text", x=5, y=10))
- Refactor UIDrawable_methods.h into UIBase.h for better organization
- Move UIEntity-specific implementations to UIEntityPyMethods.h
Author: John McCardle <mccardle.john@gmail.com>
feat: stabilize test suite and add UIDrawable methods
- Add visible, opacity properties to all UI classes (#87, #88)
- Add get_bounds(), move(), resize() methods to UIDrawable (#89, #98)
- Create UIDrawable_methods.h with template implementations
- Fix test termination issues - all tests now exit properly
- Fix test_sprite_texture_swap.py click handler signature
- Fix test_drawable_base.py segfault in headless mode
- Convert audio objects to pointers for cleanup (OpenAL warning persists)
- Remove debug print statements from UICaption
- Special handling for UIEntity to delegate drawable methods to sprite
All test files are now "airtight" - they complete successfully,
terminate on their own, and handle edge cases properly.
Author: John McCardle <mccardle.john@gmail.com>
docs: add Phase 1-3 completion summary
- Document all completed tasks across three phases
- Show before/after API improvements
- Highlight technical achievements
- Outline next steps for Phase 4-7
Author: John McCardle <mccardle.john@gmail.com>
feat: implement mcrfpy.Timer object with pause/resume/cancel capabilities closes#103
- Created PyTimer.h/cpp with object-oriented timer interface
- Enhanced PyTimerCallable with pause/resume state tracking
- Added timer control methods: pause(), resume(), cancel(), restart()
- Added timer properties: interval, remaining, paused, active, callback
- Fixed timing logic to prevent rapid catch-up after resume
- Timer objects automatically register with game engine
- Added comprehensive test demonstrating all functionality
Author: John McCardle <mccardle.john@gmail.com>
feat(Color): add helper methods from_hex, to_hex, lerp closes#94
- Add Color.from_hex(hex_string) class method for creating colors from hex
- Support formats: #RRGGBB, RRGGBB, #RRGGBBAA, RRGGBBAA
- Add color.to_hex() to convert Color to hex string
- Add color.lerp(other, t) for smooth color interpolation
- Comprehensive test coverage for all methods
Author: John McCardle <mccardle.john@gmail.com>
fix: properly configure UTF-8 encoding for Python stdio
- Use PyConfig to set stdio_encoding="UTF-8" during initialization
- Set stdio_errors="surrogateescape" for robust handling
- Configure in both init_python() and init_python_with_config()
- Cleaner solution than wrapping streams after initialization
- Fixes UnicodeEncodeError when printing unicode characters
Author: John McCardle <mccardle.john@gmail.com>
feat(Vector): implement arithmetic operations closes#93
- Add PyNumberMethods with add, subtract, multiply, divide, negate, absolute
- Add rich comparison for equality/inequality checks
- Add boolean check (zero vector is False)
- Implement vector methods: magnitude(), normalize(), dot(), distance_to(), angle(), copy()
- Fix UIDrawable::get_click() segfault when click_callable is null
- Comprehensive test coverage for all arithmetic operations
Author: John McCardle <mccardle.john@gmail.com>
feat: Complete position argument standardization for all UI classes
- Frame and Sprite now support pos keyword override
- Entity now accepts x,y arguments (was pos-only before)
- All UI classes now consistently support:
- (x, y) positional
- ((x, y)) tuple
- x=x, y=y keywords
- pos=(x,y) keyword
- pos=Vector keyword
- Improves API consistency and flexibility
Author: John McCardle <mccardle.john@gmail.com>
feat: Standardize position arguments across all UI classes
- Create PyPositionHelper for consistent position parsing
- Grid.at() now accepts (x,y), ((x,y)), x=x, y=y, pos=(x,y)
- Caption now accepts x,y args in addition to pos
- Grid init fully supports keyword arguments
- Maintain backward compatibility for all formats
- Consistent error messages across classes
Author: John McCardle <mccardle.john@gmail.com>
feat: Add Entity.die() method for lifecycle management closes#30
- Remove entity from its grid's entity list
- Clear grid reference after removal
- Safe to call multiple times (no-op if not on grid)
- Works with shared_ptr entity management
Author: John McCardle <mccardle.john@gmail.com>
perf: Skip out-of-bounds entities during Grid rendering closes#52
- Add visibility bounds check in entity render loop
- Skip entities outside view with 1 cell margin
- Improves performance for large grids with many entities
- Bounds check considers zoom and pan settings
Author: John McCardle <mccardle.john@gmail.com>
verify: Sprite texture swapping functionality closes#19
- Texture property getter/setter already implemented
- Position/scale preservation during swap confirmed
- Type validation for texture assignment working
- Tests verify functionality is complete
Author: John McCardle <mccardle.john@gmail.com>
feat: Grid size tuple support closes#90
- Add grid_size keyword parameter to Grid.__init__
- Accept tuple or list of two integers
- Override grid_x/grid_y if grid_size provided
- Maintain backward compatibility
- Add comprehensive test coverage
Author: John McCardle <mccardle.john@gmail.com>
feat: Phase 1 - safe constructors and _Drawable foundation
Closes#7 - Make all UI class constructors safe:
- Added safe default constructors for UISprite, UIGrid, UIEntity, UICaption
- Initialize all members to predictable values
- Made Python init functions accept no arguments
- Added x,y properties to UIEntity
Closes#71 - Create _Drawable Python base class:
- Created PyDrawable.h/cpp with base type (not yet inherited by UI types)
- Registered in module initialization
Closes#87 - Add visible property:
- Added bool visible=true to UIDrawable base class
- All render methods check visibility before drawing
Closes#88 - Add opacity property:
- Added float opacity=1.0 to UIDrawable base class
- UICaption and UISprite apply opacity to alpha channel
Closes#89 - Add get_bounds() method:
- Virtual method returns sf::FloatRect(x,y,w,h)
- Implemented in Frame, Caption, Sprite, Grid
Closes#98 - Add move() and resize() methods:
- move(dx,dy) for relative movement
- resize(w,h) for absolute sizing
- Caption resize is no-op (size controlled by font)
Author: John McCardle <mccardle.john@gmail.com>
docs: comprehensive alpha_streamline_2 plan and strategic vision
- Add 7-phase development plan for alpha_streamline_2 branch
- Define architectural dependencies and critical path
- Identify new issues needed (Timer objects, event system, etc.)
- Add strategic vision document with 3 transformative directions
- Timeline: 10-12 weeks to solid Beta foundation
Author: John McCardle <mccardle.john@gmail.com>
feat(Grid): flexible at() method arguments
- Support tuple argument: grid.at((x, y))
- Support keyword arguments: grid.at(x=5, y=3)
- Support pos keyword: grid.at(pos=(2, 8))
- Maintain backward compatibility with grid.at(x, y)
- Add comprehensive error handling for invalid arguments
Improves API ergonomics and Python-like flexibility
closes#63closes#69closes#59closes#47closes#2closes#3closes#33closes#27closes#73closes#74closes#78
I'd like to thank Claude Code for ~200-250M total tokens and 500-700k output tokens
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
commit 9bd1561bfc
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Jul 5 11:20:07 2025 -0400
Alpha 0.1 release
- Move RenderTexture (#6) out of alpha requirements, I don't need it
that badly
- alpha blockers resolved:
* Animation system (#59)
* Z-order rendering (#63)
* Python Sequence Protocol (#69)
* New README (#47)
* Removed deprecated methods (#2, #3)
🍾 McRogueFace 0.1.0
commit 43321487eb
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Jul 5 10:36:09 2025 -0400
Issue #63 (z-order rendering) complete
- Archive z-order test files
commit 90c318104b
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Jul 5 10:34:06 2025 -0400
Fix Issue #63: Implement z-order rendering with dirty flag optimization
- Add dirty flags to PyScene and UIFrame to track when sorting is needed
- Implement lazy sorting - only sort when z_index changes or elements are added/removed
- Make Frame children respect z_index (previously rendered in insertion order only)
- Update UIDrawable::set_int to notify when z_index changes
- Mark collections dirty on append, remove, setitem, and slice operations
- Remove per-frame vector copy in PyScene::render for better performance
commit e4482e7189
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Jul 5 01:58:03 2025 -0400
Implement complete Python Sequence Protocol for collections (closes#69)
Major implementation of the full sequence protocol for both UICollection
and UIEntityCollection, making them behave like proper Python sequences.
Core Features Implemented:
- __setitem__ (collection[i] = value) with type validation
- __delitem__ (del collection[i]) with proper cleanup
- __contains__ (item in collection) by C++ pointer comparison
- __add__ (collection + other) returns Python list
- __iadd__ (collection += other) with full validation before modification
- Negative indexing support throughout
- Complete slice support (getting, setting, deletion)
- Extended slices with step \!= 1
- index() and count() methods
- Type safety enforced for all operations
UICollection specifics:
- Accepts Frame, Caption, Sprite, and Grid objects only
- Preserves z_index when replacing items
- Auto-assigns z_index on append (existing behavior maintained)
UIEntityCollection specifics:
- Accepts Entity objects only
- Manages grid references on add/remove/replace
- Uses std::list iteration with std::advance()
Also includes:
- Default value support for constructors:
- Caption accepts None for font (uses default_font)
- Grid accepts None for texture (uses default_texture)
- Sprite accepts None for texture (uses default_texture)
- Entity accepts None for texture (uses default_texture)
This completes Issue #69, removing it as an Alpha Blocker.
commit 70cf44f8f0
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Jul 5 00:56:42 2025 -0400
Implement comprehensive animation system (closes#59)
- Add Animation class with 30+ easing functions (linear, ease in/out, quad, cubic, elastic, bounce, etc.)
- Add property system to all UI classes for animation support:
- UIFrame: position, size, colors (including individual r/g/b/a components)
- UICaption: position, size, text, colors
- UISprite: position, scale, sprite_number (with sequence support)
- UIGrid: position, size, camera center, zoom
- UIEntity: position, sprite properties
- Create AnimationManager singleton for frame-based updates
- Add Python bindings through PyAnimation wrapper
- Support for delta animations (relative values)
- Fix segfault when running scripts directly (mcrf_module initialization)
- Fix headless/windowed mode behavior to respect --headless flag
- Animations run purely in C++ without Python callbacks per frame
All UI properties are now animatable with smooth interpolation and professional easing curves.
commit 05bddae511
Author: John McCardle <mccardle.john@gmail.com>
Date: Fri Jul 4 06:59:02 2025 -0400
Update comprehensive documentation for Alpha release (Issue #47)
- Completely rewrote README.md to reflect current features
- Updated GitHub Pages documentation site with:
- Modern landing page highlighting Crypt of Sokoban
- Comprehensive API reference (2700+ lines) with exhaustive examples
- Updated getting-started guide with installation and first game tutorial
- 8 detailed tutorials covering all major game systems
- Quick reference cheat sheet for common operations
- Generated documentation screenshots showing UI elements
- Fixed deprecated API references and added new features
- Added automation API documentation
- Included Python 3.12 requirement and platform-specific instructions
Note: Text rendering in headless mode has limitations for screenshots
commit af6a5e090b
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:43:58 2025 -0400
Update ROADMAP.md to reflect completion of Issues #2 and #3
- Marked both issues as completed with the removal of deprecated action system
- Updated open issue count from ~50 to ~48
- These were both Alpha blockers, bringing us closer to release
commit 281800cd23
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:43:22 2025 -0400
Remove deprecated registerPyAction/registerInputAction system (closes#2, closes#3)
This is our largest net-negative commit yet\! Removed the entire deprecated
action registration system that provided unnecessary two-step indirection:
keyboard → action string → Python callback
Removed components:
- McRFPy_API::_registerPyAction() and _registerInputAction() methods
- McRFPy_API::callbacks map for storing Python callables
- McRFPy_API::doAction() method for executing callbacks
- ACTIONPY macro from Scene.h for detecting "_py" suffixed actions
- Scene::registerActionInjected() and unregisterActionInjected() methods
- tests/api_registerPyAction_issue2_test.py (tested deprecated functionality)
The game now exclusively uses keypressScene() for keyboard input handling,
which is simpler and more direct. Also commented out the unused _camFollow
function that referenced non-existent do_camfollow variable.
commit cc8a7d20e8
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:13:59 2025 -0400
Clean up temporary test files
commit ff83fd8bb1
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:13:46 2025 -0400
Update ROADMAP.md to reflect massive progress today
- Fixed 12+ critical bugs in a single session
- Implemented 3 missing features (Entity.index, EntityCollection.extend, sprite validation)
- Updated Phase 1 progress showing 11 of 12 items complete
- Added detailed summary of today's achievements with issue numbers
- Emphasized test-driven development approach used throughout
commit dae400031f
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:12:29 2025 -0400
Remove deprecated player_input and turn-based functions for Issue #3
Removed the commented-out player_input(), computerTurn(), and playerTurn()
functions that were part of the old turn-based system. These are no longer
needed as input is now handled through Scene callbacks.
Partial fix for #3
commit cb0130b46e
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:09:06 2025 -0400
Implement sprite index validation for Issue #33
Added validation to prevent setting sprite indices outside the valid
range for a texture. The implementation:
- Adds getSpriteCount() method to PyTexture to expose total sprites
- Validates sprite_number setter to ensure index is within bounds
- Provides clear error messages showing valid range
- Works for both Sprite and Entity objects
closes#33
commit 1e7f5e9e7e
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:05:47 2025 -0400
Implement EntityCollection.extend() method for Issue #27
Added extend() method to EntityCollection that accepts any iterable
of Entity objects and adds them all to the collection. The method:
- Accepts lists, tuples, generators, or any iterable
- Validates all items are Entity objects
- Sets the grid association for each added entity
- Properly handles errors and empty iterables
closes#27
commit 923350137d
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 21:02:14 2025 -0400
Implement Entity.index() method for Issue #73
Added index() method to Entity class that returns the entity's
position in its parent grid's entity collection. This enables
proper entity removal patterns using entity.index().
commit 6134869371
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 20:41:03 2025 -0400
Add validation to keypressScene() for non-callable arguments
Added PyCallable_Check validation to ensure keypressScene() only
accepts callable objects. Now properly raises TypeError with a
clear error message when passed non-callable arguments like
strings, numbers, None, or dicts.
commit 4715356b5e
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 20:31:36 2025 -0400
Fix Sprite texture setter 'error return without exception set'
Implemented the missing UISprite::set_texture method to properly:
- Validate the input is a Texture instance
- Update the sprite's texture using setTexture()
- Return appropriate error messages for invalid inputs
The setter now works correctly and no longer returns -1 without
setting an exception.
commit 6dd1cec600
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 20:27:32 2025 -0400
Fix Entity property setters and PyVector implementation
Fixed the 'new style getargs format' error in Entity property setters by:
- Implementing PyObject_to_sfVector2f/2i using PyVector::from_arg
- Adding proper error checking in Entity::set_position
- Implementing PyVector get_member/set_member for x/y properties
- Fixing PyVector::from_arg to handle non-tuple arguments correctly
Now Entity.pos and Entity.sprite_number setters work correctly with
proper type validation.
commit f82b861bcd
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 19:48:33 2025 -0400
Fix Issue #74: Add missing Grid.grid_y property
Added individual grid_x and grid_y getter properties to the Grid class
to complement the existing grid_size property. This allows direct access
to grid dimensions and fixes error messages that referenced these
properties before they existed.
closes#74
commit 59e6f8d53d
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 19:42:32 2025 -0400
Fix Issue #78: Middle mouse click no longer sends 'C' keyboard event
The bug was caused by accessing event.key.code on a mouse event without
checking the event type first. Since SFML uses a union for events, this
read garbage data. The middle mouse button value (2) coincidentally matched
the keyboard 'C' value (2), causing the spurious keyboard event.
Fixed by adding event type check before accessing key-specific fields.
Only keyboard events (KeyPressed/KeyReleased) now trigger key callbacks.
Test added to verify middle clicks no longer generate keyboard events.
Closes#78
commit 1c71d8d4f7
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 19:36:15 2025 -0400
Fix Grid to support None/null texture and fix error message bug
- Allow Grid to be created with None as texture parameter
- Use default cell dimensions (16x16) when no texture provided
- Skip sprite rendering when texture is null, but still render colors
- Fix issue #77: Corrected copy/paste error in Grid.at() error messages
- Grid now functional for color-only rendering and entity positioning
Test created to verify Grid works without texture, showing colored cells.
Closes#77
commit 18cfe93a44
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 19:25:49 2025 -0400
Fix --exec interactive prompt bug and create comprehensive test suite
Major fixes:
- Fixed --exec entering Python REPL instead of game loop
- Resolved screenshot transparency issue (requires timer callbacks)
- Added debug output to trace Python initialization
Test suite created:
- 13 comprehensive tests covering all Python-exposed methods
- Tests use timer callback pattern for proper game loop interaction
- Discovered multiple critical bugs and missing features
Critical bugs found:
- Grid class segfaults on instantiation (blocks all Grid functionality)
- Issue #78 confirmed: Middle mouse click sends 'C' keyboard event
- Entity property setters have argument parsing errors
- Sprite texture setter returns improper error
- keypressScene() segfaults on non-callable arguments
Documentation updates:
- Updated CLAUDE.md with testing guidelines and TDD practices
- Created test reports documenting all findings
- Updated ROADMAP.md with test results and new priorities
The Grid segfault is now the highest priority as it blocks all Grid-based functionality.
commit 9ad0b6850d
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 15:55:24 2025 -0400
Update ROADMAP.md to reflect Python interpreter and automation API progress
- Mark #32 (Python interpreter behavior) as 90% complete
- All major Python flags implemented: -h, -V, -c, -m, -i
- Script execution with proper sys.argv handling works
- Only stdin (-) support missing
- Note that new automation API enables:
- Automated UI testing capabilities
- Demo recording and playback
- Accessibility testing support
- Flag issues #53 and #45 as potentially aided by automation API
commit 7ec4698653
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 14:57:59 2025 -0400
Update ROADMAP.md to remove closed issues
- Remove #72 (iterator improvements - closed)
- Remove #51 (UIEntity derive from UIDrawable - closed)
- Update issue counts: 64 open issues from original 78
- Update dependencies and references to reflect closed issues
- Clarify that core iterators are complete, only grid points remain
commit 68c1a016b0
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 14:27:01 2025 -0400
Implement --exec flag and PyAutoGUI-compatible automation API
- Add --exec flag to execute multiple scripts before main program
- Scripts are executed in order and share Python interpreter state
- Implement full PyAutoGUI-compatible automation API in McRFPy_Automation
- Add screenshot, mouse control, keyboard input capabilities
- Fix Python initialization issues when multiple scripts are loaded
- Update CommandLineParser to handle --exec with proper sys.argv management
- Add comprehensive examples and documentation
This enables automation testing by allowing test scripts to run alongside
games using the same Python environment. The automation API provides
event injection into the SFML render loop for UI testing.
Closes#32 partially (Python interpreter emulation)
References automation testing requirements
commit 763fa201f0
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 10:43:17 2025 -0400
Python command emulation
commit a44b8c93e9
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Jul 3 09:42:46 2025 -0400
Prep: Cleanup for interpreter mode
closes#72
ref #69 - this resolves the "UICollection" (not "UIEntityCollection", perhaps renamed since the issue opened) and "UIEntityCollection" portion. The Grid point based iterators were not updated.
**RPATH updates**
Will this RPATH setting allow McRogueFace to execute using its included "lib" subdirectory after being unzipped on a new computer?
The change from "./lib" to "$ORIGIN/./lib" improves portability. The $ORIGIN token is a special Linux/Unix convention that refers to the directory containing the executable itself. This makes the path relative to the executable's location rather than the current working directory, which means McRogueFace will correctly find its libraries in the lib subdirectory regardless of where it's run from after being unzipped on a new computer.
**New standard object initialization**
PyColor, PyVector
- Fixed all 15 PyTypeObject definitions to use proper designated initializer syntax
- Replaced PyType_GenericAlloc usage in PyColor.cpp and PyVector.cpp
- Updated PyObject_New usage in UIEntity.cpp
- All object creation now uses module-based type lookups instead of static references
- Created centralized utilities in PyObjectUtils.h
**RAII Wrappers**
automatic reference counting via C++ object lifecycle
- Created PyRAII.h with PyObjectRef and PyTypeRef classes
- These provide automatic reference counting management
- Updated PyColor::from_arg() to demonstrate RAII usage
- Prevents memory leaks and reference counting errors
**Python object base in type defs:**
`.ob_base = {.ob_base = {.ob_refcnt = 1, .ob_type = NULL}, .ob_size = 0}`
PyColor, PyTexture, PyVector, UICaption, UICollection, UIEntity, UIFrame, UIGrid
**convertDrawableToPython**
replace crazy macro to detect the correct Python type of a UIDrawable instance
- Removed the problematic macro from UIDrawable.h
- Created template-based functions in PyObjectUtils.h
- Updated UICollection.cpp to use local helper function
- The new approach is cleaner, more debuggable, and avoids static type references
**Iterator fixes**
tp_iter on UICollection, UIGrid, UIGridPoint, UISprite
UIGrid logic improved, standard
**List vs Vector usage analysis**
there are different use cases that weren't standardized:
- UICollection (for Frame children) uses std::vector<std::shared_ptr<UIDrawable>>
- UIEntityCollection (for Grid entities) uses std::list<std::shared_ptr<UIEntity>>
The rationale is currently connected to frequency of expected changes.
* A "UICollection" is likely either all visible or not; it's also likely to be created once and have a static set of contents. They should be contiguous in memory in hopes that this helps rendering speed.
* A "UIEntityCollection" is expected to be rendered as a subset within the visible rectangle of the UIGrid. Scrolling the grid or gameplay logic is likely to frequently create and destroy entities. In general I expect Entity collections to have a much higher common size than UICollections. For these reasons I've made them Lists in hopes that they never have to be reallocated or moved during a frame.
This squash commit includes changes from April 21st through 28th, 2024, and the past 3 days of work at 7DRL.
Rather than resume my feature branch work, I made minor changes to safe the C++ functionality and wrote workarounds in Python.
I'm very likely to delete this commit from history by rolling master back to the previous commit, and squash merging a finished feature branch.
Closes#43
No segfault found in cos_play after completing the checklist. Maybe I accidentally fixed it...?
commit 6aa151aba3
Author: John McCardle <mccardle.john@gmail.com>
Date: Fri Apr 19 21:43:58 2024 -0400
UISprite.h/.cpp cleanup
commit ec0374ef50
Author: John McCardle <mccardle.john@gmail.com>
Date: Fri Apr 19 21:37:39 2024 -0400
UIGridPoint.h/.cpp reorganization
commit 2cb7339535
Author: John McCardle <mccardle.john@gmail.com>
Date: Fri Apr 19 21:19:25 2024 -0400
UIGrid.h/.cpp cleanup. I have reservations about the UIEntityCollection[Iter] classes + methods living there, but not enough to fix it right now.
commit 5d6af324bf
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Apr 18 22:14:57 2024 -0400
UIFrame - moving static method into class namespace; no type object access
commit 567218cd7b
Author: John McCardle <mccardle.john@gmail.com>
Date: Thu Apr 18 21:23:49 2024 -0400
UIEntity fixes for the UI.h split: There are segfaults in cos_play, I may have missed a type usage or something
commit 76693acd28
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Apr 13 00:18:37 2024 -0400
delete leftover comments
commit 9efe998a33
Author: John McCardle <mccardle.john@gmail.com>
Date: Sat Apr 13 00:17:43 2024 -0400
some work on UICaption and UICollection; fixing segfaults resulting from mcrfpydef namepace TypeObject usage
commit 714965da45
Author: John McCardle <mccardle.john@gmail.com>
Date: Fri Apr 12 14:15:00 2024 -0400
eliminate extra includes on UICaption
commit 8efa25878f
Author: John McCardle <mccardle.john@gmail.com>
Date: Wed Apr 10 23:41:14 2024 -0400
remove a lot of stuff
commit c186d8c7f3
Author: John McCardle <mccardle.john@gmail.com>
Date: Wed Apr 10 23:10:15 2024 -0400
We are compiling again! Started refactoring UICaption to be more idiomatic
commit 1b6e2a709b
Author: John McCardle <mccardle.john@gmail.com>
Date: Tue Apr 9 22:42:02 2024 -0400
Still not quite compiling; as predicted, a lot of interdependency and definition order bugs to untangle
commit aa7553a818
Author: John McCardle <mccardle.john@gmail.com>
Date: Tue Apr 9 22:41:20 2024 -0400
PyTexture clean up scribbles and experiments
commit c0201d989a
Author: John McCardle <mccardle.john@gmail.com>
Date: Mon Apr 8 22:55:00 2024 -0400
additional unsaved changes
commit 83a63a3093
Author: John McCardle <mccardle.john@gmail.com>
Date: Mon Apr 8 22:45:00 2024 -0400
doesn't compile, but UI.h/.cpp code has been divvy'd up.
refs #43 @2h
John McCardle