Struct GameStateMachine 

pub struct GameStateMachine { /* private fields */ }

Game state machine for managing different phases of gameplay.

Implementations

impl GameStateMachine

pub fn new(initial_state: GameState) -> Self

Creates a new game state machine.

Examples found in repository

examples/game_systems_demo.rs (line 213)

fn demonstrate_game_state_machine() {
  let mut state_machine = GameStateMachine::new(GameState::Initialize);
  
  println!("Starting game state machine...");
  println!("Current state: {:?}", state_machine.current_state());

  // Simulate game startup sequence
  let state_transitions = [
  (GameStateEvent::InitComplete, "Game initialized"),
  (GameStateEvent::StartGame, "Starting new game"),
  (GameStateEvent::StartGame, "Loading complete, entering gameplay"),
  (GameStateEvent::EnterCombat, "Combat encounter!"),
  (GameStateEvent::ExitCombat, "Combat resolved"),
  (GameStateEvent::Pause, "Game paused"),
  (GameStateEvent::Resume, "Game resumed"),
  (GameStateEvent::OpenInventory, "Checking inventory"),
  (GameStateEvent::CloseInventory, "Inventory closed"),
  ];

  for (event, description) in state_transitions {
  if state_machine.process_event(event) {
    println!("  {} → {:?} ({})", 
      format!("{:?}", event), 
      state_machine.current_state(), 
      description);
  } else {
    println!("  {} → Failed (invalid transition from {:?})", 
      format!("{:?}", event),
      state_machine.current_state());
  }
  }

  // Demonstrate state data
  state_machine.set_state_data("player_name".to_string(), "Hero".to_string());
  state_machine.set_state_data("level".to_string(), "forest_1".to_string());
  
  println!("\nState data:");
  if let Some(name) = state_machine.get_state_data("player_name") {
  println!("  Player name: {}", name);
  }
  if let Some(level) = state_machine.get_state_data("level") {
  println!("  Current level: {}", level);
  }

  println!("Final state: {:?}", state_machine.current_state());
}

fn demonstrate_resource_management() {
  let mut resource_manager = ResourceManager::new();

  println!("Setting up entities with resources...");

  // Create different entity types
  resource_manager.add_entity(1, 100.0, 50.0);  // Player: 100 HP, 50 MP
  resource_manager.add_entity(2, 80.0, 0.0);    // Warrior: 80 HP, 0 MP
  resource_manager.add_entity(3, 60.0, 100.0);  // Mage: 60 HP, 100 MP
  resource_manager.add_entity(4, 150.0, 25.0);  // Boss: 150 HP, 25 MP

  // Configure regeneration
  if let Some(resources) = resource_manager.get_resources_mut(1) {
  resources.health.regeneration = 2.0; // Player regenerates 2 HP/sec
  resources.mana.regeneration = 5.0;   // Player regenerates 5 MP/sec
  }

  if let Some(resources) = resource_manager.get_resources_mut(3) {
  resources.mana.regeneration = 3.0;   // Mage regenerates 3 MP/sec
  }

  println!("\nInitial resources:");
  for entity_id in [1, 2, 3, 4] {
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = match entity_id {
      1 => "Player",
      2 => "Warrior", 
      3 => "Mage",
      4 => "Boss",
      _ => "Unknown"
    };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP", 
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.mana.current, resources.mana.maximum);
  }
  }

  println!("\nSimulating combat damage...");

  // Player takes damage
  resource_manager.modify_health(1, -25.0);
  resource_manager.modify_mana(1, -15.0);
  println!("  Player takes 25 damage, uses 15 mana");

  // Warrior takes heavy damage
  resource_manager.modify_health(2, -60.0);
  println!("  Warrior takes 60 damage");

  // Mage uses lots of mana
  resource_manager.modify_mana(3, -80.0);
  println!("  Mage uses 80 mana for powerful spell");

  // Boss takes some damage
  resource_manager.modify_health(4, -45.0);
  println!("  Boss takes 45 damage from combined attacks");

  println!("\nAfter combat:");
  for entity_id in [1, 2, 3, 4] {
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = match entity_id {
      1 => "Player",
      2 => "Warrior",
      3 => "Mage", 
      4 => "Boss",
      _ => "Unknown"
    };
    println!("  {}: {:.0}/{:.0} HP ({:.0}%), {:.0}/{:.0} MP ({:.0}%)",
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.health.percentage() * 100.0,
      resources.mana.current, resources.mana.maximum,
      resources.mana.percentage() * 100.0);
  }
  }

  println!("\nSimulating 3 seconds of regeneration...");
  resource_manager.update_all(3.0);

  println!("After regeneration:");
  for entity_id in [1, 3] { // Only show entities with regen
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = if entity_id == 1 { "Player" } else { "Mage" };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP",
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.mana.current, resources.mana.maximum);
  }
  }

  // Check for defeated entities
  let defeated = resource_manager.get_defeated_entities();
  if !defeated.is_empty() {
  println!("\nDefeated entities: {:?}", defeated);
  } else {
  println!("\nNo entities defeated");
  }
}

fn demonstrate_quest_system() {
  let mut quest_manager = QuestManager::new();

  println!("Setting up quest system...");

  // Create a main quest
  let main_quest = Quest {
  id: "save_village".to_string(),
  name: "Save the Village".to_string(),
  description: "The village is under attack by orcs. Eliminate the threat!".to_string(),
  status: QuestStatus::Available,
  objectives: vec![
    QuestObjective {
      id: "kill_orcs".to_string(),
      description: "Eliminate 5 orc raiders".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc".to_string(),
        count: 5,
        current: 0,
      },
      optional: false,
    },
    QuestObjective {
      id: "find_chief".to_string(),
      description: "Find and defeat the orc chieftain".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc_chief".to_string(),
        count: 1,
        current: 0,
      },
      optional: false,
    },
    QuestObjective {
      id: "rescue_villagers".to_string(),
      description: "Rescue captured villagers (Optional)".to_string(),
      completed: false,
      objective_type: ObjectiveType::Custom {
        data: vec![("rescued".to_string(), "0".to_string())].into_iter().collect(),
      },
      optional: true,
    },
  ],
  prerequisites: vec![],
  rewards: vec![
    QuestReward::Experience(500),
    QuestReward::Currency(100),
    QuestReward::Items("healing_potion".to_string(), 3),
  ],
  data: HashMap::new(),
  };

  // Create a side quest
  let side_quest = Quest {
  id: "gather_herbs".to_string(),
  name: "Herb Gathering".to_string(),
  description: "Collect medicinal herbs for the village healer".to_string(),
  status: QuestStatus::Available,
  objectives: vec![
    QuestObjective {
      id: "collect_herbs".to_string(),
      description: "Collect 10 healing herbs".to_string(),
      completed: false,
      objective_type: ObjectiveType::CollectItems {
        item_id: "healing_herb".to_string(),
        count: 10,
        current: 0,
      },
      optional: false,
    },
  ],
  prerequisites: vec![],
  rewards: vec![
    QuestReward::Experience(100),
    QuestReward::Currency(25),
  ],
  data: HashMap::new(),
  };

  quest_manager.add_quest(main_quest);
  quest_manager.add_quest(side_quest);

  // Start both quests
  println!("\nStarting quests...");
  quest_manager.start_quest("save_village", 1);
  quest_manager.start_quest("gather_herbs", 1);

  println!("Active quests: {}", quest_manager.active_quests().len());
  for quest in quest_manager.active_quests() {
  println!("  • {} - {}", quest.name, quest.description);
  for objective in &quest.objectives {
    let status = if objective.completed { "✓" } else { "○" };
    let optional = if objective.optional { " (Optional)" } else { "" };
    println!("    {} {}{}", status, objective.description, optional);
  }
  }

  println!("\nSimulating quest progress...");

  // Progress herb collection
  quest_manager.update_objective("gather_herbs", "collect_herbs", 4);
  println!("  Collected 4 herbs...");
  
  quest_manager.update_objective("gather_herbs", "collect_herbs", 6);
  println!("  Collected 6 more herbs (10/10 complete)");

  // Progress orc elimination
  quest_manager.update_objective("save_village", "kill_orcs", 3);
  println!("  Defeated 3 orcs...");

  quest_manager.update_objective("save_village", "kill_orcs", 2);
  println!("  Defeated 2 more orcs (5/5 complete)");

  // Complete chieftain objective
  quest_manager.update_objective("save_village", "find_chief", 1);
  println!("  Defeated orc chieftain!");

  println!("\nQuest completion status:");
  println!("  Completed quests: {}", quest_manager.completed_quest_count());
  for quest in quest_manager.completed_quests() {
  println!("    ✓ {} - Completed!", quest.name);
  println!("      Rewards:");
  for reward in &quest.rewards {
    match reward {
      QuestReward::Experience(exp) => println!("        • {} Experience", exp),
      QuestReward::Currency(gold) => println!("        • {} Gold", gold),
      QuestReward::Items(item, count) => println!("        • {} x{}", item, count),
      QuestReward::UnlockQuest(quest_id) => println!("        • Unlock Quest: {}", quest_id),
      QuestReward::SetFlag(flag) => println!("        • Set Flag: {}", flag),
    }
  }
  }

  // Demonstrate flags
  quest_manager.set_flag("village_saved".to_string(), true);
  quest_manager.set_flag("hero_reputation".to_string(), true);
  
  println!("\nGlobal flags set:");
  println!("  village_saved: {}", quest_manager.get_flag("village_saved"));
  println!("  hero_reputation: {}", quest_manager.get_flag("hero_reputation"));
}

