From dcd1b0ca33d46639023221f4d7d52000b947dbdf Mon Sep 17 00:00:00 2001
From: John McCardle <mccardle.john@gmail.com>
Date: Mon, 14 Jul 2025 01:33:40 -0400
Subject: [PATCH] Add roguelike tutorial implementation files
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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

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

These examples demonstrate McRogueFace's capabilities for traditional roguelike development.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 roguelike_tutorial/part_0.py               |  80 +++++++
 roguelike_tutorial/part_1.py               | 116 ++++++++++
 roguelike_tutorial/part_1b.py              | 117 ++++++++++
 roguelike_tutorial/part_2-naive.py         | 149 +++++++++++++
 roguelike_tutorial/part_2-onemovequeued.py | 241 +++++++++++++++++++++
 roguelike_tutorial/part_2.py               | 149 +++++++++++++
 roguelike_tutorial/tutorial2.png           | Bin 0 -> 5741 bytes
 roguelike_tutorial/tutorial_hero.png       | Bin 0 -> 16742 bytes
 8 files changed, 852 insertions(+)
 create mode 100644 roguelike_tutorial/part_0.py
 create mode 100644 roguelike_tutorial/part_1.py
 create mode 100644 roguelike_tutorial/part_1b.py
 create mode 100644 roguelike_tutorial/part_2-naive.py
 create mode 100644 roguelike_tutorial/part_2-onemovequeued.py
 create mode 100644 roguelike_tutorial/part_2.py
 create mode 100644 roguelike_tutorial/tutorial2.png
 create mode 100644 roguelike_tutorial/tutorial_hero.png

