john/McRogueFace
1
0
Fork 0
Code Issues 41 Pull requests Projects 1 Releases Wiki Activity

Squashed commit of 53 Commits: [alpha_streamline_2]

Browse source 
* 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
This commit is contained in:
John McCardle 2025-07-09 22:41:15 -04:00
commit d11f76ac43
65 changed files with 16796 additions and 622 deletions
Download patch file Download diff file Expand all files Collapse all files

33
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_0/code/game.py Normal file
View file

@ -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!")

55
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_0/code/setup_test.py Normal file
View file

@ -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.")

162
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_1/code/game.py Normal file
View file

@ -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!")

217
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_2/code/game.py Normal file
View file

@ -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!")

312
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_3/code/game.py Normal file
View file

@ -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")

334
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_4/code/game.py Normal file
View file

@ -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")

388
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_5/code/game.py Normal file
View file

@ -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!")

568
roguelike_tutorial/mcrogueface_does_the_entire_tutorial_2025/Part_6/code/game.py Normal file
View file

@ -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!")