fn demonstrate_integrated_gameplay() {
  println!("Setting up integrated tactical RPG session...");

  // Initialize all systems
  let mut turn_game = TurnBasedGame::new();
  let mut resources = ResourceManager::new();
  let mut state_machine = GameStateMachine::new(GameState::Playing);
  let mut quest_manager = QuestManager::new();
  let mut event_bus = EventBus::new();

  // Set up event listeners for system integration
  event_bus.subscribe(|event: &TurnStartedEvent| {
  println!("🎯 Turn started for entity {} (Round {})", event.entity_id, event.round_number);
  EventResult::Continue
  });

  event_bus.subscribe(|event: &ResourceChangedEvent| {
  if event.resource_type == "health" && event.new_value <= 0.0 {
    println!("💀 Entity {} has fallen!", event.entity_id);
  }
  EventResult::Continue
  });

  // Create a tactical scenario
  println!("\n🗺️ Tactical Battle Setup");
  println!("Party vs Orc Raiders");

  // Add party members
  turn_game.add_participant(1, 85);   // Player Fighter
  turn_game.add_participant(2, 95);   // Player Mage
  turn_game.add_participant(3, 75);   // Player Cleric

  // Add enemies  
  turn_game.add_participant(11, 80);  // Orc Warrior 1
  turn_game.add_participant(12, 70);  // Orc Warrior 2
  turn_game.add_participant(13, 90);  // Orc Shaman

  // Initialize resources for all participants
  resources.add_entity(1, 120.0, 30.0);   // Fighter: High HP, Low MP
  resources.add_entity(2, 70.0, 100.0);   // Mage: Low HP, High MP
  resources.add_entity(3, 90.0, 80.0);    // Cleric: Medium HP, High MP

  resources.add_entity(11, 85.0, 10.0);   // Orc Warrior 1
  resources.add_entity(12, 85.0, 10.0);   // Orc Warrior 2  
  resources.add_entity(13, 65.0, 60.0);   // Orc Shaman

  // Create quest for this battle
  let battle_quest = Quest {
  id: "orc_encounter".to_string(),
  name: "Orc Encounter".to_string(),
  description: "Defeat the orc raiding party".to_string(),
  status: QuestStatus::Active,
  objectives: vec![
    QuestObjective {
      id: "defeat_orcs".to_string(),
      description: "Defeat all orc raiders".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc".to_string(),
        count: 3,
        current: 0,
      },
      optional: false,
    },
  ],
  prerequisites: vec![],
  rewards: vec![QuestReward::Experience(200)],
  data: HashMap::new(),
  };

  quest_manager.add_quest(battle_quest);

  // Create a visual representation
  let mut battle_grid = GridRenderer::new()
  .with_size(12, 8)
  .with_style(GridStyle::Square8);

  // Position party members
  battle_grid.add_colored_marker((2, 6), "F", "Fighter", DebugColor::Green, 10);
  battle_grid.add_colored_marker((1, 5), "M", "Mage", DebugColor::Blue, 10);
  battle_grid.add_colored_marker((3, 5), "C", "Cleric", DebugColor::Yellow, 10);

  // Position enemies
  battle_grid.add_colored_marker((9, 4), "O1", "Orc Warrior", DebugColor::Red, 10);
  battle_grid.add_colored_marker((10, 6), "O2", "Orc Warrior", DebugColor::Red, 10);
  battle_grid.add_colored_marker((8, 2), "S", "Orc Shaman", DebugColor::Purple, 10);

  // Add environmental elements
  battle_grid.add_colored_marker((5, 3), "T", "Tree", DebugColor::Green, 5);
  battle_grid.add_colored_marker((6, 5), "R", "Rock", DebugColor::Gray, 5);

  println!("\nBattlefield:");
  println!("{}", battle_grid.render_ascii());

  println!("Combat begins!");

  // Simulate one round of combat
  let mut actions_this_round = 0;
  let start_round = turn_game.round_number();

  while turn_game.round_number() == start_round && actions_this_round < 6 {
  if let Some(current_entity) = turn_game.current_turn() {
    let entity_name = match current_entity {
      1 => "Fighter",
      2 => "Mage", 
      3 => "Cleric",
      11 => "Orc Warrior 1",
      12 => "Orc Warrior 2",
      13 => "Orc Shaman",
      _ => "Unknown"
    };

    // Publish turn started event
    event_bus.publish(TurnStartedEvent {
      entity_id: current_entity,
      round_number: turn_game.round_number(),
      action_points: turn_game.current_participant().unwrap().action_points,
    });

    // Simulate actions based on entity type and AI
    match current_entity {
      1 => { // Fighter
        println!("  {} attacks Orc Warrior 1 with sword!", entity_name);
        resources.modify_health(11, -25.0);
        turn_game.spend_action_points(2);
        
        event_bus.publish(ResourceChangedEvent {
          entity_id: 11,
          resource_type: "health".to_string(),
          old_value: 85.0,
          new_value: resources.get_resources(11).unwrap().health.current,
        });
      },
      2 => { // Mage
        println!("  {} casts fireball at Orc Shaman!", entity_name);
        resources.modify_health(13, -35.0);
        resources.modify_mana(2, -20.0);
        turn_game.spend_action_points(3);
      },
      3 => { // Cleric  
        println!("  {} heals Fighter!", entity_name);
        resources.modify_health(1, 15.0);
        resources.modify_mana(3, -15.0);
        turn_game.spend_action_points(2);
      },
      11 => { // Orc Warrior 1
        if resources.get_resources(11).unwrap().health.current > 0.0 {
          println!("  {} attacks Fighter with axe!", entity_name);
          resources.modify_health(1, -20.0);
          turn_game.spend_action_points(2);
        }
      },
      12 => { // Orc Warrior 2
        println!("  {} charges at Mage!", entity_name);
        resources.modify_health(2, -18.0);
        turn_game.spend_action_points(3);
      },
      13 => { // Orc Shaman
        if resources.get_resources(13).unwrap().health.current > 0.0 {
          println!("  {} casts dark bolt at Cleric!", entity_name);
          resources.modify_health(3, -15.0);
          resources.modify_mana(13, -10.0);
          turn_game.spend_action_points(2);
        }
      },
      _ => {}
    }

    turn_game.end_turn();
    actions_this_round += 1;
  }

  event_bus.process_events();
  }

  println!("\n📊 End of Round Status:");
  for entity_id in [1, 2, 3, 11, 12, 13] {
  if let Some(res) = resources.get_resources(entity_id) {
    let name = match entity_id {
      1 => "Fighter",
      2 => "Mage",
      3 => "Cleric", 
      11 => "Orc Warrior 1",
      12 => "Orc Warrior 2",
      13 => "Orc Shaman",
      _ => "Unknown"
    };
    
    let status = if res.health.current <= 0.0 { " [DEFEATED]" } else { "" };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP{}",
      name, res.health.current, res.health.maximum,
      res.mana.current, res.mana.maximum, status);
  }
  }

  // Check for defeated enemies and update quest progress
  let mut orcs_defeated = 0;
  for orc_id in [11, 12, 13] {
  if let Some(res) = resources.get_resources(orc_id) {
    if res.health.current <= 0.0 {
      orcs_defeated += 1;
    }
  }
  }

  if orcs_defeated > 0 {
  quest_manager.update_objective("orc_encounter", "defeat_orcs", orcs_defeated);
  println!("\n📜 Quest Progress: {} orcs defeated", orcs_defeated);
  }

  // Check if battle is won
  let party_alive = [1, 2, 3].iter().any(|&id| {
  resources.get_resources(id).unwrap().health.current > 0.0
  });
  
  let enemies_alive = [11, 12, 13].iter().any(|&id| {
  resources.get_resources(id).unwrap().health.current > 0.0
  });

  if !enemies_alive && party_alive {
  println!("\n🎉 Victory! All orcs defeated!");
  state_machine.process_event(GameStateEvent::VictoryAchieved);
  
  if quest_manager.is_quest_completed("orc_encounter") {
    event_bus.publish(QuestCompletedEvent {
      quest_id: "orc_encounter".to_string(),
      rewards: vec![QuestReward::Experience(200)],
    });
  }
  } else if !party_alive {
  println!("\n💀 Defeat! The party has fallen...");
  state_machine.process_event(GameStateEvent::PlayerDefeated);
  } else {
  println!("\n⚔️ Battle continues! Both sides still fighting.");
  }

  println!("Final game state: {:?}", state_machine.current_state());
  
  event_bus.process_events();

  println!("\n🎯 Integration Summary:");
  println!("This demonstrated how all systems work together:");
  println!("• Turn-based combat managed participant order and actions");
  println!("• Resource system tracked health/mana for all entities");
  println!("• Quest system monitored combat objectives");
  println!("• Event system coordinated between systems");
  println!("• State machine tracked overall game flow");
  println!("• Debug visualization showed tactical positions");
}

