import com.ubivismedia.aidungeon.AIDungeon;
import com.ubivismedia.aidungeon.dungeon.DungeonManager;

// Get the DungeonManager instance
DungeonManager dungeonManager = AIDungeon.getInstance().getDungeonManager();

// Get all active dungeons
Map<Integer, Dungeon> dungeons = dungeonManager.getActiveDungeons();

// Get a specific dungeon
Dungeon dungeon = dungeonManager.getDungeon(dungeonId);

// Check for a dungeon at a location
Dungeon dungeonAtLocation = dungeonManager.getDungeonAtLocation(location);

// Get dungeon properties
String theme = dungeon.getTheme();
String biomeType = dungeon.getBiomeType();
List<Room> rooms = dungeon.getRooms();
double explorationPercentage = dungeon.getExplorationPercentage();

// Get entrance location
Location entranceLocation = dungeon.getEntranceLocation(world);

// Check if fully explored
boolean isFullyExplored = dungeon.isFullyExplored();

import com.ubivismedia.aidungeon.events.DungeonDiscoveredEvent;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;

public class MyDungeonListener implements Listener {
    
    @EventHandler
    public void onDungeonDiscovered(DungeonDiscoveredEvent event) {
        Dungeon dungeon = event.getDungeon();
        Player discoverer = event.getPlayer();
        
        // Your custom logic here
    }
}

/**
 * Creates a new dungeon at the specified location
 *
 * @param world The world where the dungeon will be created
 * @param x The x-coordinate for the dungeon entrance
 * @param y The y-coordinate for the dungeon entrance
 * @param z The z-coordinate for the dungeon entrance
 * @param biomeType The biome type string for theme selection
 * @return A CompletableFuture containing the created Dungeon instance
 * @throws IllegalArgumentException If the location is invalid
 */
public CompletableFuture<Dungeon> generateDungeon(World world, int x, int y, int z, String biomeType) {
    // Implementation
}

public class DungeonDiscoveredEvent extends Event implements Cancellable {
    private final Dungeon dungeon;
    private final Player player;
    private boolean cancelled;
    
    public Dungeon getDungeon();
    public Player getPlayer();
    
    @Override
    public boolean isCancelled();
    
    @Override
    public void setCancelled(boolean cancel);
}

@EventHandler
public void onDungeonDiscovered(DungeonDiscoveredEvent event) {
    Player player = event.getPlayer();
    Dungeon dungeon = event.getDungeon();
    
    player.sendMessage("You discovered a " + dungeon.getTheme() + " dungeon!");
    
    // Give discovery rewards
    player.giveExp(100);
    
    // You can cancel the event to prevent the discovery message
    // event.setCancelled(true);
}

public class DungeonGeneratedEvent extends Event {
    private final Dungeon dungeon;
    
    public Dungeon getDungeon();
    public World getWorld();
}

@EventHandler
public void onDungeonGenerated(DungeonGeneratedEvent event) {
    Dungeon dungeon = event.getDungeon();
    World world = event.getWorld();
    
    // Log dungeon generation
    getLogger().info("Dungeon #" + dungeon.getId() + " generated at " + 
                     dungeon.getXCoord() + ", " + dungeon.getYCoord() + ", " + dungeon.getZCoord());
    
    // Maybe spawn special entities or add custom features
    Location entranceLocation = dungeon.getEntranceLocation(world);
    world.spawnParticle(Particle.PORTAL, entranceLocation, 100, 1, 1, 1, 0.5);
}

public class DungeonStatusChangedEvent extends Event {
    private final Dungeon dungeon;
    private final Dungeon.Status oldStatus;
    private final Dungeon.Status newStatus;
    
    public Dungeon getDungeon();
    public Dungeon.Status getOldStatus();
    public Dungeon.Status getNewStatus();
}

@EventHandler
public void onDungeonStatusChanged(DungeonStatusChangedEvent event) {
    Dungeon dungeon = event.getDungeon();
    Dungeon.Status oldStatus = event.getOldStatus();
    Dungeon.Status newStatus = event.getNewStatus();
    
    if (oldStatus == Dungeon.Status.ACTIVE && newStatus == Dungeon.Status.EXPLORED) {
        // Dungeon has been fully explored
        getLogger().info("Dungeon #" + dungeon.getId() + " has been fully explored!");
        
        // Maybe give server-wide rewards or announcements
        Bukkit.broadcastMessage("A " + dungeon.getTheme() + " dungeon has been fully explored!");
    }
}

public class DungeonCollapseStartEvent extends Event implements Cancellable {
    private final Dungeon dungeon;
    private boolean cancelled;
    
    public Dungeon getDungeon();
    
    @Override
    public boolean isCancelled();
    
    @Override
    public void setCancelled(boolean cancel);
}

@EventHandler
public void onDungeonCollapseStart(DungeonCollapseStartEvent event) {
    Dungeon dungeon = event.getDungeon();
    
    // Log collapse start
    getLogger().info("Dungeon #" + dungeon.getId() + " is starting to collapse");
    
    // You can cancel the collapse if needed
    // event.setCancelled(true);
    
    // Maybe teleport any players still in the dungeon
    World world = Bukkit.getWorld(dungeon.getWorldName());
    if (world != null) {
        Location surface = dungeon.getEntranceLocation(world).clone();
        surface.setY(world.getHighestBlockYAt(surface));
        
        for (Player player : world.getPlayers()) {
            for (Room room : dungeon.getRooms()) {
                if (room.containsLocation(player.getLocation())) {
                    player.teleport(surface);
                    player.sendMessage("You were teleported out of the collapsing dungeon!");
                    break;
                }
            }
        }
    }
}

public class DungeonCollapseEndEvent extends Event {
    private final int dungeonId;
    private final String worldName;
    private final int x, y, z;
    
    public int getDungeonId();
    public String getWorldName();
    public int getX();
    public int getY();
    public int getZ();
}

@EventHandler
public void onDungeonCollapseEnd(DungeonCollapseEndEvent event) {
    int dungeonId = event.getDungeonId();
    String worldName = event.getWorldName();
    int x = event.getX();
    int y = event.getY();
    int z = event.getZ();
    
    // Log collapse completion
    getLogger().info("Dungeon #" + dungeonId + " has fully collapsed at " + 
                     x + ", " + y + ", " + z + " in world " + worldName);
    
    // Maybe spawn some aftermath effects
    World world = Bukkit.getWorld(worldName);
    if (world != null) {
        Location location = new Location(world, x, y, z);
        world.spawnParticle(Particle.CLOUD, location, 200, 5, 3, 5, 0.1);
    }
}

