// Collect an item
ItemCollector.collectItem(gameState, Item.MORPH_BALL);

// Check if player has an item
boolean hasMorph = RequirementChecker.canMorph(gameState);

// Check if player can place bombs
boolean canBomb = RequirementChecker.canPlaceBombs(gameState);

// Check if player has ice beam
boolean hasIce = RequirementChecker.hasIceBeam(gameState);

// Get current resource level
ResourceLevel energy = state.getResourceLevel(ResourceType.ENERGY);
System.out.println("Energy: " + energy.getRemaining() + "/" + energy.maxCapacity());

// Check if player has enough of a resource
boolean canShoot = ResourceManager.hasResource(state, ResourceType.MISSILE, 5);

// Consume a resource
ResourceManager.consumeResource(state, ResourceType.MISSILE, 5);

// Check if critically low on resources
boolean critical = ResourceManager.isCriticallyLow(state, ResourceType.ENERGY);

// Create a new game state
GameState state = new GameState();

// Create a game state with starting items
GameState state = GameState.standardStart(); // Has morph ball + charge beam

// Create a game state with specific items
GameState state = GameState.withItems(Item.MORPH_BALL, Item.BOMB, Item.ICE_BEAM);

// Clone a state (for simulation)
GameState clonedState = state.clone();

// Get/set energy
state.setEnergy(100);
state.addEnergy(50);
boolean survived = state.takeDamage(30);

// Get inventory
Inventory inv = state.getInventory();
int itemCount = inv.getItemCount();

// Calculate shot damage
int damage = DamageCalculator.calculateShotDamage(gameState);

// Calculate missile damage
int missileDamage = DamageCalculator.calculateMissileDamage(gameState);

// Calculate damage taken from enemy
int baseDamage = 30;
int actualDamage = DamageCalculator.calculateDamageTaken(gameState, baseDamage);

// Check if player would survive
boolean survives = DamageCalculator.wouldSurvive(gameState, 50);

// Get damage reduction percentage
double reduction = DamageCalculator.getDamageReduction(gameState); // 0.0 to 1.0

// Create a randomizer with a seed
BasicRandomizer randomizer = new BasicRandomizer("my-seed-123");

// Or use a random seed
BasicRandomizer randomizer = new BasicRandomizer(null); // Auto-generates seed

// Add locations
Location loc = Location.builder()
    .id("brinstar_01")
    .name("Morph Ball Room")
    .region("Brinstar")
    .requirements(Set.of())
    .build();
randomizer.addLocation(loc);

// Set item pool
randomizer.setItemPool(ItemPool.createStandardPool());
// Or use minimal pool for testing
randomizer.setItemPool(ItemPool.createMinimalPool());

// Run randomization
RandomizationResult result = randomizer.randomize();

// Check result
if (result.isSuccessful()) {
    System.out.println("Randomization successful!");
    System.out.println("Placed " + result.getPlacementCount() + " items");
}

// Print spoiler log
System.out.println(result.generateSpoilerLog());

// Or use formatted spoiler
PrintableSpoiler.printSpoiler(result);

// Simple location (no requirements)
Location loc1 = Location.builder()
    .id("loc_01")
    .name("Item Room 1")
    .region("Brinstar")
    .build();

// Location with requirements
Location loc2 = Location.builder()
    .id("loc_02")
    .name("Behind Bomb Wall")
    .region("Norfair")
    .requirements(Set.of("can_morph", "has_bombs"))
    .build();

// Check location properties
String id = loc2.getId();
String name = loc2.getName();
String region = loc2.getRegion();
boolean hasReqs = loc2.hasRequirements();
Set<String> reqs = loc2.getRequirements();

// Place an item
loc2.placeItem(Item.ICE_BEAM);
Item placed = loc2.getPlacedItem();
boolean isPlaced = loc2.isPlaced();

// Create standard pool
ItemPool pool = ItemPool.createStandardPool();

// Create minimal pool (for testing)
ItemPool pool = ItemPool.createMinimalPool();

// Or create custom pool
ItemPool pool = new ItemPool();
pool.addItem(Item.MORPH_BALL, 1, true);  // progression item
pool.addItem(Item.ENERGY_TANK, 5, false); // filler item

// Check pool contents
int totalItems = pool.getTotalItemCount();
int progressionItems = pool.getProgressionItemCount();
int fillerItems = pool.getFillerItemCount();

// Pick random items
Item progressionItem = pool.pickRandomProgressionItem(random);
Item fillerItem = pool.pickRandomFillerItem(random);
Item anyItem = pool.pickRandomItem(random);

// Check pool status
boolean isEmpty = pool.isEmpty();

// Single requirement
if (RequirementChecker.canMorph(state)) {
    // Player can morph
}

// Multiple requirements (all must be satisfied)
if (RequirementChecker.meetsRequirements(state,
    RequirementChecker.Requirements.canMorph(),
    RequirementChecker.Requirements.canPlaceBombs(),
    RequirementChecker.Requirements.hasIceBeam())) {
    // All requirements met
}

// Custom requirement
Requirement customReq = s -> s.getEnergy() > 50;
if (customReq.isSatisfied(state)) {
    // Custom requirement met
}

// Save current state
GameState originalState = state.clone();

// Try something
state.takeDamage(100);
if (!canSurviveDamage(state, 50)) {
    // Restore original state
    state = originalState;
}

// Collect multiple items at once
List<Item> items = List.of(
    Item.MORPH_BALL,
    Item.BOMB,
    Item.ICE_BEAM
);
ItemCollector.collectAll(state, items);

public class MyDemo {
    public static void main(String[] args) {
        // Create game state
        GameState state = GameState.standardStart();

        // Create randomizer
        BasicRandomizer randomizer = new BasicRandomizer("my-seed");
        randomizer.setItemPool(ItemPool.createMinimalPool());

        // Add locations
        // ... add locations

        // Run randomization
        RandomizationResult result = randomizer.randomize();

        // Print result
        PrintableSpoiler.printSpoiler(result);
    }
}