Scary better enemies for part 6 with Djikstra, and runs smoother without all the line checks

roguelike_tutorial/part_6.py

@@ -0,0 +1,645 @@
+"""
+McRogueFace Tutorial - Part 6: Turn-based enemy movement
+
+This tutorial builds on Part 5 by adding:
+- Turn cycles where enemies move after the player
+- Enemy AI that pursues or wanders
+- Shared collision detection for all entities
+"""
+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
+hero_texture = mcrfpy.Texture("assets/custom_player.png", 16, 16)
+
+# Create a grid of tiles
+grid_width, grid_height = 40, 30
+
+# Calculate the size in pixels
+zoom = 2.0
+grid_size = grid_width * zoom * 16, grid_height * zoom * 16
+
+# Calculate the position to center the grid on the screen
+grid_position = (1024 - grid_size[0]) / 2, (768 - grid_size[1]) / 2
+
+# Create the grid with a TCODMap for pathfinding/FOV
+grid = mcrfpy.Grid(
+    pos=grid_position,
+    grid_size=(grid_width, grid_height),
+    texture=texture,
+    size=grid_size,
+)
+
+grid.zoom = zoom
+
+# Define tile types
+FLOOR_TILES = [0, 1, 2, 4, 5, 6, 8, 9, 10]
+WALL_TILES = [3, 7, 11]
+
+# Room class for BSP
+class Room:
+    def __init__(self, x, y, w, h):
+        self.x1 = x
+        self.y1 = y
+        self.x2 = x + w
+        self.y2 = y + h
+        self.w = w
+        self.h = h
+    
+    def center(self):
+        center_x = (self.x1 + self.x2) // 2
+        center_y = (self.y1 + self.y2) // 2
+        return (center_x, center_y)
+    
+    def intersects(self, other):
+        return (self.x1 <= other.x2 and self.x2 >= other.x1 and
+                self.y1 <= other.y2 and self.y2 >= other.y1)
+
+# Dungeon generation functions (from Part 3)
+def carve_room(room):
+    for x in range(room.x1, room.x2):
+        for y in range(room.y1, room.y2):
+            if 0 <= x < grid_width and 0 <= y < grid_height:
+                point = grid.at(x, y)
+                if point:
+                    point.tilesprite = random.choice(FLOOR_TILES)
+                    point.walkable = True
+                    point.transparent = True
+
+def carve_hallway(x1, y1, x2, y2):
+    #points = mcrfpy.libtcod.line(x1, y1, x2, y2)
+    points = []
+    if random.choice([True, False]):
+        # x1,y1 -> x2,y1 -> x2,y2
+        points.extend(mcrfpy.libtcod.line(x1, y1, x2, y1))
+        points.extend(mcrfpy.libtcod.line(x2, y1, x2, y2))
+    else:
+        # x1,y1 -> x1,y2 -> x2,y2
+        points.extend(mcrfpy.libtcod.line(x1, y1, x1, y2))
+        points.extend(mcrfpy.libtcod.line(x1, y2, x2, y2))
+
+    for x, y in points:
+        if 0 <= x < grid_width and 0 <= y < grid_height:
+            point = grid.at(x, y)
+            if point:
+                point.tilesprite = random.choice(FLOOR_TILES)
+                point.walkable = True
+                point.transparent = True
+
+def generate_dungeon(max_rooms=10, room_min_size=4, room_max_size=10):
+    rooms = []
+    
+    # Fill with walls
+    for y in range(grid_height):
+        for x in range(grid_width):
+            point = grid.at(x, y)
+            if point:
+                point.tilesprite = random.choice(WALL_TILES)
+                point.walkable = False
+                point.transparent = False
+    
+    # Generate rooms
+    for _ in range(max_rooms):
+        w = random.randint(room_min_size, room_max_size)
+        h = random.randint(room_min_size, room_max_size)
+        x = random.randint(1, grid_width - w - 1)
+        y = random.randint(1, grid_height - h - 1)
+        
+        new_room = Room(x, y, w, h)
+        
+        failed = False
+        for other_room in rooms:
+            if new_room.intersects(other_room):
+                failed = True
+                break
+        
+        if not failed:
+            carve_room(new_room)
+            
+            if rooms:
+                prev_x, prev_y = rooms[-1].center()
+                new_x, new_y = new_room.center()
+                carve_hallway(prev_x, prev_y, new_x, new_y)
+            
+            rooms.append(new_room)
+    
+    return rooms
+
+# Generate the dungeon
+rooms = generate_dungeon(max_rooms=8, room_min_size=4, room_max_size=8)
+
+# Add the grid to the scene
+mcrfpy.sceneUI("tutorial").append(grid)
+
+# Spawn player in the first room
+if rooms:
+    spawn_x, spawn_y = rooms[0].center()
+else:
+    spawn_x, spawn_y = 4, 4
+
+class GameEntity(mcrfpy.Entity):
+    """An entity whose default behavior is to prevent others from moving into its tile."""
+
+    def __init__(self, x, y, walkable=False, **kwargs):
+        super().__init__(x=x, y=y, **kwargs)
+        self.walkable = walkable
+        self.dest_x = x
+        self.dest_y = y
+        self.is_moving = False
+
+    def get_position(self):
+        """Get logical position (destination if moving, otherwise current)"""
+        if self.is_moving:
+            return (self.dest_x, self.dest_y)
+        return (int(self.x), int(self.y))
+
+    def on_bump(self, other):
+        return self.walkable # allow other's motion to proceed if entity is walkable
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} x={self.x}, y={self.y}, sprite_index={self.sprite_index}>"
+
+class CombatEntity(GameEntity):
+    def __init__(self, x, y, hp=10, damage=(1,3), **kwargs):
+        super().__init__(x=x, y=y, **kwargs)
+        self.hp = hp
+        self.damage = damage
+
+    def is_dead(self):
+        return self.hp <= 0
+    
+    def start_move(self, new_x, new_y, duration=0.2, callback=None):
+        """Start animating movement to new position"""
+        self.dest_x = new_x
+        self.dest_y = new_y
+        self.is_moving = True
+        
+        # Define completion callback that resets is_moving
+        def movement_done(anim, entity):
+            self.is_moving = False
+            if callback:
+                callback(anim, entity)
+        
+        # Create animations for smooth movement
+        anim_x = mcrfpy.Animation("x", float(new_x), duration, "easeInOutQuad", callback=movement_done)
+        anim_y = mcrfpy.Animation("y", float(new_y), duration, "easeInOutQuad")
+        
+        anim_x.start(self)
+        anim_y.start(self)
+    
+    def can_see(self, target_x, target_y):
+        """Check if this entity can see the target position"""
+        mx, my = self.get_position()
+        
+        # Simple distance check first
+        dist = abs(target_x - mx) + abs(target_y - my)
+        if dist > 6:
+            return False
+        
+        # Line of sight check
+        line = list(mcrfpy.libtcod.line(mx, my, target_x, target_y))
+        for x, y in line[1:-1]:  # Skip start and end
+            cell = grid.at(x, y)
+            if cell and not cell.transparent:
+                return False
+        return True
+    
+    def ai_turn(self, player_pos):
+        """Decide next move"""
+        mx, my = self.get_position()
+        px, py = player_pos
+        
+        # Simple AI: move toward player if visible
+        if self.can_see(px, py):
+            # Calculate direction toward player
+            dx = 0
+            dy = 0
+            if px > mx:
+                dx = 1
+            elif px < mx:
+                dx = -1
+            if py > my:
+                dy = 1
+            elif py < my:
+                dy = -1
+                
+            # Prefer cardinal movement
+            if dx != 0 and dy != 0:
+                # Pick horizontal or vertical based on greater distance
+                if abs(px - mx) > abs(py - my):
+                    dy = 0
+                else:
+                    dx = 0
+                    
+            return (mx + dx, my + dy)
+        else:
+            # Random wander
+            dx, dy = random.choice([(0,1), (0,-1), (1,0), (-1,0)])
+            return (mx + dx, my + dy)
+    
+    def ai_turn_dijkstra(self):
+        """Decide next move using precomputed Dijkstra map"""
+        mx, my = self.get_position()
+        
+        # Get current distance to player
+        current_dist = grid.get_dijkstra_distance(mx, my)
+        if current_dist is None or current_dist > 20:
+            # Too far or unreachable - random wander
+            dx, dy = random.choice([(0,1), (0,-1), (1,0), (-1,0)])
+            return (mx + dx, my + dy)
+        
+        # Check all adjacent cells for best move
+        best_moves = []
+        for dx, dy in [(0,1), (0,-1), (1,0), (-1,0)]:
+            nx, ny = mx + dx, my + dy
+            
+            # Skip if out of bounds
+            if nx < 0 or nx >= grid_width or ny < 0 or ny >= grid_height:
+                continue
+                
+            # Skip if not walkable
+            cell = grid.at(nx, ny)
+            if not cell or not cell.walkable:
+                continue
+            
+            # Get distance from this cell
+            dist = grid.get_dijkstra_distance(nx, ny)
+            if dist is not None:
+                best_moves.append((dist, nx, ny))
+        
+        if best_moves:
+            # Sort by distance
+            best_moves.sort()
+            
+            # If multiple moves have the same best distance, pick randomly
+            best_dist = best_moves[0][0]
+            equal_moves = [(nx, ny) for dist, nx, ny in best_moves if dist == best_dist]
+            
+            if len(equal_moves) > 1:
+                # Random choice among equally good moves
+                nx, ny = random.choice(equal_moves)
+            else:
+                _, nx, ny = best_moves[0]
+                
+            return (nx, ny)
+        else:
+            # No valid moves
+            return (mx, my)
+
+# Create a player entity
+player = CombatEntity(
+    spawn_x, spawn_y,
+    texture=hero_texture,
+    sprite_index=0
+)
+
+# Add the player entity to the grid
+grid.entities.append(player)
+
+# Track all enemies
+enemies = []
+
+# Spawn enemies in other rooms
+for i, room in enumerate(rooms[1:], 1):  # Skip first room (player spawn)
+    if i <= 3:  # Limit to 3 enemies for now
+        enemy_x, enemy_y = room.center()
+        enemy = CombatEntity(
+            enemy_x, enemy_y,
+            texture=hero_texture,
+            sprite_index=0  # Enemy sprite (borrow player's)
+        )
+        grid.entities.append(enemy)
+        enemies.append(enemy)
+
+# Set the grid perspective to the player by default
+# Note: The new perspective system uses entity references directly
+grid.perspective = player
+
+# Initial FOV computation
+def update_fov():
+    """Update field of view from current perspective"""
+    if grid.perspective == player:
+        grid.compute_fov(int(player.x), int(player.y), radius=8, algorithm=0)
+        player.update_visibility()
+
+# Perform initial FOV calculation
+update_fov()
+
+# Center grid on current perspective
+def center_on_perspective():
+    if grid.perspective == player:
+        grid.center = (player.x + 0.5) * 16, (player.y + 0.5) * 16
+
+center_on_perspective()
+
+# Movement state tracking (from Part 3)
+#is_moving = False # make it an entity property
+move_queue = []
+current_destination = None
+current_move = None
+
+# Store animation references
+player_anim_x = None
+player_anim_y = None
+grid_anim_x = None
+grid_anim_y = None
+
+def movement_complete(anim, target):
+    """Called when movement animation completes"""
+    global move_queue, current_destination, current_move
+    global player_anim_x, player_anim_y, is_player_turn
+    
+    player.is_moving = False
+    current_move = None
+    current_destination = None
+    player_anim_x = None
+    player_anim_y = None
+    
+    # Update FOV after movement
+    update_fov()
+    center_on_perspective()
+    
+    # Player turn complete, start enemy turns and queued player move simultaneously
+    is_player_turn = False
+    process_enemy_turns_and_player_queue()
+
+motion_speed = 0.20
+is_player_turn = True  # Track whose turn it is
+
+def get_blocking_entity_at(x, y):
+    """Get blocking entity at position"""
+    for e in grid.entities:
+        if not e.walkable and (x, y) == e.get_position():
+            return e
+    return None
+
+def can_move_to(x, y, mover=None):
+    """Check if a position is valid for movement"""
+    if x < 0 or x >= grid_width or y < 0 or y >= grid_height:
+        return False
+    
+    point = grid.at(x, y)
+    if not point or not point.walkable:
+        return False
+        
+    # Check for blocking entities
+    blocker = get_blocking_entity_at(x, y)
+    if blocker and blocker != mover:
+        return False
+        
+    return True
+
+def process_enemy_turns_and_player_queue():
+    """Process all enemy AI decisions and player's queued move simultaneously"""
+    global is_player_turn, move_queue
+    
+    # Compute Dijkstra map once for all enemies (if using Dijkstra)
+    if USE_DIJKSTRA:
+        px, py = player.get_position()
+        grid.compute_dijkstra(px, py, diagonal_cost=1.41)
+    
+    enemies_to_move = []
+    claimed_positions = set()  # Track where enemies plan to move
+    
+    # Collect all enemy moves
+    for i, enemy in enumerate(enemies):
+        if enemy.is_dead():
+            continue
+            
+        # AI decides next move
+        if USE_DIJKSTRA:
+            target_x, target_y = enemy.ai_turn_dijkstra()
+        else:
+            target_x, target_y = enemy.ai_turn(player.get_position())
+        
+        # Check if move is valid and not claimed by another enemy
+        if can_move_to(target_x, target_y, enemy) and (target_x, target_y) not in claimed_positions:
+            enemies_to_move.append((enemy, target_x, target_y))
+            claimed_positions.add((target_x, target_y))
+    
+    # Start all enemy animations simultaneously
+    any_enemy_moved = False
+    if enemies_to_move:
+        for enemy, tx, ty in enemies_to_move:
+            enemy.start_move(tx, ty, duration=motion_speed)
+            any_enemy_moved = True
+    
+    # Process player's queued move at the same time
+    if move_queue:
+        next_move = move_queue.pop(0)
+        process_player_queued_move(next_move)
+    else:
+        # No queued move, set up callback to return control when animations finish
+        if any_enemy_moved:
+            # Wait for animations to complete
+            mcrfpy.setTimer("turn_complete", check_turn_complete, int(motion_speed * 1000) + 50)
+        else:
+            # No animations, return control immediately
+            is_player_turn = True
+
+def process_player_queued_move(key):
+    """Process player's queued move during enemy turn"""
+    global current_move, current_destination
+    global player_anim_x, player_anim_y, grid_anim_x, grid_anim_y
+    
+    px, py = int(player.x), int(player.y)
+    new_x, new_y = px, py
+    
+    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 new_x != px or new_y != py:
+        # Check destination at animation end time (considering enemy destinations)
+        future_blocker = get_future_blocking_entity_at(new_x, new_y)
+        
+        if future_blocker:
+            # Will bump at destination
+            # Schedule bump for when animations complete
+            mcrfpy.setTimer("delayed_bump", lambda t: handle_delayed_bump(future_blocker), int(motion_speed * 1000))
+        elif can_move_to(new_x, new_y, player):
+            # Valid move, start animation
+            player.is_moving = True
+            current_move = key
+            current_destination = (new_x, new_y)
+            player.dest_x = new_x
+            player.dest_y = new_y
+            
+            # Player animation with callback
+            player_anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad", callback=player_queued_move_complete)
+            player_anim_x.start(player)
+            player_anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad")
+            player_anim_y.start(player)
+            
+            # Move camera with 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)
+        else:
+            # Blocked by wall, wait for turn to complete
+            mcrfpy.setTimer("turn_complete", check_turn_complete, int(motion_speed * 1000) + 50)
+
+def get_future_blocking_entity_at(x, y):
+    """Get entity that will be blocking at position after current animations"""
+    for e in grid.entities:
+        if not e.walkable and (x, y) == (e.dest_x, e.dest_y):
+            return e
+    return None
+
+def handle_delayed_bump(entity):
+    """Handle bump after animations complete"""
+    global is_player_turn
+    entity.on_bump(player)
+    is_player_turn = True
+
+def player_queued_move_complete(anim, target):
+    """Called when player's queued movement completes"""
+    global is_player_turn
+    player.is_moving = False
+    update_fov()
+    center_on_perspective()
+    is_player_turn = True
+
+def check_turn_complete(timer_name):
+    """Check if all animations are complete"""
+    global is_player_turn
+    
+    # Check if any entity is still moving
+    if player.is_moving:
+        mcrfpy.setTimer("turn_complete", check_turn_complete, 50)
+        return
+        
+    for enemy in enemies:
+        if enemy.is_moving:
+            mcrfpy.setTimer("turn_complete", check_turn_complete, 50)
+            return
+    
+    # All done
+    is_player_turn = True
+
+def process_move(key):
+    """Process a move based on the key"""
+    global current_move, current_destination, move_queue
+    global player_anim_x, player_anim_y, grid_anim_x, grid_anim_y, is_player_turn
+    
+    # Only allow player movement on player's turn
+    if not is_player_turn:
+        return
+    
+    # Only allow player movement when in player perspective
+    if grid.perspective != player:
+        return
+    
+    if player.is_moving:
+        move_queue.clear()
+        move_queue.append(key)
+        return
+    
+    px, py = int(player.x), int(player.y)
+    new_x, new_y = px, py
+    
+    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 new_x != px or new_y != py:
+        # Check what's at destination
+        blocker = get_blocking_entity_at(new_x, new_y)
+        
+        if blocker:
+            # Bump interaction (combat will go here later)
+            blocker.on_bump(player)
+            # Still counts as a turn
+            is_player_turn = False
+            process_enemy_turns_and_player_queue()
+        elif can_move_to(new_x, new_y, player):
+            player.is_moving = True
+            current_move = key
+            current_destination = (new_x, new_y)
+            player.dest_x = new_x
+            player.dest_y = new_y
+            
+            # Start player move animation
+            player_anim_x = mcrfpy.Animation("x", float(new_x), motion_speed, "easeInOutQuad", callback=movement_complete)
+            player_anim_x.start(player)
+            player_anim_y = mcrfpy.Animation("y", float(new_y), motion_speed, "easeInOutQuad")
+            player_anim_y.start(player)
+            
+            # Move camera with 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)
+
+def handle_keys(key, state):
+    """Handle keyboard input"""
+    if state == "start":
+        # Movement keys
+        if key in ["W", "Up", "S", "Down", "A", "Left", "D", "Right"]:
+            process_move(key)
+        
+# Register the keyboard handler
+mcrfpy.keypressScene(handle_keys)
+
+# Add UI elements
+title = mcrfpy.Caption((320, 10),
+    text="McRogueFace Tutorial - Part 6: Turn-based Movement",
+)
+title.fill_color = mcrfpy.Color(255, 255, 255, 255)
+mcrfpy.sceneUI("tutorial").append(title)
+
+instructions = mcrfpy.Caption((150, 720),
+    text="Use WASD/Arrows to move. Enemies move after you!",
+)
+instructions.font_size = 18
+instructions.fill_color = mcrfpy.Color(200, 200, 200, 255)
+mcrfpy.sceneUI("tutorial").append(instructions)
+
+# Debug info
+debug_caption = mcrfpy.Caption((10, 40),
+    text=f"Grid: {grid_width}x{grid_height} | Rooms: {len(rooms)} | Enemies: {len(enemies)}",
+)
+debug_caption.font_size = 16
+debug_caption.fill_color = mcrfpy.Color(255, 255, 0, 255)
+mcrfpy.sceneUI("tutorial").append(debug_caption)
+
+# Update function for turn display
+def update_turn_display():
+    turn_text = "Player" if is_player_turn else "Enemy"
+    alive_enemies = sum(1 for e in enemies if not e.is_dead())
+    debug_caption.text = f"Grid: {grid_width}x{grid_height} | Turn: {turn_text} | Enemies: {alive_enemies}/{len(enemies)}"
+
+# Configuration toggle
+USE_DIJKSTRA = True  # Set to False to use old line-of-sight AI
+
+# Timer to update display
+def update_display(runtime):
+    update_turn_display()
+
+mcrfpy.setTimer("display_update", update_display, 100)
+
+print("Tutorial Part 6 loaded!")
+print("Turn-based movement system active!")
+print(f"Using {'Dijkstra' if USE_DIJKSTRA else 'Line-of-sight'} AI pathfinding")
+print("- Enemies move after the player")
+print("- Enemies pursue when they can see you" if not USE_DIJKSTRA else "- Enemies use optimal pathfinding")
+print("- Enemies wander when they can't" if not USE_DIJKSTRA else "- All enemies share one pathfinding map")
+print("Use WASD or Arrow keys to move!")