examples/beginner_tutorial.rs (line 472)

fn tutorial_step_8_complete_game() {
    println!("🎯 Step 8: Complete Mini-Game");
    println!("-----------------------------");
    println!("Let's put everything together into a working game!");
    
    // Game components
    let mut world = World::new();
    let mut turn_game = TurnBasedGame::new();
    let mut resource_manager = ResourceManager::new();
    let mut event_bus = EventBus::new();
    let mut state_machine = GameStateMachine::new(GameState::Playing);
    
    // Game events
    #[derive(Debug, Clone)]
    struct PlayerMoved {
        from: (i32, i32),
        to: (i32, i32),
    }
    
    #[derive(Debug, Clone)] 
    struct EnemyDefeated {
        enemy_type: String,
        position: (i32, i32),
    }
    
    #[derive(Debug, Clone)]
    struct TreasureFound {
        position: (i32, i32),
        value: u32,
    }
    
    // Events automatically implement Event trait via blanket impl
    
    // Set up event listeners
    event_bus.subscribe(|event: &PlayerMoved| {
        println!("📍 Player moved from ({}, {}) to ({}, {})", 
            event.from.0, event.from.1, event.to.0, event.to.1);
        EventResult::Continue
    });
    
    event_bus.subscribe(|event: &EnemyDefeated| {
        println!("💀 {} defeated at ({}, {})!", 
            event.enemy_type, event.position.0, event.position.1);
        EventResult::Continue
    });
    
    event_bus.subscribe(|event: &TreasureFound| {
        println!("💰 Found treasure worth {} gold at ({}, {})!", 
            event.value, event.position.0, event.position.1);
        EventResult::Continue
    });
    
    // Create game entities
    let player = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(1, 1)),
        Health::new(100),
    ));
    
    let goblin = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(4, 2)),
        Health::new(25),
    ));
    
    let _treasure = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(6, 3)),
    ));
    
    // Add to game systems
    turn_game.add_participant(player.id() as u32, 100); // Player goes first
    turn_game.add_participant(goblin.id() as u32, 80);  // Goblin second
    
    resource_manager.add_entity(player.id() as u32, 100.0, 30.0);
    resource_manager.add_entity(goblin.id() as u32, 25.0, 0.0);
    
    println!("🎮 Mini Dungeon Explorer Started!");
    println!("Player Goal: Defeat the goblin and find the treasure");
    
    // Game state tracking
    let mut player_gold = 0;
    let mut enemies_defeated = 0;
    
    // Simulate simple gameplay
    println!("\n=== Game Simulation ===");
    
    // Player moves towards goblin
    let player_start = SquareCoord::<FourConnected>::new(1, 1);
    let goblin_pos = SquareCoord::<FourConnected>::new(4, 2);
    
    event_bus.publish(PlayerMoved { 
        from: (player_start.x, player_start.y), 
        to: (goblin_pos.x - 1, goblin_pos.y) 
    });
    
    // Combat occurs
    println!("⚔️ Player attacks goblin!");
    resource_manager.modify_health(goblin.id() as u32, -25.0); // Defeat goblin
    
    event_bus.publish(EnemyDefeated {
        enemy_type: "Goblin".to_string(),
        position: (goblin_pos.x, goblin_pos.y),
    });
    enemies_defeated += 1;
    
    // Player finds treasure
    let treasure_pos = SquareCoord::<FourConnected>::new(6, 3);
    event_bus.publish(TreasureFound {
        position: (treasure_pos.x, treasure_pos.y),
        value: 100,
    });
    player_gold += 100;
    
    // Victory condition
    state_machine.process_event(GameStateEvent::VictoryAchieved);
    println!("🎉 Victory! Game completed!");
    
    event_bus.process_events();
    
    // Final game summary
    println!("\n📋 Game Summary:");
    println!("   Final State: {:?}", state_machine.current_state());
    println!("   Player Gold: {}", player_gold);
    println!("   Enemies Defeated: {}", enemies_defeated);
    
    if state_machine.current_state() == GameState::Victory {
        println!("🏆 Congratulations! You've mastered the basics of tiles_tools!");
    } else {
        println!("⏰ Game ended - but you've learned the fundamentals!");
    }
    
    println!("✅ You've built a complete tile-based game using tiles_tools!\n");
}

pub fn current_state(&self) -> GameState

Gets the current state.

Examples found in repository

examples/game_systems_demo.rs (line 216)

fn demonstrate_game_state_machine() {
  let mut state_machine = GameStateMachine::new(GameState::Initialize);
  
  println!("Starting game state machine...");
  println!("Current state: {:?}", state_machine.current_state());

  // Simulate game startup sequence
  let state_transitions = [
  (GameStateEvent::InitComplete, "Game initialized"),
  (GameStateEvent::StartGame, "Starting new game"),
  (GameStateEvent::StartGame, "Loading complete, entering gameplay"),
  (GameStateEvent::EnterCombat, "Combat encounter!"),
  (GameStateEvent::ExitCombat, "Combat resolved"),
  (GameStateEvent::Pause, "Game paused"),
  (GameStateEvent::Resume, "Game resumed"),
  (GameStateEvent::OpenInventory, "Checking inventory"),
  (GameStateEvent::CloseInventory, "Inventory closed"),
  ];

  for (event, description) in state_transitions {
  if state_machine.process_event(event) {
    println!("  {} → {:?} ({})", 
      format!("{:?}", event), 
      state_machine.current_state(), 
      description);
  } else {
    println!("  {} → Failed (invalid transition from {:?})", 
      format!("{:?}", event),
      state_machine.current_state());
  }
  }

  // Demonstrate state data
  state_machine.set_state_data("player_name".to_string(), "Hero".to_string());
  state_machine.set_state_data("level".to_string(), "forest_1".to_string());
  
  println!("\nState data:");
  if let Some(name) = state_machine.get_state_data("player_name") {
  println!("  Player name: {}", name);
  }
  if let Some(level) = state_machine.get_state_data("level") {
  println!("  Current level: {}", level);
  }

  println!("Final state: {:?}", state_machine.current_state());
}

fn demonstrate_resource_management() {
  let mut resource_manager = ResourceManager::new();

  println!("Setting up entities with resources...");

  // Create different entity types
  resource_manager.add_entity(1, 100.0, 50.0);  // Player: 100 HP, 50 MP
  resource_manager.add_entity(2, 80.0, 0.0);    // Warrior: 80 HP, 0 MP
  resource_manager.add_entity(3, 60.0, 100.0);  // Mage: 60 HP, 100 MP
  resource_manager.add_entity(4, 150.0, 25.0);  // Boss: 150 HP, 25 MP

  // Configure regeneration
  if let Some(resources) = resource_manager.get_resources_mut(1) {
  resources.health.regeneration = 2.0; // Player regenerates 2 HP/sec
  resources.mana.regeneration = 5.0;   // Player regenerates 5 MP/sec
  }

  if let Some(resources) = resource_manager.get_resources_mut(3) {
  resources.mana.regeneration = 3.0;   // Mage regenerates 3 MP/sec
  }

  println!("\nInitial resources:");
  for entity_id in [1, 2, 3, 4] {
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = match entity_id {
      1 => "Player",
      2 => "Warrior", 
      3 => "Mage",
      4 => "Boss",
      _ => "Unknown"
    };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP", 
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.mana.current, resources.mana.maximum);
  }
  }

  println!("\nSimulating combat damage...");

  // Player takes damage
  resource_manager.modify_health(1, -25.0);
  resource_manager.modify_mana(1, -15.0);
  println!("  Player takes 25 damage, uses 15 mana");

  // Warrior takes heavy damage
  resource_manager.modify_health(2, -60.0);
  println!("  Warrior takes 60 damage");

  // Mage uses lots of mana
  resource_manager.modify_mana(3, -80.0);
  println!("  Mage uses 80 mana for powerful spell");

  // Boss takes some damage
  resource_manager.modify_health(4, -45.0);
  println!("  Boss takes 45 damage from combined attacks");

  println!("\nAfter combat:");
  for entity_id in [1, 2, 3, 4] {
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = match entity_id {
      1 => "Player",
      2 => "Warrior",
      3 => "Mage", 
      4 => "Boss",
      _ => "Unknown"
    };
    println!("  {}: {:.0}/{:.0} HP ({:.0}%), {:.0}/{:.0} MP ({:.0}%)",
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.health.percentage() * 100.0,
      resources.mana.current, resources.mana.maximum,
      resources.mana.percentage() * 100.0);
  }
  }

  println!("\nSimulating 3 seconds of regeneration...");
  resource_manager.update_all(3.0);

  println!("After regeneration:");
  for entity_id in [1, 3] { // Only show entities with regen
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = if entity_id == 1 { "Player" } else { "Mage" };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP",
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.mana.current, resources.mana.maximum);
  }
  }

  // Check for defeated entities
  let defeated = resource_manager.get_defeated_entities();
  if !defeated.is_empty() {
  println!("\nDefeated entities: {:?}", defeated);
  } else {
  println!("\nNo entities defeated");
  }
}

