Files
examples
level0.02
src
build.gradle
settings.gradle
Code
46 3,591
src/main/java/com/kodari/proceduraldimensions/ProceduralDimensions.java
package com.kodari.proceduraldimensions;

import com.kodari.proceduraldimensions.command.BackroomsCommand;
import com.kodari.proceduraldimensions.dimension.DimensionManager;
import com.kodari.proceduraldimensions.event.DimensionEventManager;
import com.kodari.proceduraldimensions.item.CustomItemManager;
import com.kodari.proceduraldimensions.listener.PlayerListener;
import com.kodari.proceduraldimensions.api.ProceduralDimensionsApi;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;

public final class ProceduralDimensions extends JavaPlugin {
    private DimensionManager dimensionManager;
    private DimensionEventManager eventManager;
    private CustomItemManager itemManager;
    private ProceduralDimensionsApi api;
    private PlayerListener playerListener;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        if (!new File(getDataFolder(), "eventsConfig.yml").exists()) {
            saveResource("eventsConfig.yml", false);
        }
        installDocumentation();
        File worlds = new File(getDataFolder(), "worlds");
        if (!worlds.exists()) worlds.mkdirs();
        if (getConfig().getBoolean("CreateExampleWorlds", true)) installExampleWorldPresets(worlds);

        itemManager = new CustomItemManager(this);
        dimensionManager = new DimensionManager(this);
        eventManager = new DimensionEventManager(this);
        api = new ProceduralDimensionsApi(this);

        playerListener = new PlayerListener(this);
        getServer().getPluginManager().registerEvents(playerListener, this);
        getServer().getPluginManager().registerEvents(dimensionManager, this);
        getServer().getPluginManager().registerEvents(itemManager, this);
        getServer().getPluginManager().registerEvents(eventManager, this);
        BackroomsCommand command = new BackroomsCommand(this);
        getCommand("backrooms").setExecutor(command);
        getCommand("backrooms").setTabCompleter(command);

        dimensionManager.loadDefinitions();
        Bukkit.getScheduler().runTaskTimer(this, dimensionManager::tick, 1L, 1L);
        Bukkit.getScheduler().runTaskTimer(this, eventManager::tick, 1L, 1L);
        Bukkit.getScheduler().runTaskTimer(this, playerListener::tick, 1L, 20L);
        long saveTicks = Math.max(30, getConfig().getInt("SaveInterval", 300)) * 20L;
        Bukkit.getScheduler().runTaskTimer(this, dimensionManager::saveAll, saveTicks, saveTicks);
    }

    private void installExampleWorldPresets(File worlds) {
        String[][] presets = {
                {"areas", "world", "world/strange", "Subrooms"},
                {"basic-random", "world", "Subrooms"},
                {"empty", "world", "Subrooms"},
                {"hallway"},
                {"hub", "world", "Subrooms"},
                {"repeat", "world", "Subrooms"},
                {"wave-connect", "world", "Subrooms"}
        };

        for (String[] preset : presets) {
            File folder = new File(worlds, preset[0]);
            if (!folder.exists() && !folder.mkdirs()) {
                getLogger().warning("Could not create example preset folder " + folder);
                continue;
            }

            File definition = new File(folder, preset[0] + ".yml");
            if (!definition.exists()) {
                String resourcePath = "presets/" + preset[0] + "/" + preset[0] + ".yml";
                try (InputStream resource = getResource(resourcePath)) {
                    if (resource == null) {
                        getLogger().warning("Missing bundled example preset " + resourcePath);
                        continue;
                    }
                    Files.copy(resource, definition.toPath());
                } catch (IOException ex) {
                    getLogger().warning("Could not install example preset " + preset[0] + ": " + ex.getMessage());
                    continue;
                }
            }

            for (int i = 1; i < preset.length; i++) {
                File templateFolder = new File(folder, preset[i]);
                if (!templateFolder.exists() && !templateFolder.mkdirs()) {
                    getLogger().warning("Could not create template folder " + templateFolder);
                }
            }
        }
    }

    private void installDocumentation() {
        File folder = new File(getDataFolder(), "docs");
        if (!folder.exists() && !folder.mkdirs()) {
            getLogger().warning("Could not create documentation folder " + folder);
            return;
        }

        String[] documents = {
                "README.md",
                "commands.md",
                "worlds-and-configuration.md",
                "items-and-events.md",
                "behavior-and-integrations.md"
        };
        for (String document : documents) {
            File target = new File(folder, document);
            if (target.exists()) continue;
            String resourcePath = "docs/" + document;
            try (InputStream resource = getResource(resourcePath)) {
                if (resource == null) {
                    getLogger().warning("Missing bundled documentation " + resourcePath);
                    continue;
                }
                Files.copy(resource, target.toPath());
            } catch (IOException ex) {
                getLogger().warning("Could not install documentation " + document + ": " + ex.getMessage());
            }
        }
    }

    @Override
    public void onDisable() {
        if (eventManager != null) eventManager.shutdown();
        if (playerListener != null) playerListener.shutdown();
        if (dimensionManager != null) dimensionManager.saveAll();
    }

    public void reloadPlugin() {
        if (eventManager != null) eventManager.shutdown();
        reloadConfig();
        if (dimensionManager != null) dimensionManager.loadDefinitions();
        if (eventManager != null) eventManager.reload();
        if (playerListener != null) playerListener.tick();
    }

    public DimensionManager dimensions() { return dimensionManager; }
    public DimensionEventManager events() { return eventManager; }
    public CustomItemManager items() { return itemManager; }
    public ProceduralDimensionsApi api() { return api; }
}