diff --git a/roguelike_tutorial/part_0.py b/roguelike_tutorial/part_0.py
new file mode 100644
index 0000000..eb9ed94
--- /dev/null
+++ b/roguelike_tutorial/part_0.py
@@ -0,0 +1,80 @@
+"""
+McRogueFace Tutorial - Part 0: Introduction to Scene, Texture, and Grid
+
+This tutorial introduces the basic building blocks:
+- Scene: A container for UI elements and game state
+- Texture: Loading image assets for use in the game
+- Grid: A tilemap component for rendering tile-based worlds
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = zoom
+grid.center = (grid_width/2.0)*16, (grid_height/2.0)*16 # center on the middle of the central tile
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 0",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((280, 750),
+    text="Scene + Texture + Grid = Tilemap!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 0 loaded!")
+print(f"Created a {grid.grid_size[0]}x{grid.grid_size[1]} grid")
+print(f"Grid positioned at ({grid.x}, {grid.y})")
diff --git a/roguelike_tutorial/part_1.py b/roguelike_tutorial/part_1.py
new file mode 100644
index 0000000..4c19d6d
--- /dev/null
+++ b/roguelike_tutorial/part_1.py
@@ -0,0 +1,116 @@
+"""
+McRogueFace Tutorial - Part 1: Entities and Keyboard Input
+
+This tutorial builds on Part 0 by adding:
+- Entity: A game object that can be placed in a grid
+- Keyboard handling: Responding to key presses to move the entity
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = zoom
+grid.center = (grid_width/2.0)*16, (grid_height/2.0)*16 # center on the middle of the central tile
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    if state == "start":  # Only respond to key press, not release
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y 
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            py -= 1
+        elif key == "S" or key == "Down":
+            py += 1
+        elif key == "A" or key == "Left":
+            px -= 1
+        elif key == "D" or key == "Right":
+            px += 1
+        
+        # Update player position (no collision checking yet)
+        player.x = px 
+        player.y = py
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 1",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((200, 750),
+    text="Use WASD or Arrow Keys to move the hero!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 1 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Use WASD or Arrow keys to move!")
diff --git a/roguelike_tutorial/part_1b.py b/roguelike_tutorial/part_1b.py
new file mode 100644
index 0000000..3894fc7
--- /dev/null
+++ b/roguelike_tutorial/part_1b.py
@@ -0,0 +1,117 @@
+"""
+McRogueFace Tutorial - Part 1: Entities and Keyboard Input
+
+This tutorial builds on Part 0 by adding:
+- Entity: A game object that can be placed in a grid
+- Keyboard handling: Responding to key presses to move the entity
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    if state == "start":  # Only respond to key press, not release
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y 
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            py -= 1
+        elif key == "S" or key == "Down":
+            py += 1
+        elif key == "A" or key == "Left":
+            px -= 1
+        elif key == "D" or key == "Right":
+            px += 1
+        
+        # Update player position (no collision checking yet)
+        player.x = px 
+        player.y = py
+        grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 1",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((200, 750),
+    text="Use WASD or Arrow Keys to move the hero!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 1 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Use WASD or Arrow keys to move!")
diff --git a/roguelike_tutorial/part_2-naive.py b/roguelike_tutorial/part_2-naive.py
new file mode 100644
index 0000000..6959a4b
--- /dev/null
+++ b/roguelike_tutorial/part_2-naive.py
@@ -0,0 +1,149 @@
+"""
+McRogueFace Tutorial - Part 2: Animated Movement
+
+This tutorial builds on Part 1 by adding:
+- Animation system for smooth movement
+- Movement that takes 0.5 seconds per tile
+- Input blocking during movement animation
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Movement state tracking
+is_moving = False
+move_animations = []  # Track active animations
+
+# Animation completion callback
+def movement_complete(runtime):
+    """Called when movement animation completes"""
+    global is_moving
+    is_moving = False
+    # Ensure grid is centered on final position
+    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+
+motion_speed = 0.30 # seconds per tile
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    global is_moving, move_animations
+    
+    if state == "start" and not is_moving:  # Only respond to key press when not moving
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y
+        new_x, new_y = px, py
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            new_y -= 1
+        elif key == "S" or key == "Down":
+            new_y += 1
+        elif key == "A" or key == "Left":
+            new_x -= 1
+        elif key == "D" or key == "Right":
+            new_x += 1
+        
+        # If position changed, start movement animation
+        if new_x != px or new_y != py:
+            is_moving = True
+            
+            # Create animations for player position
+            anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad")
+            anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad")
+            anim_x.start(player)
+            anim_y.start(player)
+            
+            # Animate grid center to follow player
+            center_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
+            center_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
+            center_x.start(grid)
+            center_y.start(grid)
+            
+            # Set a timer to mark movement as complete
+            mcrfpy.setTimer("move_complete", movement_complete, 500)
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 2",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((150, 750),
+    text="Smooth movement! Each step takes 0.5 seconds.",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 2 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Movement is now animated over 0.5 seconds per tile!")
+print("Use WASD or Arrow keys to move!")
diff --git a/roguelike_tutorial/part_2-onemovequeued.py b/roguelike_tutorial/part_2-onemovequeued.py
new file mode 100644
index 0000000..126c433
--- /dev/null
+++ b/roguelike_tutorial/part_2-onemovequeued.py
@@ -0,0 +1,241 @@
+"""
+McRogueFace Tutorial - Part 2: Enhanced with Single Move Queue
+
+This tutorial builds on Part 2 by adding:
+- Single queued move system for responsive input
+- Debug display showing position and queue status
+- Smooth continuous movement when keys are held
+- Animation callbacks to prevent race conditions
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Movement state tracking
+is_moving = False
+move_queue = []  # List to store queued moves (max 1 item)
+#last_position = (4, 4)  # Track last position
+current_destination = None  # Track where we're currently moving to
+current_move = None  # Track current move direction
+
+# Store animation references
+player_anim_x = None
+player_anim_y = None
+grid_anim_x = None
+grid_anim_y = None
+
+# Debug display caption
+debug_caption = mcrfpy.Caption((10, 40),
+    text="Last: (4, 4) | Queue: 0 | Dest: None",
+)
+debug_caption.font_size = 16
+debug_caption.fill_color = mcrfpy.Color(255, 255, 0, 255)
+mcrfpy.sceneUI("tutorial").append(debug_caption)
+
+# Additional debug caption for movement state
+move_debug_caption = mcrfpy.Caption((10, 60),
+    text="Moving: False | Current: None | Queued: None",
+)
+move_debug_caption.font_size = 16
+move_debug_caption.fill_color = mcrfpy.Color(255, 200, 0, 255)
+mcrfpy.sceneUI("tutorial").append(move_debug_caption)
+
+def key_to_direction(key):
+    """Convert key to direction string"""
+    if key == "W" or key == "Up":
+        return "Up"
+    elif key == "S" or key == "Down":
+        return "Down"
+    elif key == "A" or key == "Left":
+        return "Left"
+    elif key == "D" or key == "Right":
+        return "Right"
+    return None
+
+def update_debug_display():
+    """Update the debug caption with current state"""
+    queue_count = len(move_queue)
+    dest_text = f"({current_destination[0]}, {current_destination[1]})" if current_destination else "None"
+    debug_caption.text = f"Last: ({player.x}, {player.y}) | Queue: {queue_count} | Dest: {dest_text}"
+    
+    # Update movement state debug
+    current_dir = key_to_direction(current_move) if current_move else "None"
+    queued_dir = key_to_direction(move_queue[0]) if move_queue else "None"
+    move_debug_caption.text = f"Moving: {is_moving} | Current: {current_dir} | Queued: {queued_dir}"
+
+# Animation completion callback
+def movement_complete(anim, target):
+    """Called when movement animation completes"""
+    global is_moving, move_queue, current_destination, current_move
+    global player_anim_x, player_anim_y
+    print(f"In callback for animation: {anim=} {target=}")
+    # Clear movement state
+    is_moving = False
+    current_move = None
+    current_destination = None
+    # Clear animation references
+    player_anim_x = None
+    player_anim_y = None
+    
+    # Update last position to where we actually are now
+    #last_position = (int(player.x), int(player.y))
+    
+    # Ensure grid is centered on final position
+    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+    
+    # Check if there's a queued move
+    if move_queue:
+        # Pop the next move from the queue
+        next_move = move_queue.pop(0)
+        print(f"Processing queued move: {next_move}")
+        # Process it like a fresh input
+        process_move(next_move)
+    
+    update_debug_display()
+
+motion_speed = 0.30 # seconds per tile
+
+def process_move(key):
+    """Process a move based on the key"""
+    global is_moving, current_move, current_destination, move_queue
+    global player_anim_x, player_anim_y, grid_anim_x, grid_anim_y
+    
+    # If already moving, just update the queue
+    if is_moving:
+        print(f"process_move processing {key=} as a queued move (is_moving = True)")
+        # Clear queue and add new move (only keep 1 queued move)
+        move_queue.clear()
+        move_queue.append(key)
+        update_debug_display()
+        return
+    print(f"process_move processing {key=} as a new, immediate animation (is_moving = False)")
+    # Calculate new position from current position
+    px, py = int(player.x), int(player.y)
+    new_x, new_y = px, py
+    
+    # Calculate new position based on key press (only one tile movement)
+    if key == "W" or key == "Up":
+        new_y -= 1
+    elif key == "S" or key == "Down":
+        new_y += 1
+    elif key == "A" or key == "Left":
+        new_x -= 1
+    elif key == "D" or key == "Right":
+        new_x += 1
+    
+    # Start the move if position changed
+    if new_x != px or new_y != py:
+        is_moving = True
+        current_move = key
+        current_destination = (new_x, new_y)
+        # only animate a single axis, same callback from either
+        if new_x != px:
+            player_anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad", callback=movement_complete)
+            player_anim_x.start(player)
+        elif new_y != py:
+            player_anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad", callback=movement_complete)
+            player_anim_y.start(player)
+        
+        # Animate grid center to follow player
+        grid_anim_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
+        grid_anim_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
+        grid_anim_x.start(grid)
+        grid_anim_y.start(grid)
+        
+        update_debug_display()
+
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    if state == "start":
+        # Only process movement keys
+        if key in ["W", "Up", "S", "Down", "A", "Left", "D", "Right"]:
+            print(f"handle_keys producing actual input: {key=}")
+            process_move(key)
+
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 2 Enhanced",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((150, 750),
+    text="One-move queue system with animation callbacks!",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 2 Enhanced loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Movement now uses animation callbacks to prevent race conditions!")
+print("Use WASD or Arrow keys to move!")
diff --git a/roguelike_tutorial/part_2.py b/roguelike_tutorial/part_2.py
new file mode 100644
index 0000000..66a11b0
--- /dev/null
+++ b/roguelike_tutorial/part_2.py
@@ -0,0 +1,149 @@
+"""
+McRogueFace Tutorial - Part 2: Animated Movement
+
+This tutorial builds on Part 1 by adding:
+- Animation system for smooth movement
+- Movement that takes 0.5 seconds per tile
+- Input blocking during movement animation
+"""
+import mcrfpy
+import random
+
+# Create and activate a new scene
+mcrfpy.createScene("tutorial")
+mcrfpy.setScene("tutorial")
+
+# Load the texture (4x3 tiles, 64x48 pixels total, 16x16 per tile)
+texture = mcrfpy.Texture("assets/tutorial2.png", 16, 16)
+
+# Load the hero sprite texture (32x32 sprite sheet)
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+# Each tile is 16x16 pixels, so with 3x zoom: 16*3 = 48 pixels per tile
+
+grid_width, grid_height = 25, 20 # width, height in number of tiles
+
+# calculating the size in pixels to fit the entire grid on-screen
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# calculating the position to center the grid on the screen - assuming default 1024x768 resolution
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,  # height and width on screen
+)
+
+grid.zoom = 3.0 # we're not using the zoom variable! It's going to be really big!
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Fill the grid with a simple pattern
+for y in range(grid_height):
+    for x in range(grid_width):
+        # Create walls around the edges
+        if x == 0 or x == grid_width-1 or y == 0 or y == grid_height-1:
+            tile_index = random.choice(WALL_TILES)
+        else:
+            # Fill interior with floor tiles
+            tile_index = random.choice(FLOOR_TILES)
+        
+        # Set the tile at this position
+        point = grid.at(x, y)
+        if point:
+            point.tilesprite = tile_index
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Create a player entity at position (4, 4)
+player = mcrfpy.Entity(
+    (4, 4),  # Entity positions are tile coordinates
+    texture=hero_texture,
+    sprite_index=0  # Use the first sprite in the texture
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16 # grid center is in texture/pixel coordinates
+
+# Movement state tracking
+is_moving = False
+move_animations = []  # Track active animations
+
+# Animation completion callback
+def movement_complete(runtime):
+    """Called when movement animation completes"""
+    global is_moving
+    is_moving = False
+    # Ensure grid is centered on final position
+    grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+
+motion_speed = 0.30 # seconds per tile
+# Define keyboard handler
+def handle_keys(key, state):
+    """Handle keyboard input to move the player"""
+    global is_moving, move_animations
+    
+    if state == "start" and not is_moving:  # Only respond to key press when not moving
+        # Get current player position in grid coordinates
+        px, py = player.x, player.y
+        new_x, new_y = px, py
+        
+        # Calculate new position based on key press
+        if key == "W" or key == "Up":
+            new_y -= 1
+        elif key == "S" or key == "Down":
+            new_y += 1
+        elif key == "A" or key == "Left":
+            new_x -= 1
+        elif key == "D" or key == "Right":
+            new_x += 1
+        
+        # If position changed, start movement animation
+        if new_x != px or new_y != py:
+            is_moving = True
+            
+            # Create animations for player position
+            anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad")
+            anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad")
+            anim_x.start(player)
+            anim_y.start(player)
+            
+            # Animate grid center to follow player
+            center_x = mcrfpy.Animation("center_x", (new_x + 0.5) * 16, motion_speed, "linear")
+            center_y = mcrfpy.Animation("center_y", (new_y + 0.5) * 16, motion_speed, "linear")
+            center_x.start(grid)
+            center_y.start(grid)
+            
+            # Set a timer to mark movement as complete
+            mcrfpy.setTimer("move_complete", movement_complete, 500)
+
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add a title caption
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 2",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+# Add instructions
+instructions = mcrfpy.Caption((150, 750),
+    "Smooth movement! Each step takes 0.5 seconds.",
+)
+instructions.font_size=18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+print("Tutorial Part 2 loaded!")
+print(f"Player entity created at grid position (4, 4)")
+print("Movement is now animated over 0.5 seconds per tile!")
+print("Use WASD or Arrow keys to move!")
diff --git a/roguelike_tutorial/tutorial2.png b/roguelike_tutorial/tutorial2.png
new file mode 100644
index 0000000000000000000000000000000000000000..e7854196517cae002aa2d3381728d0adbc125ff8
GIT binary patch
literal 5741
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

literal 0
HcmV?d00001

diff --git a/roguelike_tutorial/tutorial_hero.png b/roguelike_tutorial/tutorial_hero.png
new file mode 100644
index 0000000000000000000000000000000000000000..c202176caf74bd28325f0e4352e28e35db03d2ec
GIT binary patch
literal 16742
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

literal 0
HcmV?d00001