fn demonstrate_quest_system() {
  let mut quest_manager = QuestManager::new();

  println!("Setting up quest system...");

  // Create a main quest
  let main_quest = Quest {
  id: "save_village".to_string(),
  name: "Save the Village".to_string(),
  description: "The village is under attack by orcs. Eliminate the threat!".to_string(),
  status: QuestStatus::Available,
  objectives: vec![
    QuestObjective {
      id: "kill_orcs".to_string(),
      description: "Eliminate 5 orc raiders".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc".to_string(),
        count: 5,
        current: 0,
      },
      optional: false,
    },
    QuestObjective {
      id: "find_chief".to_string(),
      description: "Find and defeat the orc chieftain".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc_chief".to_string(),
        count: 1,
        current: 0,
      },
      optional: false,
    },
    QuestObjective {
      id: "rescue_villagers".to_string(),
      description: "Rescue captured villagers (Optional)".to_string(),
      completed: false,
      objective_type: ObjectiveType::Custom {
        data: vec![("rescued".to_string(), "0".to_string())].into_iter().collect(),
      },
      optional: true,
    },
  ],
  prerequisites: vec![],
  rewards: vec![
    QuestReward::Experience(500),
    QuestReward::Currency(100),
    QuestReward::Items("healing_potion".to_string(), 3),
  ],
  data: HashMap::new(),
  };

  // Create a side quest
  let side_quest = Quest {
  id: "gather_herbs".to_string(),
  name: "Herb Gathering".to_string(),
  description: "Collect medicinal herbs for the village healer".to_string(),
  status: QuestStatus::Available,
  objectives: vec![
    QuestObjective {
      id: "collect_herbs".to_string(),
      description: "Collect 10 healing herbs".to_string(),
      completed: false,
      objective_type: ObjectiveType::CollectItems {
        item_id: "healing_herb".to_string(),
        count: 10,
        current: 0,
      },
      optional: false,
    },
  ],
  prerequisites: vec![],
  rewards: vec![
    QuestReward::Experience(100),
    QuestReward::Currency(25),
  ],
  data: HashMap::new(),
  };

  quest_manager.add_quest(main_quest);
  quest_manager.add_quest(side_quest);

  // Start both quests
  println!("\nStarting quests...");
  quest_manager.start_quest("save_village", 1);
  quest_manager.start_quest("gather_herbs", 1);

  println!("Active quests: {}", quest_manager.active_quests().len());
  for quest in quest_manager.active_quests() {
  println!("  • {} - {}", quest.name, quest.description);
  for objective in &quest.objectives {
    let status = if objective.completed { "✓" } else { "○" };
    let optional = if objective.optional { " (Optional)" } else { "" };
    println!("    {} {}{}", status, objective.description, optional);
  }
  }

  println!("\nSimulating quest progress...");

  // Progress herb collection
  quest_manager.update_objective("gather_herbs", "collect_herbs", 4);
  println!("  Collected 4 herbs...");
  
  quest_manager.update_objective("gather_herbs", "collect_herbs", 6);
  println!("  Collected 6 more herbs (10/10 complete)");

  // Progress orc elimination
  quest_manager.update_objective("save_village", "kill_orcs", 3);
  println!("  Defeated 3 orcs...");

  quest_manager.update_objective("save_village", "kill_orcs", 2);
  println!("  Defeated 2 more orcs (5/5 complete)");

  // Complete chieftain objective
  quest_manager.update_objective("save_village", "find_chief", 1);
  println!("  Defeated orc chieftain!");

  println!("\nQuest completion status:");
  println!("  Completed quests: {}", quest_manager.completed_quest_count());
  for quest in quest_manager.completed_quests() {
  println!("    ✓ {} - Completed!", quest.name);
  println!("      Rewards:");
  for reward in &quest.rewards {
    match reward {
      QuestReward::Experience(exp) => println!("        • {} Experience", exp),
      QuestReward::Currency(gold) => println!("        • {} Gold", gold),
      QuestReward::Items(item, count) => println!("        • {} x{}", item, count),
      QuestReward::UnlockQuest(quest_id) => println!("        • Unlock Quest: {}", quest_id),
      QuestReward::SetFlag(flag) => println!("        • Set Flag: {}", flag),
    }
  }
  }

  // Demonstrate flags
  quest_manager.set_flag("village_saved".to_string(), true);
  quest_manager.set_flag("hero_reputation".to_string(), true);
  
  println!("\nGlobal flags set:");
  println!("  village_saved: {}", quest_manager.get_flag("village_saved"));
  println!("  hero_reputation: {}", quest_manager.get_flag("hero_reputation"));
}

