Custom Spawn

var Bukkit = Java.type("org.bukkit.Bukkit");
var CreatureSpawnEvent = Java.type("org.bukkit.event.entity.CreatureSpawnEvent");
var EntityType = Java.type("org.bukkit.entity.EntityType");
var Location = Java.type("org.bukkit.Location");

var Double = Java.type("java.lang.Double");
var File = Java.type("java.io.File");
var Scanner = Java.type("java.util.Scanner");
var Integer = Java.type("java.lang.Integer");
var InputStreamReader = Java.type("java.io.InputStreamReader");
var Reader = Java.type("java.io.Reader");

var FileConfiguration = Java.type("org.bukkit.configuration.file.FileConfiguration");
var YamlConfiguration = Java.type("org.bukkit.configuration.file.YamlConfiguration");

var config = null;
var configFile = null;
var FAPI;

var npcs;
var spawned;

function reloadNpcs() {
    if (config == null)
        return;

    var worlds = config.getKeys(false);

    worlds.forEach(function(world) {
        var entities = config.getConfigurationSection(world);
        var entitiesKey = entities.getKeys(false);
    
        entitiesKey.forEach(function(entity) {
            var npc = entities.getConfigurationSection(entity);
            var data = {
                world: world.toString(),
                entity: entity.toString(),
                id: npc.toString(),
                tab: npc.getInt("tab"),
                probability: npc.getDouble("probability")
            };
            
            npcs.push(data);
        });
    }); 
}

function onInit() {
    FAPI = API.getTempData("FAPI");
    npcs = [];
    spawned = [];

    registerConfig();
    reloadNpcs();

    FAPI.registerCommand("sc-create", null, null, function (event) {
        var player = event.getPlayer();
        var args = event.getArguments();

        if (args.length < 5) {
            sendInfo(player);
            return;
        }

        var config = getConfig();

        try {
            var world = Bukkit.getWorld(args[0]);
            var entity = args[1].toUpperCase();
            var npc = args[2];
            var tab = args[3];
            var probability = args[4];
            var path;

            if (world == null) {
                API.message(player, "&c¡El mundo ingresado no existe!");
                return;
            }

            if (EntityType.valueOf(entity) == null) {
                API.message(player, "&c¡La entidad de reemplazo ingresada no existe!");
                return;
            }

            if (isNaN(tab) || isNaN(probability)) {
                API.message(player, "&c¡El tab y la probabilidad debe ser numérica!");
                return;
            }

            path = world.getName() + "." + entity + "." + npc;

            if (config.getString(path) != null) {
                API.message(player, "&c¡El NPC ya está registrado!");
                return;
            }

            tab = Integer.parseInt(tab);
            probability = Double.parseDouble(probability);

            config.set(path + ".tab", tab);
            config.set(path + ".probability", probability);
            saveConfig();
            API.message(player, "&a¡NPC registrado correctamente!");
        } catch (exception) {
            API.message(player, "&e&lOcurrió un error &7-> &c" + exception);
        }
    });

    FAPI.registerCommand("sc-delete", null, null, function (event) {
        var player = event.getPlayer();
        var args = event.getArguments();

        if (args.length < 3) {
            sendInfo(player);
            return;
        }

        var config = getConfig();

        try {
            var world = Bukkit.getWorld(args[0]);
            var entity = args[1];
            var npc = args[2]
            var path;

            if (world == null) {
                API.message(player, "&c¡El mundo ingresado no existe!");
                return;
            }

            if (EntityType.valueOf(entity) == null) {
                API.message(player, "&c¡La entidad de reemplazo ingresada no existe!");
                return;
            }

            path = world.getName() + "." + entity + "." + npc;

            if (config.get(path) == null) {
                API.message(player, "&c¡El NPC no está registrado!");
                return;
            }

            config.set(path, null);
            saveConfig();
            API.message(player, "&a¡NPC eliminado correctamente!");
        } catch (exception) {
            API.message(player, "&eOcurrió un error &7-> &c" + exception);
        }
    });

    FAPI.registerCommand("sc-reload", null, null, function (event) {
        var player = event.getPlayer();

        reloadConfig(); 
        reloadNpcs();
        API.message(player, "&a¡Configuración recargada correctamente!");
    });

    FAPI.registerCommand("sc-list", null, null, function (event) {
        var player = event.getPlayer();

        API.message(player, "&a&lLISTA:");
        previewFile(player);
    });

    API.registerListener(CreatureSpawnEvent.class, function(event) {
        var entity = event.getEntity();
        var location = entity.getLocation();

        for (var i = 0; i < npcs.length; i++) {
            try {
                var npc = npcs[i];

                if (entity.getWorld().getName() != npc.world) 
                    continue;

                if (entity.getType() != EntityType.valueOf(npc.entity))
                    continue;

                if (Math.random() * 100 > npc.probability)
                    continue;

                entity.remove();
                var optional = API.spawnClone(npc.id, npc.tab, location);

                optional.ifPresent(function(metadata) {
                    metadata.getNpc().ifPresent(function(n) {
                        var data = {
                            npc: n,
                            timestamp: Date.now()
                        };

                        spawned.push(data);
                    });
                });
            } catch (exception) {
                //
            }
        }
    });

    API.runRepeatingTask(function() {
        for (var i = spawned.length - 1; i >= 0; i--) {
            try {
                var data = spawned[i];

                if (Date.now() - data.timestamp > 600000) {
                    if (data.npc != null)
                        data.npc.despawn();

                    spawned.splice(i, 1);
                }
            } catch (exception) {
                //
            }
        }
    }, 1200);
}

function sendInfo(player) {
    API.message(player, "&8------ &f&lSPAWN CUSTOM &8------");
    API.message(player, "/sc-create <mundo> <entidad de reemplazo> <npc> <tab> <probabilidad>");
    API.message(player, "/sc-delete <mundo> <entidad de reemplazo> <npc>");
    API.message(player, "/sc-reload");
    API.message(player, "/sc-list");
}

function reloadConfig() {
	if (config == null) {
		configFile = new File(getDataFolder(), "spawncustom.yml");
	}

	config = YamlConfiguration.loadConfiguration(configFile);
	var defConfigStream;

	try {
		defConfigStream = new InputStreamReader(configFile, "UTF8");

		if (defConfigStream != null) {
			var defConfig = YamlConfiguration.loadConfiguration(defConfigStream);
			config.setDefaults(defConfig);
		}
	} catch(exception) {
		exception.printStackTrace();
	}
}

function getConfig() {
    if (config == null) {
        reloadConfig();
    }

    return config;
}
 
function saveConfig() {
	try {
		config.save(configFile);			
	} catch(exception) {
		exception.printStackTrace();
	}
}
 
function registerConfig() {
	configFile = new File(getDataFolder(), "spawncustom.yml");

	if (!configFile.exists()) {
		getConfig().options().copyDefaults(true);
		saveConfig();
	}
}

function previewFile(player) {
    try {
        var scan = new Scanner(configFile);

        while (scan.hasNextLine()) {
            var line = scan.nextLine();
            API.message(player, "&a" + line);
        }
        scan.close();
    } catch (exception) {
        exception.printStackTrace();
    }
}

function getDataFolder() {
    return new File(".");
}