public class BossSpawnedEvent extends Event {
    private final Dungeon dungeon;
    private final LivingEntity bossEntity;
    
    public Dungeon getDungeon();
    public LivingEntity getBossEntity();
}

@EventHandler
public void onBossSpawned(BossSpawnedEvent event) {
    Dungeon dungeon = event.getDungeon();
    LivingEntity boss = event.getBossEntity();
    
    // Log boss spawn
    getLogger().info("Boss spawned in dungeon #" + dungeon.getId() + ": " + boss.getCustomName());
    
    // Maybe add custom effects or modify the boss
    boss.addPotionEffect(new PotionEffect(PotionEffectType.GLOWING, Integer.MAX_VALUE, 0));
    
    // Announce to nearby players
    World world = boss.getWorld();
    for (Player player : world.getPlayers()) {
        if (player.getLocation().distance(boss.getLocation()) < 50) {
            player.sendMessage("§c§lA powerful enemy has awakened in the dungeon!");
            player.playSound(player.getLocation(), Sound.ENTITY_WITHER_SPAWN, 1.0f, 0.5f);
        }
    }
}

public class BossDefeatedEvent extends Event {
    private final Dungeon dungeon;
    private final Player killer;
    private final LivingEntity boss;
    
    public Dungeon getDungeon();
    public Player getKiller();
    public LivingEntity getBoss();
    public List<Player> getNearbyPlayers();
}

@EventHandler
public void onBossDefeated(BossDefeatedEvent event) {
    Dungeon dungeon = event.getDungeon();
    Player killer = event.getKiller();
    LivingEntity boss = event.getBoss();
    List<Player> nearbyPlayers = event.getNearbyPlayers();
    
    // Log boss defeat
    getLogger().info("Boss in dungeon #" + dungeon.getId() + " was defeated by " + killer.getName());
    
    // Give rewards to the killer
    killer.giveExp(500);
    killer.sendMessage("You have defeated the dungeon boss and earned 500 XP!");
    
    // Give rewards to nearby players who helped
    for (Player player : nearbyPlayers) {
        if (player != killer) {
            player.giveExp(250);
            player.sendMessage("You helped defeat the dungeon boss and earned 250 XP!");
        }
    }
    
    // Maybe spawn special rewards at the boss location
    Location bossLocation = boss.getLocation();
    bossLocation.getWorld().dropItem(bossLocation, new ItemStack(Material.DIAMOND, 5));
    
    // Create special effects
    bossLocation.getWorld().spawnParticle(Particle.EXPLOSION_HUGE, bossLocation, 10, 3, 3, 3, 0.1);
    bossLocation.getWorld().playSound(bossLocation, Sound.ENTITY_WITHER_DEATH, 1.0f, 1.0f);
}

public class RoomDiscoveredEvent extends Event {
    private final Room room;
    private final Dungeon dungeon;
    private final Player player;
    
    public Room getRoom();
    public Dungeon getDungeon();
    public Player getPlayer();
}

@EventHandler
public void onRoomDiscovered(RoomDiscoveredEvent event) {
    Player player = event.getPlayer();
    Room room = event.getRoom();
    Dungeon dungeon = event.getDungeon();
    
    // Different messages/rewards based on room type
    if (room.isBossRoom()) {
        player.sendMessage("§c§lYou have found the boss room! Prepare for battle!");
        player.playSound(player.getLocation(), Sound.BLOCK_BELL_USE, 1.0f, 0.5f);
    } else if (room.isTreasureRoom()) {
        player.sendMessage("§6§lYou have found a treasure room!");
        player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1.0f, 1.5f);
    } else if (room.getRoomType().equals("TRAP")) {
        player.sendMessage("§e§lThis room looks dangerous. Watch your step!");
    }
    
    // Track player's room discoveries
    addRoomToPlayerDiscoveries(player.getUniqueId(), room.getId());
}

public class RoomExploredEvent extends Event {
    private final Room room;
    private final Dungeon dungeon;
    private final Player player;
    
    public Room getRoom();
    public Dungeon getDungeon();
    public Player getPlayer();
}

@EventHandler
public void onRoomExplored(RoomExploredEvent event) {
    Player player = event.getPlayer();
    Room room = event.getRoom();
    Dungeon dungeon = event.getDungeon();
    
    // Give exploration XP based on room type
    int xpAmount = 10; // Base amount
    
    if (room.isBossRoom()) {
        xpAmount = 50;
    } else if (room.isTreasureRoom()) {
        xpAmount = 30;
    } else if (room.getRoomType().equals("TRAP")) {
        xpAmount = 20;
    }
    
    player.giveExp(xpAmount);
    
    // Check if this was the last unexplored room
    if (dungeon.isFullyExplored()) {
        player.sendMessage("§a§lCongratulations! You have fully explored this dungeon!");
        
        // Maybe give a special reward for full exploration
        ItemStack reward = new ItemStack(Material.ENCHANTED_BOOK);
        ItemMeta meta = reward.getItemMeta();
        meta.setDisplayName("§6Tome of Dungeon Mastery");
        reward.setItemMeta(meta);
        player.getInventory().addItem(reward);
    }
}

public class PlayerProgressUpdatedEvent extends Event {
    private final UUID playerUuid;
    private final int dungeonId;
    private final double oldProgress;
    private final double newProgress;
    
    public UUID getPlayerUuid();
    public int getDungeonId();
    public double getOldProgress();
    public double getNewProgress();
    public boolean isCompleted();
}

@EventHandler
public void onPlayerProgressUpdated(PlayerProgressUpdatedEvent event) {
    UUID playerUuid = event.getPlayerUuid();
    int dungeonId = event.getDungeonId();
    double oldProgress = event.getOldProgress();
    double newProgress = event.getNewProgress();
    
    // Check for milestone achievements
    if (oldProgress < 50 && newProgress >= 50) {
        // Player reached 50% exploration
        Player player = Bukkit.getPlayer(playerUuid);
        if (player != null) {
            player.sendMessage("§6You've explored half of the dungeon!");
            player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1.0f, 1.0f);
        }
    }
    
    // Check for dungeon completion
    if (event.isCompleted()) {
        // Track completion in custom stats system
        addCompletedDungeon(playerUuid, dungeonId);
        
        // Maybe update global leaderboard
        updateDungeonCompletionLeaderboard(playerUuid);
    }
}

import com.ubivismedia.aidungeon.events.*;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;