fn demonstrate_integrated_gameplay() {
  println!("Setting up integrated tactical RPG session...");

  // Initialize all systems
  let mut turn_game = TurnBasedGame::new();
  let mut resources = ResourceManager::new();
  let mut state_machine = GameStateMachine::new(GameState::Playing);
  let mut quest_manager = QuestManager::new();
  let mut event_bus = EventBus::new();

  // Set up event listeners for system integration
  event_bus.subscribe(|event: &TurnStartedEvent| {
  println!("🎯 Turn started for entity {} (Round {})", event.entity_id, event.round_number);
  EventResult::Continue
  });

  event_bus.subscribe(|event: &ResourceChangedEvent| {
  if event.resource_type == "health" && event.new_value <= 0.0 {
    println!("💀 Entity {} has fallen!", event.entity_id);
  }
  EventResult::Continue
  });

  // Create a tactical scenario
  println!("\n🗺️ Tactical Battle Setup");
  println!("Party vs Orc Raiders");

  // Add party members
  turn_game.add_participant(1, 85);   // Player Fighter
  turn_game.add_participant(2, 95);   // Player Mage
  turn_game.add_participant(3, 75);   // Player Cleric

  // Add enemies  
  turn_game.add_participant(11, 80);  // Orc Warrior 1
  turn_game.add_participant(12, 70);  // Orc Warrior 2
  turn_game.add_participant(13, 90);  // Orc Shaman

  // Initialize resources for all participants
  resources.add_entity(1, 120.0, 30.0);   // Fighter: High HP, Low MP
  resources.add_entity(2, 70.0, 100.0);   // Mage: Low HP, High MP
  resources.add_entity(3, 90.0, 80.0);    // Cleric: Medium HP, High MP

  resources.add_entity(11, 85.0, 10.0);   // Orc Warrior 1
  resources.add_entity(12, 85.0, 10.0);   // Orc Warrior 2  
  resources.add_entity(13, 65.0, 60.0);   // Orc Shaman

  // Create quest for this battle
  let battle_quest = Quest {
  id: "orc_encounter".to_string(),
  name: "Orc Encounter".to_string(),
  description: "Defeat the orc raiding party".to_string(),
  status: QuestStatus::Active,
  objectives: vec![
    QuestObjective {
      id: "defeat_orcs".to_string(),
      description: "Defeat all orc raiders".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc".to_string(),
        count: 3,
        current: 0,
      },
      optional: false,
    },
  ],
  prerequisites: vec![],
  rewards: vec![QuestReward::Experience(200)],
  data: HashMap::new(),
  };

  quest_manager.add_quest(battle_quest);

  // Create a visual representation
  let mut battle_grid = GridRenderer::new()
  .with_size(12, 8)
  .with_style(GridStyle::Square8);

  // Position party members
  battle_grid.add_colored_marker((2, 6), "F", "Fighter", DebugColor::Green, 10);
  battle_grid.add_colored_marker((1, 5), "M", "Mage", DebugColor::Blue, 10);
  battle_grid.add_colored_marker((3, 5), "C", "Cleric", DebugColor::Yellow, 10);

  // Position enemies
  battle_grid.add_colored_marker((9, 4), "O1", "Orc Warrior", DebugColor::Red, 10);
  battle_grid.add_colored_marker((10, 6), "O2", "Orc Warrior", DebugColor::Red, 10);
  battle_grid.add_colored_marker((8, 2), "S", "Orc Shaman", DebugColor::Purple, 10);

  // Add environmental elements
  battle_grid.add_colored_marker((5, 3), "T", "Tree", DebugColor::Green, 5);
  battle_grid.add_colored_marker((6, 5), "R", "Rock", DebugColor::Gray, 5);

  println!("\nBattlefield:");
  println!("{}", battle_grid.render_ascii());

  println!("Combat begins!");

  // Simulate one round of combat
  let mut actions_this_round = 0;
  let start_round = turn_game.round_number();

  while turn_game.round_number() == start_round && actions_this_round < 6 {
  if let Some(current_entity) = turn_game.current_turn() {
    let entity_name = match current_entity {
      1 => "Fighter",
      2 => "Mage", 
      3 => "Cleric",
      11 => "Orc Warrior 1",
      12 => "Orc Warrior 2",
      13 => "Orc Shaman",
      _ => "Unknown"
    };

    // Publish turn started event
    event_bus.publish(TurnStartedEvent {
      entity_id: current_entity,
      round_number: turn_game.round_number(),
      action_points: turn_game.current_participant().unwrap().action_points,
    });

    // Simulate actions based on entity type and AI
    match current_entity {
      1 => { // Fighter
        println!("  {} attacks Orc Warrior 1 with sword!", entity_name);
        resources.modify_health(11, -25.0);
        turn_game.spend_action_points(2);
        
        event_bus.publish(ResourceChangedEvent {
          entity_id: 11,
          resource_type: "health".to_string(),
          old_value: 85.0,
          new_value: resources.get_resources(11).unwrap().health.current,
        });
      },
      2 => { // Mage
        println!("  {} casts fireball at Orc Shaman!", entity_name);
        resources.modify_health(13, -35.0);
        resources.modify_mana(2, -20.0);
        turn_game.spend_action_points(3);
      },
      3 => { // Cleric  
        println!("  {} heals Fighter!", entity_name);
        resources.modify_health(1, 15.0);
        resources.modify_mana(3, -15.0);
        turn_game.spend_action_points(2);
      },
      11 => { // Orc Warrior 1
        if resources.get_resources(11).unwrap().health.current > 0.0 {
          println!("  {} attacks Fighter with axe!", entity_name);
          resources.modify_health(1, -20.0);
          turn_game.spend_action_points(2);
        }
      },
      12 => { // Orc Warrior 2
        println!("  {} charges at Mage!", entity_name);
        resources.modify_health(2, -18.0);
        turn_game.spend_action_points(3);
      },
      13 => { // Orc Shaman
        if resources.get_resources(13).unwrap().health.current > 0.0 {
          println!("  {} casts dark bolt at Cleric!", entity_name);
          resources.modify_health(3, -15.0);
          resources.modify_mana(13, -10.0);
          turn_game.spend_action_points(2);
        }
      },
      _ => {}
    }

    turn_game.end_turn();
    actions_this_round += 1;
  }

  event_bus.process_events();
  }

  println!("\n📊 End of Round Status:");
  for entity_id in [1, 2, 3, 11, 12, 13] {
  if let Some(res) = resources.get_resources(entity_id) {
    let name = match entity_id {
      1 => "Fighter",
      2 => "Mage",
      3 => "Cleric", 
      11 => "Orc Warrior 1",
      12 => "Orc Warrior 2",
      13 => "Orc Shaman",
      _ => "Unknown"
    };
    
    let status = if res.health.current <= 0.0 { " [DEFEATED]" } else { "" };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP{}",
      name, res.health.current, res.health.maximum,
      res.mana.current, res.mana.maximum, status);
  }
  }

  // Check for defeated enemies and update quest progress
  let mut orcs_defeated = 0;
  for orc_id in [11, 12, 13] {
  if let Some(res) = resources.get_resources(orc_id) {
    if res.health.current <= 0.0 {
      orcs_defeated += 1;
    }
  }
  }

  if orcs_defeated > 0 {
  quest_manager.update_objective("orc_encounter", "defeat_orcs", orcs_defeated);
  println!("\n📜 Quest Progress: {} orcs defeated", orcs_defeated);
  }

  // Check if battle is won
  let party_alive = [1, 2, 3].iter().any(|&id| {
  resources.get_resources(id).unwrap().health.current > 0.0
  });
  
  let enemies_alive = [11, 12, 13].iter().any(|&id| {
  resources.get_resources(id).unwrap().health.current > 0.0
  });

  if !enemies_alive && party_alive {
  println!("\n🎉 Victory! All orcs defeated!");
  state_machine.process_event(GameStateEvent::VictoryAchieved);
  
  if quest_manager.is_quest_completed("orc_encounter") {
    event_bus.publish(QuestCompletedEvent {
      quest_id: "orc_encounter".to_string(),
      rewards: vec![QuestReward::Experience(200)],
    });
  }
  } else if !party_alive {
  println!("\n💀 Defeat! The party has fallen...");
  state_machine.process_event(GameStateEvent::PlayerDefeated);
  } else {
  println!("\n⚔️ Battle continues! Both sides still fighting.");
  }

  println!("Final game state: {:?}", state_machine.current_state());
  
  event_bus.process_events();

  println!("\n🎯 Integration Summary:");
  println!("This demonstrated how all systems work together:");
  println!("• Turn-based combat managed participant order and actions");
  println!("• Resource system tracked health/mana for all entities");
  println!("• Quest system monitored combat objectives");
  println!("• Event system coordinated between systems");
  println!("• State machine tracked overall game flow");
  println!("• Debug visualization showed tactical positions");
}

examples/beginner_tutorial.rs (line 581)

fn tutorial_step_8_complete_game() {
    println!("🎯 Step 8: Complete Mini-Game");
    println!("-----------------------------");
    println!("Let's put everything together into a working game!");
    
    // Game components
    let mut world = World::new();
    let mut turn_game = TurnBasedGame::new();
    let mut resource_manager = ResourceManager::new();
    let mut event_bus = EventBus::new();
    let mut state_machine = GameStateMachine::new(GameState::Playing);
    
    // Game events
    #[derive(Debug, Clone)]
    struct PlayerMoved {
        from: (i32, i32),
        to: (i32, i32),
    }
    
    #[derive(Debug, Clone)] 
    struct EnemyDefeated {
        enemy_type: String,
        position: (i32, i32),
    }
    
    #[derive(Debug, Clone)]
    struct TreasureFound {
        position: (i32, i32),
        value: u32,
    }
    
    // Events automatically implement Event trait via blanket impl
    
    // Set up event listeners
    event_bus.subscribe(|event: &PlayerMoved| {
        println!("📍 Player moved from ({}, {}) to ({}, {})", 
            event.from.0, event.from.1, event.to.0, event.to.1);
        EventResult::Continue
    });
    
    event_bus.subscribe(|event: &EnemyDefeated| {
        println!("💀 {} defeated at ({}, {})!", 
            event.enemy_type, event.position.0, event.position.1);
        EventResult::Continue
    });
    
    event_bus.subscribe(|event: &TreasureFound| {
        println!("💰 Found treasure worth {} gold at ({}, {})!", 
            event.value, event.position.0, event.position.1);
        EventResult::Continue
    });
    
    // Create game entities
    let player = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(1, 1)),
        Health::new(100),
    ));
    
    let goblin = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(4, 2)),
        Health::new(25),
    ));
    
    let _treasure = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(6, 3)),
    ));
    
    // Add to game systems
    turn_game.add_participant(player.id() as u32, 100); // Player goes first
    turn_game.add_participant(goblin.id() as u32, 80);  // Goblin second
    
    resource_manager.add_entity(player.id() as u32, 100.0, 30.0);
    resource_manager.add_entity(goblin.id() as u32, 25.0, 0.0);
    
    println!("🎮 Mini Dungeon Explorer Started!");
    println!("Player Goal: Defeat the goblin and find the treasure");
    
    // Game state tracking
    let mut player_gold = 0;
    let mut enemies_defeated = 0;
    
    // Simulate simple gameplay
    println!("\n=== Game Simulation ===");
    
    // Player moves towards goblin
    let player_start = SquareCoord::<FourConnected>::new(1, 1);
    let goblin_pos = SquareCoord::<FourConnected>::new(4, 2);
    
    event_bus.publish(PlayerMoved { 
        from: (player_start.x, player_start.y), 
        to: (goblin_pos.x - 1, goblin_pos.y) 
    });
    
    // Combat occurs
    println!("⚔️ Player attacks goblin!");
    resource_manager.modify_health(goblin.id() as u32, -25.0); // Defeat goblin
    
    event_bus.publish(EnemyDefeated {
        enemy_type: "Goblin".to_string(),
        position: (goblin_pos.x, goblin_pos.y),
    });
    enemies_defeated += 1;
    
    // Player finds treasure
    let treasure_pos = SquareCoord::<FourConnected>::new(6, 3);
    event_bus.publish(TreasureFound {
        position: (treasure_pos.x, treasure_pos.y),
        value: 100,
    });
    player_gold += 100;
    
    // Victory condition
    state_machine.process_event(GameStateEvent::VictoryAchieved);
    println!("🎉 Victory! Game completed!");
    
    event_bus.process_events();
    
    // Final game summary
    println!("\n📋 Game Summary:");
    println!("   Final State: {:?}", state_machine.current_state());
    println!("   Player Gold: {}", player_gold);
    println!("   Enemies Defeated: {}", enemies_defeated);
    
    if state_machine.current_state() == GameState::Victory {
        println!("🏆 Congratulations! You've mastered the basics of tiles_tools!");
    } else {
        println!("⏰ Game ended - but you've learned the fundamentals!");
    }
    
    println!("✅ You've built a complete tile-based game using tiles_tools!\n");
}

pub fn previous_state(&self) -> Option<GameState>

Gets the previous state.

pub fn add_transition( &mut self, from: GameState, event: GameStateEvent, to: GameState, )

Adds a state transition rule.

pub fn process_event(&mut self, event: GameStateEvent) -> bool

Processes a state event and potentially transitions to a new state.

Examples found in repository

examples/game_systems_demo.rs (line 232)

fn demonstrate_game_state_machine() {
  let mut state_machine = GameStateMachine::new(GameState::Initialize);
  
  println!("Starting game state machine...");
  println!("Current state: {:?}", state_machine.current_state());

  // Simulate game startup sequence
  let state_transitions = [
  (GameStateEvent::InitComplete, "Game initialized"),
  (GameStateEvent::StartGame, "Starting new game"),
  (GameStateEvent::StartGame, "Loading complete, entering gameplay"),
  (GameStateEvent::EnterCombat, "Combat encounter!"),
  (GameStateEvent::ExitCombat, "Combat resolved"),
  (GameStateEvent::Pause, "Game paused"),
  (GameStateEvent::Resume, "Game resumed"),
  (GameStateEvent::OpenInventory, "Checking inventory"),
  (GameStateEvent::CloseInventory, "Inventory closed"),
  ];

  for (event, description) in state_transitions {
  if state_machine.process_event(event) {
    println!("  {} → {:?} ({})", 
      format!("{:?}", event), 
      state_machine.current_state(), 
      description);
  } else {
    println!("  {} → Failed (invalid transition from {:?})", 
      format!("{:?}", event),
      state_machine.current_state());
  }
  }

  // Demonstrate state data
  state_machine.set_state_data("player_name".to_string(), "Hero".to_string());
  state_machine.set_state_data("level".to_string(), "forest_1".to_string());
  
  println!("\nState data:");
  if let Some(name) = state_machine.get_state_data("player_name") {
  println!("  Player name: {}", name);
  }
  if let Some(level) = state_machine.get_state_data("level") {
  println!("  Current level: {}", level);
  }

  println!("Final state: {:?}", state_machine.current_state());
}

fn demonstrate_resource_management() {
  let mut resource_manager = ResourceManager::new();

  println!("Setting up entities with resources...");

  // Create different entity types
  resource_manager.add_entity(1, 100.0, 50.0);  // Player: 100 HP, 50 MP
  resource_manager.add_entity(2, 80.0, 0.0);    // Warrior: 80 HP, 0 MP
  resource_manager.add_entity(3, 60.0, 100.0);  // Mage: 60 HP, 100 MP
  resource_manager.add_entity(4, 150.0, 25.0);  // Boss: 150 HP, 25 MP

  // Configure regeneration
  if let Some(resources) = resource_manager.get_resources_mut(1) {
  resources.health.regeneration = 2.0; // Player regenerates 2 HP/sec
  resources.mana.regeneration = 5.0;   // Player regenerates 5 MP/sec
  }

  if let Some(resources) = resource_manager.get_resources_mut(3) {
  resources.mana.regeneration = 3.0;   // Mage regenerates 3 MP/sec
  }

  println!("\nInitial resources:");
  for entity_id in [1, 2, 3, 4] {
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = match entity_id {
      1 => "Player",
      2 => "Warrior", 
      3 => "Mage",
      4 => "Boss",
      _ => "Unknown"
    };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP", 
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.mana.current, resources.mana.maximum);
  }
  }

  println!("\nSimulating combat damage...");

  // Player takes damage
  resource_manager.modify_health(1, -25.0);
  resource_manager.modify_mana(1, -15.0);
  println!("  Player takes 25 damage, uses 15 mana");

  // Warrior takes heavy damage
  resource_manager.modify_health(2, -60.0);
  println!("  Warrior takes 60 damage");

  // Mage uses lots of mana
  resource_manager.modify_mana(3, -80.0);
  println!("  Mage uses 80 mana for powerful spell");

  // Boss takes some damage
  resource_manager.modify_health(4, -45.0);
  println!("  Boss takes 45 damage from combined attacks");

  println!("\nAfter combat:");
  for entity_id in [1, 2, 3, 4] {
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = match entity_id {
      1 => "Player",
      2 => "Warrior",
      3 => "Mage", 
      4 => "Boss",
      _ => "Unknown"
    };
    println!("  {}: {:.0}/{:.0} HP ({:.0}%), {:.0}/{:.0} MP ({:.0}%)",
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.health.percentage() * 100.0,
      resources.mana.current, resources.mana.maximum,
      resources.mana.percentage() * 100.0);
  }
  }

  println!("\nSimulating 3 seconds of regeneration...");
  resource_manager.update_all(3.0);

  println!("After regeneration:");
  for entity_id in [1, 3] { // Only show entities with regen
  if let Some(resources) = resource_manager.get_resources(entity_id) {
    let entity_type = if entity_id == 1 { "Player" } else { "Mage" };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP",
      entity_type,
      resources.health.current, resources.health.maximum,
      resources.mana.current, resources.mana.maximum);
  }
  }

  // Check for defeated entities
  let defeated = resource_manager.get_defeated_entities();
  if !defeated.is_empty() {
  println!("\nDefeated entities: {:?}", defeated);
  } else {
  println!("\nNo entities defeated");
  }
}

fn demonstrate_quest_system() {
  let mut quest_manager = QuestManager::new();

  println!("Setting up quest system...");

  // Create a main quest
  let main_quest = Quest {
  id: "save_village".to_string(),
  name: "Save the Village".to_string(),
  description: "The village is under attack by orcs. Eliminate the threat!".to_string(),
  status: QuestStatus::Available,
  objectives: vec![
    QuestObjective {
      id: "kill_orcs".to_string(),
      description: "Eliminate 5 orc raiders".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc".to_string(),
        count: 5,
        current: 0,
      },
      optional: false,
    },
    QuestObjective {
      id: "find_chief".to_string(),
      description: "Find and defeat the orc chieftain".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc_chief".to_string(),
        count: 1,
        current: 0,
      },
      optional: false,
    },
    QuestObjective {
      id: "rescue_villagers".to_string(),
      description: "Rescue captured villagers (Optional)".to_string(),
      completed: false,
      objective_type: ObjectiveType::Custom {
        data: vec![("rescued".to_string(), "0".to_string())].into_iter().collect(),
      },
      optional: true,
    },
  ],
  prerequisites: vec![],
  rewards: vec![
    QuestReward::Experience(500),
    QuestReward::Currency(100),
    QuestReward::Items("healing_potion".to_string(), 3),
  ],
  data: HashMap::new(),
  };

  // Create a side quest
  let side_quest = Quest {
  id: "gather_herbs".to_string(),
  name: "Herb Gathering".to_string(),
  description: "Collect medicinal herbs for the village healer".to_string(),
  status: QuestStatus::Available,
  objectives: vec![
    QuestObjective {
      id: "collect_herbs".to_string(),
      description: "Collect 10 healing herbs".to_string(),
      completed: false,
      objective_type: ObjectiveType::CollectItems {
        item_id: "healing_herb".to_string(),
        count: 10,
        current: 0,
      },
      optional: false,
    },
  ],
  prerequisites: vec![],
  rewards: vec![
    QuestReward::Experience(100),
    QuestReward::Currency(25),
  ],
  data: HashMap::new(),
  };

  quest_manager.add_quest(main_quest);
  quest_manager.add_quest(side_quest);

  // Start both quests
  println!("\nStarting quests...");
  quest_manager.start_quest("save_village", 1);
  quest_manager.start_quest("gather_herbs", 1);

  println!("Active quests: {}", quest_manager.active_quests().len());
  for quest in quest_manager.active_quests() {
  println!("  • {} - {}", quest.name, quest.description);
  for objective in &quest.objectives {
    let status = if objective.completed { "✓" } else { "○" };
    let optional = if objective.optional { " (Optional)" } else { "" };
    println!("    {} {}{}", status, objective.description, optional);
  }
  }

  println!("\nSimulating quest progress...");

  // Progress herb collection
  quest_manager.update_objective("gather_herbs", "collect_herbs", 4);
  println!("  Collected 4 herbs...");
  
  quest_manager.update_objective("gather_herbs", "collect_herbs", 6);
  println!("  Collected 6 more herbs (10/10 complete)");

  // Progress orc elimination
  quest_manager.update_objective("save_village", "kill_orcs", 3);
  println!("  Defeated 3 orcs...");

  quest_manager.update_objective("save_village", "kill_orcs", 2);
  println!("  Defeated 2 more orcs (5/5 complete)");

  // Complete chieftain objective
  quest_manager.update_objective("save_village", "find_chief", 1);
  println!("  Defeated orc chieftain!");

  println!("\nQuest completion status:");
  println!("  Completed quests: {}", quest_manager.completed_quest_count());
  for quest in quest_manager.completed_quests() {
  println!("    ✓ {} - Completed!", quest.name);
  println!("      Rewards:");
  for reward in &quest.rewards {
    match reward {
      QuestReward::Experience(exp) => println!("        • {} Experience", exp),
      QuestReward::Currency(gold) => println!("        • {} Gold", gold),
      QuestReward::Items(item, count) => println!("        • {} x{}", item, count),
      QuestReward::UnlockQuest(quest_id) => println!("        • Unlock Quest: {}", quest_id),
      QuestReward::SetFlag(flag) => println!("        • Set Flag: {}", flag),
    }
  }
  }

  // Demonstrate flags
  quest_manager.set_flag("village_saved".to_string(), true);
  quest_manager.set_flag("hero_reputation".to_string(), true);
  
  println!("\nGlobal flags set:");
  println!("  village_saved: {}", quest_manager.get_flag("village_saved"));
  println!("  hero_reputation: {}", quest_manager.get_flag("hero_reputation"));
}