public class DungeonRewardsPlugin extends JavaPlugin implements Listener {
    
    private Map<UUID, Integer> playerPoints = new HashMap<>();
    
    @Override
    public void onEnable() {
        getServer().getPluginManager().registerEvents(this, this);
        
        // Register commands
        getCommand("dungeonpoints").setExecutor(new DungeonPointsCommand(this));
        
        // Load player points from database
        loadPlayerPoints();
    }
    
    @EventHandler
    public void onDungeonDiscovered(DungeonDiscoveredEvent event) {
        // Award points for discovering a dungeon
        addPlayerPoints(event.getPlayer().getUniqueId(), 10);
        event.getPlayer().sendMessage("§6+10 Dungeon Points for discovering a new dungeon!");
    }
    
    @EventHandler
    public void onRoomDiscovered(RoomDiscoveredEvent event) {
        // Award points based on room type
        int points = 0;
        Room room = event.getRoom();
        
        if (room.isBossRoom()) {
            points = 15;
        } else if (room.isTreasureRoom()) {
            points = 10;
        } else if (room.getRoomType().equals("TRAP")) {
            points = 8;
        } else {
            points = 5;
        }
        
        addPlayerPoints(event.getPlayer().getUniqueId(), points);
        event.getPlayer().sendMessage("§6+" + points + " Dungeon Points for discovering a " + 
                                    room.getRoomType().toLowerCase() + " room!");
    }
    
    @EventHandler
    public void onBossDefeated(BossDefeatedEvent event) {
        // Big reward for defeating a boss
        addPlayerPoints(event.getKiller().getUniqueId(), 50);
        event.getKiller().sendMessage("§6+50 Dungeon Points for defeating the dungeon boss!");
        
        // Smaller reward for helpers
        for (Player player : event.getNearbyPlayers()) {
            if (player != event.getKiller()) {
                addPlayerPoints(player.getUniqueId(), 25);
                player.sendMessage("§6+25 Dungeon Points for helping defeat the dungeon boss!");
            }
        }
    }
    
    @EventHandler
    public void onDungeonCollapseEnd(DungeonCollapseEndEvent event) {
        // Maybe some server-wide rewards or events when dungeons collapse
        getServer().broadcastMessage("§7A dungeon has collapsed and returned to nature.");
        
        // Spawn a new dungeon somewhere else to maintain dungeon count
        getServer().dispatchCommand(getServer().getConsoleSender(), "aid scan");
    }
    
    private void addPlayerPoints(UUID playerUuid, int points) {
        playerPoints.put(playerUuid, playerPoints.getOrDefault(playerUuid, 0) + points);
        savePlayerPoints(playerUuid);
        
        // Check for reward thresholds
        checkRewards(playerUuid);
    }
    
    private void checkRewards(UUID playerUuid) {
        int totalPoints = playerPoints.getOrDefault(playerUuid, 0);
        Player player = getServer().getPlayer(playerUuid);
        
        if (player == null) return;
        
        // Define reward tiers
        if (totalPoints >= 1000 && !hasReward(playerUuid, "tier3")) {
            giveReward(player, "tier3");
            player.sendMessage("§a§lYou've reached 1000 Dungeon Points and unlocked the Elite Explorer reward!");
        } else if (totalPoints >= 500 && !hasReward(playerUuid, "tier2")) {
            giveReward(player, "tier2");
            player.sendMessage("§a§lYou've reached 500 Dungeon Points and unlocked the Veteran Explorer reward!");
        } else if (totalPoints >= 100 && !hasReward(playerUuid, "tier1")) {
            giveReward(player, "tier1");
            player.sendMessage("§a§lYou've reached 100 Dungeon Points and unlocked the Novice Explorer reward!");
        }
    }
    
    // Database methods would be implemented here
    private void loadPlayerPoints() { /* Implementation */ }
    private void savePlayerPoints(UUID playerUuid) { /* Implementation */ }
    private boolean hasReward(UUID playerUuid, String tier) { /* Implementation */ }
    private void giveReward(Player player, String tier) { /* Implementation */ }
    
    // Getter for other classes
    public int getPlayerPoints(UUID playerUuid) {
        return playerPoints.getOrDefault(playerUuid, 0);
    }
}

import com.ubivismedia.aidungeon.AIDungeon;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.java.JavaPlugin;

public class YourPlugin extends JavaPlugin {
    private AIDungeon aidungeon;
    private boolean aidungeonHooked = false;
    
    @Override
    public void onEnable() {
        // Get the AIDungeon plugin instance
        Plugin plugin = getServer().getPluginManager().getPlugin("AIDungeon");
        
        if (plugin instanceof AIDungeon) {
            aidungeon = (AIDungeon) plugin;
            aidungeonHooked = true;
            getLogger().info("Successfully hooked into AIDungeon!");
        } else {
            getLogger().warning("AIDungeon not found or not enabled!");
            if (plugin == null) {
                getLogger().warning("Make sure AIDungeon is installed!");
            } else {
                getLogger().warning("Incompatible version of AIDungeon detected!");
            }
        }
        
        // Register event listeners, commands, etc.
        if (aidungeonHooked) {
            getServer().getPluginManager().registerEvents(new YourDungeonListener(this), this);
            getCommand("yourdungeoncommand").setExecutor(new YourDungeonCommand(this));
        }
    }
    
    public AIDungeon getAIDungeon() {
        return aidungeon;
    }
    
    public boolean isAIDungeonHooked() {
        return aidungeonHooked;
    }
}

import com.ubivismedia.aidungeon.events.BossDefeatedEvent;
import com.ubivismedia.aidungeon.events.DungeonDiscoveredEvent;
import com.ubivismedia.aidungeon.events.RoomExploredEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;

public class CustomRewardsListener implements Listener {
    private final YourPlugin plugin;
    