fn demonstrate_integrated_gameplay() {
  println!("Setting up integrated tactical RPG session...");

  // Initialize all systems
  let mut turn_game = TurnBasedGame::new();
  let mut resources = ResourceManager::new();
  let mut state_machine = GameStateMachine::new(GameState::Playing);
  let mut quest_manager = QuestManager::new();
  let mut event_bus = EventBus::new();

  // Set up event listeners for system integration
  event_bus.subscribe(|event: &TurnStartedEvent| {
  println!("🎯 Turn started for entity {} (Round {})", event.entity_id, event.round_number);
  EventResult::Continue
  });

  event_bus.subscribe(|event: &ResourceChangedEvent| {
  if event.resource_type == "health" && event.new_value <= 0.0 {
    println!("💀 Entity {} has fallen!", event.entity_id);
  }
  EventResult::Continue
  });

  // Create a tactical scenario
  println!("\n🗺️ Tactical Battle Setup");
  println!("Party vs Orc Raiders");

  // Add party members
  turn_game.add_participant(1, 85);   // Player Fighter
  turn_game.add_participant(2, 95);   // Player Mage
  turn_game.add_participant(3, 75);   // Player Cleric

  // Add enemies  
  turn_game.add_participant(11, 80);  // Orc Warrior 1
  turn_game.add_participant(12, 70);  // Orc Warrior 2
  turn_game.add_participant(13, 90);  // Orc Shaman

  // Initialize resources for all participants
  resources.add_entity(1, 120.0, 30.0);   // Fighter: High HP, Low MP
  resources.add_entity(2, 70.0, 100.0);   // Mage: Low HP, High MP
  resources.add_entity(3, 90.0, 80.0);    // Cleric: Medium HP, High MP

  resources.add_entity(11, 85.0, 10.0);   // Orc Warrior 1
  resources.add_entity(12, 85.0, 10.0);   // Orc Warrior 2  
  resources.add_entity(13, 65.0, 60.0);   // Orc Shaman

  // Create quest for this battle
  let battle_quest = Quest {
  id: "orc_encounter".to_string(),
  name: "Orc Encounter".to_string(),
  description: "Defeat the orc raiding party".to_string(),
  status: QuestStatus::Active,
  objectives: vec![
    QuestObjective {
      id: "defeat_orcs".to_string(),
      description: "Defeat all orc raiders".to_string(),
      completed: false,
      objective_type: ObjectiveType::KillTargets {
        target_type: "orc".to_string(),
        count: 3,
        current: 0,
      },
      optional: false,
    },
  ],
  prerequisites: vec![],
  rewards: vec![QuestReward::Experience(200)],
  data: HashMap::new(),
  };

  quest_manager.add_quest(battle_quest);

  // Create a visual representation
  let mut battle_grid = GridRenderer::new()
  .with_size(12, 8)
  .with_style(GridStyle::Square8);

  // Position party members
  battle_grid.add_colored_marker((2, 6), "F", "Fighter", DebugColor::Green, 10);
  battle_grid.add_colored_marker((1, 5), "M", "Mage", DebugColor::Blue, 10);
  battle_grid.add_colored_marker((3, 5), "C", "Cleric", DebugColor::Yellow, 10);

  // Position enemies
  battle_grid.add_colored_marker((9, 4), "O1", "Orc Warrior", DebugColor::Red, 10);
  battle_grid.add_colored_marker((10, 6), "O2", "Orc Warrior", DebugColor::Red, 10);
  battle_grid.add_colored_marker((8, 2), "S", "Orc Shaman", DebugColor::Purple, 10);

  // Add environmental elements
  battle_grid.add_colored_marker((5, 3), "T", "Tree", DebugColor::Green, 5);
  battle_grid.add_colored_marker((6, 5), "R", "Rock", DebugColor::Gray, 5);

  println!("\nBattlefield:");
  println!("{}", battle_grid.render_ascii());

  println!("Combat begins!");

  // Simulate one round of combat
  let mut actions_this_round = 0;
  let start_round = turn_game.round_number();

  while turn_game.round_number() == start_round && actions_this_round < 6 {
  if let Some(current_entity) = turn_game.current_turn() {
    let entity_name = match current_entity {
      1 => "Fighter",
      2 => "Mage", 
      3 => "Cleric",
      11 => "Orc Warrior 1",
      12 => "Orc Warrior 2",
      13 => "Orc Shaman",
      _ => "Unknown"
    };

    // Publish turn started event
    event_bus.publish(TurnStartedEvent {
      entity_id: current_entity,
      round_number: turn_game.round_number(),
      action_points: turn_game.current_participant().unwrap().action_points,
    });

    // Simulate actions based on entity type and AI
    match current_entity {
      1 => { // Fighter
        println!("  {} attacks Orc Warrior 1 with sword!", entity_name);
        resources.modify_health(11, -25.0);
        turn_game.spend_action_points(2);
        
        event_bus.publish(ResourceChangedEvent {
          entity_id: 11,
          resource_type: "health".to_string(),
          old_value: 85.0,
          new_value: resources.get_resources(11).unwrap().health.current,
        });
      },
      2 => { // Mage
        println!("  {} casts fireball at Orc Shaman!", entity_name);
        resources.modify_health(13, -35.0);
        resources.modify_mana(2, -20.0);
        turn_game.spend_action_points(3);
      },
      3 => { // Cleric  
        println!("  {} heals Fighter!", entity_name);
        resources.modify_health(1, 15.0);
        resources.modify_mana(3, -15.0);
        turn_game.spend_action_points(2);
      },
      11 => { // Orc Warrior 1
        if resources.get_resources(11).unwrap().health.current > 0.0 {
          println!("  {} attacks Fighter with axe!", entity_name);
          resources.modify_health(1, -20.0);
          turn_game.spend_action_points(2);
        }
      },
      12 => { // Orc Warrior 2
        println!("  {} charges at Mage!", entity_name);
        resources.modify_health(2, -18.0);
        turn_game.spend_action_points(3);
      },
      13 => { // Orc Shaman
        if resources.get_resources(13).unwrap().health.current > 0.0 {
          println!("  {} casts dark bolt at Cleric!", entity_name);
          resources.modify_health(3, -15.0);
          resources.modify_mana(13, -10.0);
          turn_game.spend_action_points(2);
        }
      },
      _ => {}
    }

    turn_game.end_turn();
    actions_this_round += 1;
  }

  event_bus.process_events();
  }

  println!("\n📊 End of Round Status:");
  for entity_id in [1, 2, 3, 11, 12, 13] {
  if let Some(res) = resources.get_resources(entity_id) {
    let name = match entity_id {
      1 => "Fighter",
      2 => "Mage",
      3 => "Cleric", 
      11 => "Orc Warrior 1",
      12 => "Orc Warrior 2",
      13 => "Orc Shaman",
      _ => "Unknown"
    };
    
    let status = if res.health.current <= 0.0 { " [DEFEATED]" } else { "" };
    println!("  {}: {:.0}/{:.0} HP, {:.0}/{:.0} MP{}",
      name, res.health.current, res.health.maximum,
      res.mana.current, res.mana.maximum, status);
  }
  }

  // Check for defeated enemies and update quest progress
  let mut orcs_defeated = 0;
  for orc_id in [11, 12, 13] {
  if let Some(res) = resources.get_resources(orc_id) {
    if res.health.current <= 0.0 {
      orcs_defeated += 1;
    }
  }
  }

  if orcs_defeated > 0 {
  quest_manager.update_objective("orc_encounter", "defeat_orcs", orcs_defeated);
  println!("\n📜 Quest Progress: {} orcs defeated", orcs_defeated);
  }

  // Check if battle is won
  let party_alive = [1, 2, 3].iter().any(|&id| {
  resources.get_resources(id).unwrap().health.current > 0.0
  });
  
  let enemies_alive = [11, 12, 13].iter().any(|&id| {
  resources.get_resources(id).unwrap().health.current > 0.0
  });

  if !enemies_alive && party_alive {
  println!("\n🎉 Victory! All orcs defeated!");
  state_machine.process_event(GameStateEvent::VictoryAchieved);
  
  if quest_manager.is_quest_completed("orc_encounter") {
    event_bus.publish(QuestCompletedEvent {
      quest_id: "orc_encounter".to_string(),
      rewards: vec![QuestReward::Experience(200)],
    });
  }
  } else if !party_alive {
  println!("\n💀 Defeat! The party has fallen...");
  state_machine.process_event(GameStateEvent::PlayerDefeated);
  } else {
  println!("\n⚔️ Battle continues! Both sides still fighting.");
  }

  println!("Final game state: {:?}", state_machine.current_state());
  
  event_bus.process_events();

  println!("\n🎯 Integration Summary:");
  println!("This demonstrated how all systems work together:");
  println!("• Turn-based combat managed participant order and actions");
  println!("• Resource system tracked health/mana for all entities");
  println!("• Quest system monitored combat objectives");
  println!("• Event system coordinated between systems");
  println!("• State machine tracked overall game flow");
  println!("• Debug visualization showed tactical positions");
}