    public CustomRewardsListener(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    @EventHandler
    public void onDungeonDiscovered(DungeonDiscoveredEvent event) {
        Player player = event.getPlayer();
        
        // Give custom currency
        plugin.getEconomyManager().addCurrency(player, "dungeon_tokens", 5);
        player.sendMessage("§a+5 Dungeon Tokens for discovering a new dungeon!");
    }
    
    @EventHandler
    public void onRoomExplored(RoomExploredEvent event) {
        Player player = event.getPlayer();
        
        // Give rewards based on room type
        if (event.getRoom().isBossRoom()) {
            plugin.getEconomyManager().addCurrency(player, "dungeon_tokens", 10);
            player.sendMessage("§a+10 Dungeon Tokens for exploring the boss room!");
        } else if (event.getRoom().isTreasureRoom()) {
            plugin.getEconomyManager().addCurrency(player, "dungeon_tokens", 7);
            player.sendMessage("§a+7 Dungeon Tokens for exploring a treasure room!");
        } else {
            plugin.getEconomyManager().addCurrency(player, "dungeon_tokens", 2);
            player.sendMessage("§a+2 Dungeon Tokens for exploring a room!");
        }
    }
    
    @EventHandler
    public void onBossDefeated(BossDefeatedEvent event) {
        Player player = event.getKiller();
        
        // Big reward for boss defeat
        plugin.getEconomyManager().addCurrency(player, "dungeon_tokens", 25);
        player.sendMessage("§a+25 Dungeon Tokens for defeating the dungeon boss!");
        
        // Add to player stats
        plugin.getStatsManager().incrementStat(player, "bosses_defeated", 1);
    }
}

import com.ubivismedia.aidungeon.AIDungeon;
import com.ubivismedia.aidungeon.dungeon.DungeonManager;
import com.ubivismedia.aidungeon.model.Dungeon;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

public class DungeonStatsCommand implements CommandExecutor {
    private final YourPlugin plugin;
    
    public DungeonStatsCommand(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!(sender instanceof Player)) {
            sender.sendMessage("This command can only be used by players.");
            return true;
        }
        
        Player player = (Player) sender;
        
        if (!plugin.isAIDungeonHooked()) {
            player.sendMessage("§cAIDungeon is not currently available.");
            return true;
        }
        
        AIDungeon aidungeon = plugin.getAIDungeon();
        DungeonManager dungeonManager = aidungeon.getDungeonManager();
        
        // Show the player their dungeon exploration statistics
        int totalDungeons = countPlayerDungeons(player);
        int completedDungeons = countPlayerCompletedDungeons(player);
        int defeatedBosses = plugin.getStatsManager().getStat(player, "bosses_defeated");
        
        player.sendMessage("§6=== Your Dungeon Statistics ===");
        player.sendMessage("§eDungeons Explored: §f" + totalDungeons);
        player.sendMessage("§eDungeons Completed: §f" + completedDungeons);
        player.sendMessage("§eBosses Defeated: §f" + defeatedBosses);
        player.sendMessage("§eDungeon Tokens: §f" + plugin.getEconomyManager().getCurrency(player, "dungeon_tokens"));
        
        // Show currently active dungeon if player is in one
        Dungeon currentDungeon = dungeonManager.getDungeonAtLocation(player.getLocation());
        if (currentDungeon != null) {
            player.sendMessage("§eCurrently in: §f" + formatDungeonName(currentDungeon.getTheme()));
            player.sendMessage("§eExploration: §f" + String.format("%.1f%%", currentDungeon.getExplorationPercentage()));
            player.sendMessage("§eBoss Defeated: §f" + (currentDungeon.isBossDefeated() ? "Yes" : "No"));
        }
        
        return true;
    }
    
    private String formatDungeonName(String theme) {
        // Convert theme_name to Title Case
        String[] words = theme.split("_");
        StringBuilder result = new StringBuilder();
        
        for (String word : words) {
            if (word.length() > 0) {
                result.append(Character.toUpperCase(word.charAt(0)))
                      .append(word.substring(1))
                      .append(" ");
            }
        }
        
        return result.toString().trim();
    }
    
    private int countPlayerDungeons(Player player) {
        // Implementation to count dungeons from your plugin's database
        return plugin.getStatsManager().getPlayerDungeonCount(player);
    }
    
    private int countPlayerCompletedDungeons(Player player) {
        // Implementation to count completed dungeons from your plugin's database
        return plugin.getStatsManager().getPlayerCompletedDungeonCount(player);
    }
}

import com.ubivismedia.aidungeon.events.DungeonGeneratedEvent;
import com.ubivismedia.aidungeon.events.RoomDiscoveredEvent;
import com.ubivismedia.aidungeon.model.Dungeon;
import com.ubivismedia.aidungeon.model.Room;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.EntityType;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.scheduler.BukkitRunnable;

public class DungeonEnhancementsListener implements Listener {
    private final YourPlugin plugin;
    
    public DungeonEnhancementsListener(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    @EventHandler
    public void onDungeonGenerated(DungeonGeneratedEvent event) {
        Dungeon dungeon = event.getDungeon();
        World world = event.getWorld();
        
        // Add custom particle effects at the dungeon entrance
        Location entranceLocation = dungeon.getEntranceLocation(world);
        
        // Schedule repeating particle effects
        new BukkitRunnable() {
            @Override
            public void run() {
                // Check if dungeon still exists and is active
                if (plugin.getAIDungeon().getDungeonManager().getDungeon(dungeon.getId()) == null) {
                    this.cancel();
                    return;
                }
                
                // Spawn particles
                world.spawnParticle(org.bukkit.Particle.DRAGON_BREATH, 
                        entranceLocation.clone().add(0, 1.5, 0), 
                        20, 0.5, 0.5, 0.5, 0.02);
            }
        }.runTaskTimer(plugin, 20L, 40L); // Run every 2 seconds
        
        // Add custom entities to the boss room
        Room bossRoom = dungeon.getBossRoom();
        if (bossRoom != null) {
            Location bossRoomCenter = bossRoom.getCenterLocation(world);
            
            // Spawn minions in the boss room
            for (int i = 0; i < 4; i++) {
                double offsetX = (Math.random() - 0.5) * (bossRoom.getWidth() * 0.8);
                double offsetZ = (Math.random() - 0.5) * (bossRoom.getLength() * 0.8);
                
                Location spawnLoc = bossRoomCenter.clone().add(offsetX, 0, offsetZ);
                world.spawnEntity(spawnLoc, EntityType.SKELETON);
            }
        }
    }
    
    @EventHandler
    public void onRoomDiscovered(RoomDiscoveredEvent event) {
        Room room = event.getRoom();
        Player player = event.getPlayer();
        World world = player.getWorld();
        
        // Add special effects when a player discovers a room
        Location roomCenter = room.getCenterLocation(world);
        
        // Play sound effect
        world.playSound(roomCenter, org.bukkit.Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1.0f, 0.5f);
        
        // Spawn ambient particles
        world.spawnParticle(org.bukkit.Particle.ENCHANTMENT_TABLE, 
                roomCenter, 50, room.getWidth()/2.0, room.getHeight()/2.0, room.getLength()/2.0, 0.1);
    }
}

import com.ubivismedia.aidungeon.events.BossDefeatedEvent;
import com.ubivismedia.aidungeon.events.DungeonDiscoveredEvent;
import net.milkbowl.vault.economy.Economy;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.plugin.RegisteredServiceProvider;

public class VaultIntegrationListener implements Listener {
    private final YourPlugin plugin;
    private Economy economy;
    