examples/beginner_tutorial.rs (line 574)

fn tutorial_step_8_complete_game() {
    println!("🎯 Step 8: Complete Mini-Game");
    println!("-----------------------------");
    println!("Let's put everything together into a working game!");
    
    // Game components
    let mut world = World::new();
    let mut turn_game = TurnBasedGame::new();
    let mut resource_manager = ResourceManager::new();
    let mut event_bus = EventBus::new();
    let mut state_machine = GameStateMachine::new(GameState::Playing);
    
    // Game events
    #[derive(Debug, Clone)]
    struct PlayerMoved {
        from: (i32, i32),
        to: (i32, i32),
    }
    
    #[derive(Debug, Clone)] 
    struct EnemyDefeated {
        enemy_type: String,
        position: (i32, i32),
    }
    
    #[derive(Debug, Clone)]
    struct TreasureFound {
        position: (i32, i32),
        value: u32,
    }
    
    // Events automatically implement Event trait via blanket impl
    
    // Set up event listeners
    event_bus.subscribe(|event: &PlayerMoved| {
        println!("📍 Player moved from ({}, {}) to ({}, {})", 
            event.from.0, event.from.1, event.to.0, event.to.1);
        EventResult::Continue
    });
    
    event_bus.subscribe(|event: &EnemyDefeated| {
        println!("💀 {} defeated at ({}, {})!", 
            event.enemy_type, event.position.0, event.position.1);
        EventResult::Continue
    });
    
    event_bus.subscribe(|event: &TreasureFound| {
        println!("💰 Found treasure worth {} gold at ({}, {})!", 
            event.value, event.position.0, event.position.1);
        EventResult::Continue
    });
    
    // Create game entities
    let player = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(1, 1)),
        Health::new(100),
    ));
    
    let goblin = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(4, 2)),
        Health::new(25),
    ));
    
    let _treasure = world.spawn((
        Position::new(SquareCoord::<FourConnected>::new(6, 3)),
    ));
    
    // Add to game systems
    turn_game.add_participant(player.id() as u32, 100); // Player goes first
    turn_game.add_participant(goblin.id() as u32, 80);  // Goblin second
    
    resource_manager.add_entity(player.id() as u32, 100.0, 30.0);
    resource_manager.add_entity(goblin.id() as u32, 25.0, 0.0);
    
    println!("🎮 Mini Dungeon Explorer Started!");
    println!("Player Goal: Defeat the goblin and find the treasure");
    
    // Game state tracking
    let mut player_gold = 0;
    let mut enemies_defeated = 0;
    
    // Simulate simple gameplay
    println!("\n=== Game Simulation ===");
    
    // Player moves towards goblin
    let player_start = SquareCoord::<FourConnected>::new(1, 1);
    let goblin_pos = SquareCoord::<FourConnected>::new(4, 2);
    
    event_bus.publish(PlayerMoved { 
        from: (player_start.x, player_start.y), 
        to: (goblin_pos.x - 1, goblin_pos.y) 
    });
    
    // Combat occurs
    println!("⚔️ Player attacks goblin!");
    resource_manager.modify_health(goblin.id() as u32, -25.0); // Defeat goblin
    
    event_bus.publish(EnemyDefeated {
        enemy_type: "Goblin".to_string(),
        position: (goblin_pos.x, goblin_pos.y),
    });
    enemies_defeated += 1;
    
    // Player finds treasure
    let treasure_pos = SquareCoord::<FourConnected>::new(6, 3);
    event_bus.publish(TreasureFound {
        position: (treasure_pos.x, treasure_pos.y),
        value: 100,
    });
    player_gold += 100;
    
    // Victory condition
    state_machine.process_event(GameStateEvent::VictoryAchieved);
    println!("🎉 Victory! Game completed!");
    
    event_bus.process_events();
    
    // Final game summary
    println!("\n📋 Game Summary:");
    println!("   Final State: {:?}", state_machine.current_state());
    println!("   Player Gold: {}", player_gold);
    println!("   Enemies Defeated: {}", enemies_defeated);
    
    if state_machine.current_state() == GameState::Victory {
        println!("🏆 Congratulations! You've mastered the basics of tiles_tools!");
    } else {
        println!("⏰ Game ended - but you've learned the fundamentals!");
    }
    
    println!("✅ You've built a complete tile-based game using tiles_tools!\n");
}

pub fn transition_to(&mut self, new_state: GameState)

Forces a transition to a specific state.

pub fn set_state_data(&mut self, key: String, value: String)

Sets data associated with the current state.

Examples found in repository

examples/game_systems_demo.rs (line 245)

fn demonstrate_game_state_machine() {
  let mut state_machine = GameStateMachine::new(GameState::Initialize);
  
  println!("Starting game state machine...");
  println!("Current state: {:?}", state_machine.current_state());

  // Simulate game startup sequence
  let state_transitions = [
  (GameStateEvent::InitComplete, "Game initialized"),
  (GameStateEvent::StartGame, "Starting new game"),
  (GameStateEvent::StartGame, "Loading complete, entering gameplay"),
  (GameStateEvent::EnterCombat, "Combat encounter!"),
  (GameStateEvent::ExitCombat, "Combat resolved"),
  (GameStateEvent::Pause, "Game paused"),
  (GameStateEvent::Resume, "Game resumed"),
  (GameStateEvent::OpenInventory, "Checking inventory"),
  (GameStateEvent::CloseInventory, "Inventory closed"),
  ];

  for (event, description) in state_transitions {
  if state_machine.process_event(event) {
    println!("  {} → {:?} ({})", 
      format!("{:?}", event), 
      state_machine.current_state(), 
      description);
  } else {
    println!("  {} → Failed (invalid transition from {:?})", 
      format!("{:?}", event),
      state_machine.current_state());
  }
  }

  // Demonstrate state data
  state_machine.set_state_data("player_name".to_string(), "Hero".to_string());
  state_machine.set_state_data("level".to_string(), "forest_1".to_string());
  
  println!("\nState data:");
  if let Some(name) = state_machine.get_state_data("player_name") {
  println!("  Player name: {}", name);
  }
  if let Some(level) = state_machine.get_state_data("level") {
  println!("  Current level: {}", level);
  }

  println!("Final state: {:?}", state_machine.current_state());
}

pub fn get_state_data(&self, key: &str) -> Option<&String>

Gets data associated with the current state.

Examples found in repository

examples/game_systems_demo.rs (line 249)

fn demonstrate_game_state_machine() {
  let mut state_machine = GameStateMachine::new(GameState::Initialize);
  
  println!("Starting game state machine...");
  println!("Current state: {:?}", state_machine.current_state());

  // Simulate game startup sequence
  let state_transitions = [
  (GameStateEvent::InitComplete, "Game initialized"),
  (GameStateEvent::StartGame, "Starting new game"),
  (GameStateEvent::StartGame, "Loading complete, entering gameplay"),
  (GameStateEvent::EnterCombat, "Combat encounter!"),
  (GameStateEvent::ExitCombat, "Combat resolved"),
  (GameStateEvent::Pause, "Game paused"),
  (GameStateEvent::Resume, "Game resumed"),
  (GameStateEvent::OpenInventory, "Checking inventory"),
  (GameStateEvent::CloseInventory, "Inventory closed"),
  ];

  for (event, description) in state_transitions {
  if state_machine.process_event(event) {
    println!("  {} → {:?} ({})", 
      format!("{:?}", event), 
      state_machine.current_state(), 
      description);
  } else {
    println!("  {} → Failed (invalid transition from {:?})", 
      format!("{:?}", event),
      state_machine.current_state());
  }
  }

  // Demonstrate state data
  state_machine.set_state_data("player_name".to_string(), "Hero".to_string());
  state_machine.set_state_data("level".to_string(), "forest_1".to_string());
  
  println!("\nState data:");
  if let Some(name) = state_machine.get_state_data("player_name") {
  println!("  Player name: {}", name);
  }
  if let Some(level) = state_machine.get_state_data("level") {
  println!("  Current level: {}", level);
  }

  println!("Final state: {:?}", state_machine.current_state());
}

pub fn can_transition(&self, event: GameStateEvent) -> bool

Checks if the machine can transition on the given event.