    public VaultIntegrationListener(YourPlugin plugin) {
        this.plugin = plugin;
        setupEconomy();
    }
    
    private boolean setupEconomy() {
        if (plugin.getServer().getPluginManager().getPlugin("Vault") == null) {
            return false;
        }
        
        RegisteredServiceProvider<Economy> rsp = plugin.getServer().getServicesManager().getRegistration(Economy.class);
        if (rsp == null) {
            return false;
        }
        
        economy = rsp.getProvider();
        return economy != null;
    }
    
    @EventHandler
    public void onDungeonDiscovered(DungeonDiscoveredEvent event) {
        if (economy == null) return;
        
        Player player = event.getPlayer();
        
        // Give money reward for discovering a dungeon
        double reward = 50.0;
        economy.depositPlayer(player, reward);
        player.sendMessage("§a+" + reward + " " + economy.currencyNamePlural() + " for discovering a dungeon!");
    }
    
    @EventHandler
    public void onBossDefeated(BossDefeatedEvent event) {
        if (economy == null) return;
        
        Player player = event.getKiller();
        
        // Give money reward for defeating a boss
        double reward = 250.0;
        economy.depositPlayer(player, reward);
        player.sendMessage("§a+" + reward + " " + economy.currencyNamePlural() + " for defeating a dungeon boss!");
        
        // Give smaller rewards to helpers
        double helperReward = 100.0;
        for (Player helper : event.getNearbyPlayers()) {
            if (helper != player) {
                economy.depositPlayer(helper, helperReward);
                helper.sendMessage("§a+" + helperReward + " " + economy.currencyNamePlural() + " for helping defeat a dungeon boss!");
            }
        }
    }
}

import com.ubivismedia.aidungeon.AIDungeon;
import com.ubivismedia.aidungeon.dungeon.DungeonManager;
import com.ubivismedia.aidungeon.model.Dungeon;
import com.ubivismedia.aidungeon.model.Room;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DungeonDataAnalyzer {
    private final YourPlugin plugin;
    
    public DungeonDataAnalyzer(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    public Map<String, Integer> getThemeDistribution() {
        if (!plugin.isAIDungeonHooked()) {
            return new HashMap<>();
        }
        
        DungeonManager dungeonManager = plugin.getAIDungeon().getDungeonManager();
        Map<Integer, Dungeon> dungeons = dungeonManager.getActiveDungeons();
        
        // Count dungeons by theme
        Map<String, Integer> themeCount = new HashMap<>();
        
        for (Dungeon dungeon : dungeons.values()) {
            String theme = dungeon.getTheme();
            themeCount.put(theme, themeCount.getOrDefault(theme, 0) + 1);
        }
        
        return themeCount;
    }
    
    public Map<String, Integer> getRoomTypeDistribution() {
        if (!plugin.isAIDungeonHooked()) {
            return new HashMap<>();
        }
        
        DungeonManager dungeonManager = plugin.getAIDungeon().getDungeonManager();
        Map<Integer, Dungeon> dungeons = dungeonManager.getActiveDungeons();
        
        // Count rooms by type
        Map<String, Integer> roomTypeCount = new HashMap<>();
        
        for (Dungeon dungeon : dungeons.values()) {
            for (Room room : dungeon.getRooms()) {
                String roomType = room.getRoomType();
                roomTypeCount.put(roomType, roomTypeCount.getOrDefault(roomType, 0) + 1);
            }
        }
        
        return roomTypeCount;
    }
    
    public double getAverageExplorationPercentage() {
        if (!plugin.isAIDungeonHooked()) {
            return 0.0;
        }
        
        DungeonManager dungeonManager = plugin.getAIDungeon().getDungeonManager();
        Map<Integer, Dungeon> dungeons = dungeonManager.getActiveDungeons();
        
        if (dungeons.isEmpty()) {
            return 0.0;
        }
        
        // Calculate average exploration percentage
        double totalPercentage = 0.0;
        
        for (Dungeon dungeon : dungeons.values()) {
            totalPercentage += dungeon.getExplorationPercentage();
        }
        
        return totalPercentage / dungeons.size();
    }
    
    public List<Dungeon> getNewestDungeons(int count) {
        if (!plugin.isAIDungeonHooked()) {
            return List.of();
        }
        
        DungeonManager dungeonManager = plugin.getAIDungeon().getDungeonManager();
        Map<Integer, Dungeon> dungeons = dungeonManager.getActiveDungeons();
        
        // Sort dungeons by creation date (newest first) and take the first 'count'
        return dungeons.values().stream()
                .sorted((d1, d2) -> d2.getCreatedAt().compareTo(d1.getCreatedAt()))
                .limit(count)
                .toList();
    }
}

import com.ubivismedia.aidungeon.AIDungeon;
import com.ubivismedia.aidungeon.database.DatabaseManager;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class DungeonDatabaseQueries {
    private final YourPlugin plugin;
    
    public DungeonDatabaseQueries(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    public List<Integer> getPlayerExploredDungeons(UUID playerUuid) {
        if (!plugin.isAIDungeonHooked()) {
            return List.of();
        }
        
        List<Integer> exploredDungeons = new ArrayList<>();
        DatabaseManager dbManager = plugin.getAIDungeon().getDatabaseManager();
        
        try (Connection conn = dbManager.getConnection();
             PreparedStatement stmt = conn.prepareStatement(
                     "SELECT dungeon_id FROM player_progress WHERE player_uuid = ? AND exploration_percent > 0")) {
            
            stmt.setString(1, playerUuid.toString());
            ResultSet rs = stmt.executeQuery();
            
            while (rs.next()) {
                exploredDungeons.add(rs.getInt("dungeon_id"));
            }
            
        } catch (SQLException e) {
            plugin.getLogger().severe("Error querying player explored dungeons: " + e.getMessage());
            e.printStackTrace();
        }
        
        return exploredDungeons;
    }
    
    public Map<String, Integer> getTopDungeonExplorers(int limit) {
        if (!plugin.isAIDungeonHooked()) {
            return Map.of();
        }
        
        Map<String, Integer> topExplorers = new LinkedHashMap<>();
        DatabaseManager dbManager = plugin.getAIDungeon().getDatabaseManager();
        
        try (Connection conn = dbManager.getConnection();
             PreparedStatement stmt = conn.prepareStatement(
                     "SELECT player_uuid, COUNT(*) as dungeon_count FROM player_progress " +
                     "WHERE exploration_percent = 100 " +
                     "GROUP BY player_uuid ORDER BY dungeon_count DESC LIMIT ?")) {
            
            stmt.setInt(1, limit);
            ResultSet rs = stmt.executeQuery();
            
            while (rs.next()) {
                String playerUuid = rs.getString("player_uuid");
                int dungeonCount = rs.getInt("dungeon_count");
                
                // Convert UUID to player name if possible
                String playerName = Bukkit.getOfflinePlayer(UUID.fromString(playerUuid)).getName();
                if (playerName == null) {
                    playerName = playerUuid;
                }
                
                topExplorers.put(playerName, dungeonCount);
            }
            
        } catch (SQLException e) {
            plugin.getLogger().severe("Error querying top dungeon explorers: " + e.getMessage());
            e.printStackTrace();
        }
        
        return topExplorers;
    }
}

import com.ubivismedia.aidungeon.AIDungeon;
import com.ubivismedia.aidungeon.dungeon.DungeonManager;
import com.ubivismedia.aidungeon.model.Dungeon;
import me.clip.placeholderapi.expansion.PlaceholderExpansion;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;

public class AIDungeonPlaceholders extends PlaceholderExpansion {
    private final YourPlugin plugin;
    
    public AIDungeonPlaceholders(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    @Override
    public String getIdentifier() {
        return "yourdungeon";
    }
    
    @Override
    public String getAuthor() {
        return plugin.getDescription().getAuthors().get(0);
    }
    
    @Override
    public String getVersion() {
        return plugin.getDescription().getVersion();
    }
    
    @Override
    public boolean persist() {
        return true;
    }
    
    @Override
    public String onRequest(OfflinePlayer offlinePlayer, String identifier) {
        if (offlinePlayer == null || !offlinePlayer.isOnline() || !plugin.isAIDungeonHooked()) {
            return null;
        }
        
        Player player = offlinePlayer.getPlayer();
        AIDungeon aidungeon = plugin.getAIDungeon();
        DungeonManager dungeonManager = aidungeon.getDungeonManager();
        
        // Current dungeon placeholders
        if (identifier.equals("current_dungeon")) {
            Dungeon dungeon = dungeonManager.getDungeonAtLocation(player.getLocation());
            return dungeon != null ? formatDungeonName(dungeon.getTheme()) : "None";
        }
        
        if (identifier.equals("current_dungeon_exploration")) {
            Dungeon dungeon = dungeonManager.getDungeonAtLocation(player.getLocation());
            return dungeon != null ? String.format("%.1f%%", dungeon.getExplorationPercentage()) : "0.0%";
        }
        
        if (identifier.equals("current_dungeon_boss_defeated")) {
            Dungeon dungeon = dungeonManager.getDungeonAtLocation(player.getLocation());
            return dungeon != null ? (dungeon.isBossDefeated() ? "Yes" : "No") : "N/A";
        }
        
        // Player stats placeholders
        if (identifier.equals("total_dungeons")) {
            return String.valueOf(plugin.getDungeonDataAnalyzer().getPlayerDungeonCount(player.getUniqueId()));
        }
        
        if (identifier.equals("completed_dungeons")) {
            return String.valueOf(plugin.getDungeonDataAnalyzer().getPlayerCompletedDungeonCount(player.getUniqueId()));
        }
        
        if (identifier.equals("boss_kills")) {
            return String.valueOf(plugin.getStatsManager().getStat(player, "bosses_defeated"));
        }
        
        if (identifier.equals("dungeon_tokens")) {
            return String.valueOf(plugin.getEconomyManager().getCurrency(player, "dungeon_tokens"));
        }
        
        return null;
    }
    
    private String formatDungeonName(String theme) {
        String[] words = theme.split("_");
        StringBuilder result = new StringBuilder();
        
        for (String word : words) {
            if (word.length() > 0) {
                result.append(Character.toUpperCase(word.charAt(0)))
                      .append(word.substring(1))
                      .append(" ");
            }
        }
        
        return result.toString().trim();
    }
}

import com.ubivismedia.aidungeon.events.BossDefeatedEvent;
import com.ubivismedia.aidungeon.events.DungeonDiscoveredEvent;
import com.ubivismedia.aidungeon.model.Dungeon;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;

public class DungeonProgressionSystem implements Listener {
    private final YourPlugin plugin;
    
    // Define progression tiers
    private final String[] PROGRESSION_TIERS = {
        "Novice Explorer",
        "Dungeon Delver",
        "Tomb Raider",
        "Dungeon Master",
        "Legendary Conqueror"
    };
    
    // Dungeon completions required for each tier
    private final int[] TIER_REQUIREMENTS = {1, 5, 15, 30, 50};
    
    // Special abilities unlocked at each tier
    private final String[] TIER_ABILITIES = {
        "dungeonheal",      // Regenerate health in dungeons
        "dungeoncompass",   // Compass pointing to nearest dungeon
        "dungeonrescue",    // Teleport to dungeon entrance when health is low
        "dungeonloot",      // Improved loot chances
        "dungeonblink"      // Short-range teleport within dungeons
    };
    
    public DungeonProgressionSystem(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    @EventHandler
    public void onBossDefeated(BossDefeatedEvent event) {
        Player player = event.getKiller();
        
        // Update player's completed dungeon count
        int completedDungeons = plugin.getDungeonDataAnalyzer().getPlayerCompletedDungeonCount(player.getUniqueId());
        completedDungeons++;
        
        // Save the updated count
        plugin.getDungeonDataAnalyzer().setPlayerCompletedDungeonCount(player.getUniqueId(), completedDungeons);
        
        // Check if player leveled up in the progression system
        int oldTier = getCurrentTier(completedDungeons - 1);
        int newTier = getCurrentTier(completedDungeons);
        
        if (newTier > oldTier) {
            // Player has reached a new tier!
            String tierName = PROGRESSION_TIERS[newTier];
            String ability = TIER_ABILITIES[newTier];
            
            player.sendMessage("§a§l=============================");
            player.sendMessage("§6§lDUNGEON TIER REACHED: §e" + tierName);
            player.sendMessage("§6§lNew Ability Unlocked: §e" + formatAbilityName(ability));
            player.sendMessage("§a§l=============================");
            
            // Give player the new ability
            grantAbility(player, ability);
        }
    }
    
    private int getCurrentTier(int completedDungeons) {
        for (int i = TIER_REQUIREMENTS.length - 1; i >= 0; i--) {
            if (completedDungeons >= TIER_REQUIREMENTS[i]) {
                return i;
            }
        }
        return -1; // No tier yet
    }
    
    private String formatAbilityName(String ability) {
        // Remove "dungeon" prefix and capitalize
        String name = ability.replace("dungeon", "");
        return Character.toUpperCase(name.charAt(0)) + name.substring(1);
    }
    
    private void grantAbility(Player player, String ability) {
        // Implementation to give player the ability
        plugin.getAbilityManager().unlockAbility(player.getUniqueId(), ability);
    }
    
    // Command to use abilities would be implemented separately
}

public class SafeDungeonAccess {
    private final YourPlugin plugin;
    
    public SafeDungeonAccess(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    public Optional<Dungeon> getCurrentDungeon(Player player) {
        try {
            if (!plugin.isAIDungeonHooked()) {
                return Optional.empty();
            }
            
            DungeonManager dungeonManager = plugin.getAIDungeon().getDungeonManager();
            Dungeon dungeon = dungeonManager.getDungeonAtLocation(player.getLocation());
            
            return Optional.ofNullable(dungeon);
        } catch (Exception e) {
            plugin.getLogger().warning("Error getting current dungeon: " + e.getMessage());
            return Optional.empty();
        }
    }
    
    public void safelyTrackExploration(Player player) {
        try {
            if (!plugin.isAIDungeonHooked()) {
                return;
            }
            
            DungeonManager dungeonManager = plugin.getAIDungeon().getDungeonManager();
            Dungeon dungeon = dungeonManager.getDungeonAtLocation(player.getLocation());
            
            if (dungeon != null) {
                Room room = dungeonManager.getRoomAtLocation(player.getLocation());
                if (room != null) {
                    dungeonManager.trackPlayerExploration(player, dungeon, room);
                }
            }
        } catch (Exception e) {
            plugin.getLogger().warning("Error tracking exploration: " + e.getMessage());
        }
    }
}

import com.ubivismedia.aidungeon.AIDungeon;
import org.bukkit.plugin.Plugin;

public class VersionCompatibilityHandler {
    private final YourPlugin plugin;
    private String aidungeonVersion;
    private boolean isCompatible = false;
    
    public VersionCompatibilityHandler(YourPlugin plugin) {
        this.plugin = plugin;
        checkCompatibility();
    }
    
    private void checkCompatibility() {
        Plugin aidungeonPlugin = plugin.getServer().getPluginManager().getPlugin("AIDungeon");
        
        if (aidungeonPlugin == null || !(aidungeonPlugin instanceof AIDungeon)) {
            plugin.getLogger().warning("AIDungeon plugin not found or is not the expected type.");
            return;
        }
        
        // Get version string
        aidungeonVersion = aidungeonPlugin.getDescription().getVersion();
        
        // Parse version (assuming format like "0.2.0")
        String[] versionParts = aidungeonVersion.split("\\.");
        if (versionParts.length < 2) {
            plugin.getLogger().warning("Unable to parse AIDungeon version: " + aidungeonVersion);
            return;
        }
        
        try {
            int major = Integer.parseInt(versionParts[0]);
            int minor = Integer.parseInt(versionParts[1]);
            
            // Check if version is compatible (e.g., 0.2.0 or newer)
            if (major > 0 || (major == 0 && minor >= 2)) {
                isCompatible = true;
                plugin.getLogger().info("Compatible AIDungeon version detected: " + aidungeonVersion);
            } else {
                plugin.getLogger().warning("Incompatible AIDungeon version: " + aidungeonVersion + 
                                         ". Requires 0.2.0 or newer.");
            }
        } catch (NumberFormatException e) {
            plugin.getLogger().warning("Error parsing AIDungeon version: " + e.getMessage());
        }
    }
    
    public boolean isCompatible() {
        return isCompatible;
    }
    
    public String getVersion() {
        return aidungeonVersion;
    }
}

## Performance Considerations

When integrating with AIDungeon, keep these performance factors in mind:

### Efficient Event Handling

```java
import com.ubivismedia.aidungeon.events.DungeonDiscoveredEvent;
import com.ubivismedia.aidungeon.events.RoomDiscoveredEvent;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;

public class OptimizedEventHandler implements Listener {
    private final YourPlugin plugin;
    private long lastRoomProcessTime = 0;
    private static final long ROOM_PROCESS_COOLDOWN = 1000; // 1 second cooldown
    
    public OptimizedEventHandler(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
    public void onDungeonDiscovered(DungeonDiscoveredEvent event) {
        // Use MONITOR priority to run after AIDungeon's own handlers
        
        // Handle dungeon discovery (this event is infrequent, so no cooldown needed)
        processDiscovery(event);
    }
    
    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
    public void onRoomDiscovered(RoomDiscoveredEvent event) {
        // Add rate limiting for frequent events
        long currentTime = System.currentTimeMillis();
        if (currentTime - lastRoomProcessTime < ROOM_PROCESS_COOLDOWN) {
            return; // Skip if processed recently
        }
        
        // Process room discovery
        processRoomDiscovery(event);
        lastRoomProcessTime = currentTime;
    }
    
    // Use async processing for database operations
    private void processDiscovery(DungeonDiscoveredEvent event) {
        // Quick synchronous operations
        event.getPlayer().sendMessage("Dungeon discovered!");
        
        // Move heavy processing to async task
        plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> {
            // Database operations
            plugin.getPlayerDatabase().recordDungeonDiscovery(
                event.getPlayer().getUniqueId(), 
                event.getDungeon().getId()
            );
            
            // Any other heavy processing
            processStatistics(event.getDungeon());
        });
    }
    
    private void processRoomDiscovery(RoomDiscoveredEvent event) {
        // Implementation here
    }
    
    private void processStatistics(Dungeon dungeon) {
        // Heavy statistical processing
    }
}

import com.ubivismedia.aidungeon.model.Dungeon;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

public class DungeonDataCache {
    private final Map<Integer, Dungeon> dungeonCache = new HashMap<>();
    private final Map<UUID, Map<Integer, Double>> playerProgressCache = new HashMap<>();
    private final Map<Integer, Long> cacheTimes = new HashMap<>();
    
    private static final long CACHE_EXPIRY = TimeUnit.MINUTES.toMillis(5); // 5 minute cache
    
    // Cache a dungeon
    public void cacheDungeon(Dungeon dungeon) {
        dungeonCache.put(dungeon.getId(), dungeon);
        cacheTimes.put(dungeon.getId(), System.currentTimeMillis());
    }
    
    // Get a dungeon from cache
    public Dungeon getDungeon(int dungeonId) {
        // Check if cache is valid
        Long cacheTime = cacheTimes.get(dungeonId);
        if (cacheTime == null || System.currentTimeMillis() - cacheTime > CACHE_EXPIRY) {
            dungeonCache.remove(dungeonId);
            cacheTimes.remove(dungeonId);
            return null;
        }
        
        return dungeonCache.get(dungeonId);
    }
    
    // Cache player progress
    public void cachePlayerProgress(UUID playerUuid, int dungeonId, double progress) {
        playerProgressCache.computeIfAbsent(playerUuid, k -> new HashMap<>())
            .put(dungeonId, progress);
    }
    
    // Get player progress
    public Double getPlayerProgress(UUID playerUuid, int dungeonId) {
        Map<Integer, Double> progressMap = playerProgressCache.get(playerUuid);
        return progressMap != null ? progressMap.get(dungeonId) : null;
    }
    
    // Clear expired cache entries
    public void cleanupCache() {
        long currentTime = System.currentTimeMillis();
        
        // Remove expired dungeon cache entries
        cacheTimes.entrySet().removeIf(entry -> 
            currentTime - entry.getValue() > CACHE_EXPIRY
        );
        
        dungeonCache.keySet().removeIf(id -> !cacheTimes.containsKey(id));
    }
}

import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.scheduler.BukkitRunnable;

public class DungeonPlayerTracker implements Listener {
    private final YourPlugin plugin;
    private final Map<UUID, Location> lastProcessedLocations = new HashMap<>();
    
    public DungeonPlayerTracker(YourPlugin plugin) {
        this.plugin = plugin;
        
        // Schedule periodic cleanup of location cache
        new BukkitRunnable() {
            @Override
            public void run() {
                // Remove entries for offline players
                for (Player player : plugin.getServer().getOnlinePlayers()) {
                    lastProcessedLocations.remove(player.getUniqueId());
                }
            }
        }.runTaskTimer(plugin, 1200L, 1200L); // Run every minute
    }
    
    @EventHandler(ignoreCancelled = true)
    public void onPlayerMove(PlayerMoveEvent event) {
        // Skip if player only rotated but didn't change position
        if (event.getFrom().getBlockX() == event.getTo().getBlockX() &&
            event.getFrom().getBlockY() == event.getTo().getBlockY() &&
            event.getFrom().getBlockZ() == event.getTo().getBlockZ()) {
            return;
        }
        
        Player player = event.getPlayer();
        Location currentLocation = player.getLocation();
        
        // Only process every 10 blocks moved to reduce overhead
        Location lastLocation = lastProcessedLocations.get(player.getUniqueId());
        if (lastLocation != null && lastLocation.distance(currentLocation) < 10) {
            return;
        }
        
        // Update last processed location
        lastProcessedLocations.put(player.getUniqueId(), currentLocation.clone());
        
        // Schedule async task for non-critical operations
        plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> {
            // Do database lookups or other heavy operations
            int nearbyDungeons = countNearbyDungeons(currentLocation);
            
            // Schedule sync task for any operations that need to be sync
            if (nearbyDungeons > 0) {
                plugin.getServer().getScheduler().runTask(plugin, () -> {
                    // Update player's HUD or other sync operations
                    updatePlayerDungeonHUD(player, nearbyDungeons);
                });
            }
        });
    }
    
    private int countNearbyDungeons(Location location) {
        // Implementation to count nearby dungeons
        return 0;
    }
    
    private void updatePlayerDungeonHUD(Player player, int dungeonCount) {
        // Implementation to update player's HUD
    }
}

@Override
public void onEnable() {
    // Check if AIDungeon is loaded
    if (getServer().getPluginManager().getPlugin("AIDungeon") == null) {
        getLogger().severe("AIDungeon plugin not found! Disabling plugin.");
        getServer().getPluginManager().disablePlugin(this);
        return;
    }
    
    // Wait for AIDungeon to be fully enabled
    if (!getServer().getPluginManager().isPluginEnabled("AIDungeon")) {
        getLogger().info("Waiting for AIDungeon to be fully enabled...");
        getServer().getPluginManager().registerEvents(new PluginEnableListener(), this);
    } else {
        initializePlugin();
    }
}

private class PluginEnableListener implements Listener {
    @EventHandler
    public void onPluginEnable(PluginEnableEvent event) {
        if (event.getPlugin().getName().equals("AIDungeon")) {
            getLogger().info("AIDungeon enabled, initializing plugin now.");
            initializePlugin();
            // Unregister this listener
            HandlerList.unregisterAll(this);
        }
    }
}

private void initializePlugin() {
    // Initialize your plugin's features
}

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.concurrent.CompletableFuture;

public class SafeDatabaseOperations {
    private final YourPlugin plugin;
    
    public SafeDatabaseOperations(YourPlugin plugin) {
        this.plugin = plugin;
    }
    
    public CompletableFuture<List<Integer>> getCompletedDungeons(UUID playerUuid) {
        CompletableFuture<List<Integer>> future = new CompletableFuture<>();
        
        // Run database operation asynchronously
        plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> {
            List<Integer> dungeonIds = new ArrayList<>();
            
            try {
                Connection conn = plugin.getAIDungeon().getDatabaseManager().getConnection();
                
                // Important: Use try-with-resources to ensure connection is returned to pool
                try (conn;
                     PreparedStatement stmt = conn.prepareStatement(
                         "SELECT dungeon_id FROM player_progress " +
                         "WHERE player_uuid = ? AND exploration_percent = 100")) {
                    
                    stmt.setString(1, playerUuid.toString());
                    ResultSet rs = stmt.executeQuery();
                    
                    while (rs.next()) {
                        dungeonIds.add(rs.getInt("dungeon_id"));
                    }
                }
                
                future.complete(dungeonIds);
            } catch (SQLException e) {
                plugin.getLogger().severe("Database error: " + e.getMessage());
                future.completeExceptionally(e);
            }
        });
        
        return future;
    }
}

/**
 * Calculates the exploration percentage for a dungeon
 *
 * @param dungeonId The ID of the dungeon
 * @return Percentage of the dungeon that has been explored (0-100)
 * @throws IllegalArgumentException If the dungeon ID is invalid
 */
public double calculateExplorationPercentage(int dungeonId) {
    // Implementation
}