pax_global_header00006660000000000000000000000064150347677420014531gustar00rootroot0000000000000052 comment=20ff98dc9f2d142b27785136d286e9afae87c211 Resourceloader-2.2/000077500000000000000000000000001503476774200143525ustar00rootroot00000000000000Resourceloader-2.2/LICENSE000066400000000000000000000020471503476774200153620ustar00rootroot00000000000000MIT License Copyright (c) 2024 Vortex Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Resourceloader-2.2/README.md000066400000000000000000000300171503476774200156320ustar00rootroot00000000000000# Resourceloader ## Commands ### Core Commands - `/load` - Load the default server resource pack - `/load ` - Load a specific resource pack - `/autoload ` - Set automatic pack loading for players on join - `/listpacks` - List all available resource packs with status information ### Pack Management - `/mergepack .zip [pack3...]` - Merge multiple resource packs with intelligent conflict resolution - `/mergegui` - Open the graphical interface for merging packs with preview - `/removepack ` - Remove a resource pack from server and configuration - `/checkpack ` - Validate resource pack structure, JSON files, and textures ### Administration - `/resourcereload` - Reload the plugin configuration and rescan packs folder - `/resourceversion` - Check for plugin updates and version information - `/clearcache` - Clear the resource pack cache and temporary filesand flexible resource pack management plugin for Minecraft servers. Manage, merge, and distribute resource packs with advanced features for optimization and user experience! ## Features - **Advanced Resource Pack Management** - Complete pack lifecycle management with automatic backups and statistics - **Smart Compression System** - Adaptive compression levels based on player connection quality - **Intelligent Pack Merging** - Merge multiple packs with JSON/model conflict resolution and pack format compatibility - **Resource Pack Validation** - Comprehensive validation system for pack structure, JSON files, and missing textures - **Dual Pack Support** - Support for both local file and URL-based resource packs with automatic caching - **Enhanced Enforcement** - Reliable resource pack enforcement with proper player join handling and autoload - **Performance Optimizations** - SHA1 hash caching, intelligent compression, and optimized pack serving - **Smart File Watching** - Event batching system prevents duplicate notifications and config conflicts - **GUI Interface** - User-friendly graphical interface for pack merging with preview options - **Robust Configuration** - Auto-sync between packs folder and configuration with duplicate prevention - **Permission System** - Granular permission-based access control - **Easy Commands** - Intuitive commands with tab completion and comprehensive help ## Commands - `/load` - Load the default server resource pack - `/load ` - Load a specific resource pack - `/autoload ` - Automatically loads in the specified pack upon joining - `/mergepack .zip [pack3...]` - Merge resource packs - `/mergegui` - Open the graphical interface for merging packs - `/removepack ` - Remove a resource pack - `/listpacks` - List all available resource packs - `/resourcereload` - Reload the plugin configuration - `/resourceversion` - Check for plugin updates - `/clearcache` - Clear the resource pack cache ## Permissions - `resourceloader.load` - Use the /load command (default: true) - `resourceloader.list` - Use the /listpacks command (default: true) - `resourceloader.admin` - Access to all admin commands (default: op) - `resourceloader.bypass` - Bypass forced resource pack loading (default: op) ## Configuration ```yaml # ResourceLoader Configuration # For detailed documentation, visit: https://github.com/DefectiveVortex/Resourceloader #====================# # Resource Packs # #====================# # The default server resource pack that will be loaded when using /load without arguments # Examples: # Local file: "server-pack.zip" # URL: "https://example.com/server-pack.zip" server-pack: "" # Individual resource pack definitions # Format: # packname: "filename.zip" # For local files # packname: "https://..." # For external URLs resource-packs: # example1: "pack1.zip" # example2: "https://example.com/pack2.zip" # Storage configuration storage: # Custom directory for resource packs (absolute path) # Leave empty to use plugins/ResourceLoader/packs/ resource-pack-directory: "" # Automatic resource pack detection auto-detection: true #====================# # Server Settings # #====================# # Web server configuration for serving resource packs server: # The port to serve resource packs on (default: 40021) port: 40021 # Network settings (advanced) localhost: false # Set to true only for local testing address: "" # Leave empty for auto-detection fallback: localhost # Used if auto-detection fails #====================# # Performance # #====================# # Resource pack compression settings compression: # Enable compression of resource packs enabled: true # Compression level selection auto-select: true # Choose compression based on player's connection default-level: "medium" # Used when auto-select is false # Options: "low", "medium", "high" # Cache settings for downloaded resource packs cache: enabled: true expiry-days: 7 # How long to keep cached packs auto-cleanup: true # Automatically remove expired cache entries #====================# # Pack Management # #====================# # Backup configuration backup: enabled: true interval-hours: 24 # Hours between automatic backups keep-count: 5 # Number of backup files to retain # Usage statistics and player preferences statistics: enabled: true # Track pack usage and performance save-preferences: true # Remember player's last used packs max-preferences: 5 # Number of packs to remember per player #====================# # User Interface # #====================# # GUI settings for the pack merger gui: enabled: true show-preview: true # Show pack preview before merging conflict-handling: "ask" # How to handle conflicts: "ask", "overwrite", "skip" #====================# # Enforcement # #====================# # Resource pack enforcement settings enforcement: enabled: false kick-on-decline: true kick-on-fail: true restrict: prevent-interaction: true # Whether to use vanilla Minecraft's resource pack system by modifying server.properties # WARNING: This will override any existing resource pack settings in server.properties use-server-properties: false # If true, will create a public URL for the pack that doesn't require authentication # Only used when use-server-properties is true and a local file is used make-pack-public: false ``` ## Installation 1. Download the latest release 2. Place the JAR file in your server's `plugins` folder 3. Start/restart your server 4. A `packs` folder will be created in `plugins/Resourceloader/` 5. Place your resource pack files in the `packs` folder 6. Configure the plugin in `config.yml` (or let it auto-configure) 7. Use `/resourcereload` to apply changes ## Resource Pack Management ### File-based Resource Packs - Place .zip resource packs in `plugins/Resourceloader/packs/` - Files are automatically detected and added to configuration - Configuration keys are generated based on filenames (sanitized to prevent conflicts) - Automatic backups are created based on your settings - Smart file watching prevents duplicate notifications and config corruption ### URL-based Resource Packs - Support for direct download URLs with progress tracking - Automatic caching with SHA1 hash verification for better performance - Smart compression based on player connection quality - Configurable cache duration and automatic cleanup - Reliable download with retry mechanisms ### Resource Pack Validation - **Comprehensive Structure Validation** - Checks for pack.mcmeta, assets folder, and proper directory structure - **JSON File Validation** - Validates model files, blockstates, and item models for syntax errors - **Texture Reference Checking** - Detects missing textures referenced in model files - **Pack Format Compatibility** - Ensures pack format matches server Minecraft version - **Use `/checkpack ` to validate any resource pack** ### Enhanced Pack Merging - **Intelligent JSON Merging** - Smart handling of model files, blockstates, and item models - **Texture Conflict Resolution** - Preview and choose how to handle duplicate textures - **Pack Format Auto-Detection** - Automatically sets correct pack_format for server version - **Metadata Preservation** - Maintains pack.mcmeta compatibility and descriptions - **Real-time Preview** - See changes before committing to merged pack - **Command or GUI interface** - Use `/mergepack` or `/mergegui` for different workflows ### Autoload Priority System - **Player Preference Priority** - Autoload preferences (set via `/autoload`) take priority over server enforcement - **Smart Pack Loading** - Players with autoload preferences bypass enforcement and get their chosen pack - **Detailed Console Logging** - Clear logs showing whether autoload or enforcement is being applied - **Seamless Experience** - No conflicts between personal preferences and server requirements - **Per-Player Customization** - Each player can have their own preferred pack while maintaining server defaults ### Performance & Reliability Features - **SHA1 Hash Caching** - Prevents re-downloading unchanged packs and validates file integrity - **Event Batching** - Prevents duplicate file system notifications and reduces server load - **Adaptive Compression** - Optimizes pack size based on player connection quality - **Intelligent Enforcement** - Proper player join event handling for reliable pack loading - **Configuration Protection** - Prevents config corruption from simultaneous modifications - **Smart Cache Management** - Automatic cleanup of expired cache entries with configurable retention - **Optimized Pack Serving** - Efficient file serving with minimal memory footprint ### Statistics and Monitoring - Track pack usage and performance - Player preference history - Backup management - Usage statistics for optimization ## Troubleshooting & Best Practices ### Common Issues - **Pack Not Loading**: Use `/checkpack ` to validate pack structure and identify issues - **Config Corruption**: Plugin automatically prevents duplicate entries and config corruption - **Performance Issues**: Enable SHA1 caching and compression for better performance - **Player Join Issues**: Enforcement now uses PlayerJoinEvent for reliable pack loading - **Autoload Not Working**: Check console logs for detailed autoload/enforcement messages ### Autoload vs Enforcement Priority - **Priority Order**: Player autoload preferences (`/autoload`) always take priority over server enforcement - **How It Works**: When a player joins, the plugin first checks for their autoload preference, then falls back to enforcement - **Console Logging**: Look for "Autoload:" or "Enforcement:" messages in console to see which system is active - **Player Control**: Players can use `/autoload clear` to remove their preference and fall back to server enforcement ### Best Practices - **Validate Packs**: Always run `/checkpack` on new packs before distribution - **Use Compression**: Enable adaptive compression for better player experience - **Regular Maintenance**: Use `/clearcache` periodically to clear old cache files - **Monitor Logs**: Check console for pack validation warnings and errors - **Backup Strategy**: Enable automatic backups in configuration ### Performance Tips - Place smaller packs in the `packs` folder for faster local serving - Use URL-based packs for larger packs with CDN acceleration - Enable SHA1 caching to reduce redundant downloads - Configure appropriate cache retention periods ## Requirements - Minecraft 1.13 or newer - Java 17 or newer ## Support If you encounter any issues or have suggestions: - Create an issue on the GitHub repository - Contact @vortexunwanted on Discord (faster response) ## License This project is licensed under the MIT License - see the LICENSE file for details.Resourceloader-2.2/dependency-reduced-pom.xml000066400000000000000000000046211503476774200214170ustar00rootroot00000000000000 4.0.0 org.vortex Resourceloader Resourceloader 2.2 A simple resource pack loader for Minecraft servers clean package true src/main/resources maven-compiler-plugin 3.13.0 ${java.version} maven-shade-plugin 3.5.3 package shade org.json.simple org.vortex.resourceloader.libs.json.simple spigotmc-repo https://hub.spigotmc.org/nexus/content/repositories/snapshots/ dmulloy2-repo https://repo.dmulloy2.net/repository/public/ org.spigotmc spigot-api 1.21.1-R0.1-SNAPSHOT provided com.comphenix.protocol ProtocolLib 5.1.0 provided UTF-8 17 Resourceloader-2.2/pom.xml000066400000000000000000000073641503476774200157010ustar00rootroot00000000000000 4.0.0 org.vortex Resourceloader 2.2 jar Resourceloader A simple resource pack loader for Minecraft servers 17 UTF-8 clean package org.apache.maven.plugins maven-compiler-plugin 3.13.0 ${java.version} org.apache.maven.plugins maven-shade-plugin 3.5.3 package shade org.json.simple org.vortex.resourceloader.libs.json.simple src/main/resources true spigotmc-repo https://hub.spigotmc.org/nexus/content/repositories/snapshots/ dmulloy2-repo https://repo.dmulloy2.net/repository/public/ org.spigotmc spigot-api 1.21.1-R0.1-SNAPSHOT provided com.googlecode.json-simple json-simple 1.1.1 com.google.code.gson gson 2.10.1 com.fasterxml.jackson.core jackson-databind 2.15.2 commons-io commons-io 2.11.0 com.comphenix.protocol ProtocolLib 5.1.0 provided Resourceloader-2.2/src/000077500000000000000000000000001503476774200151415ustar00rootroot00000000000000Resourceloader-2.2/src/main/000077500000000000000000000000001503476774200160655ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/000077500000000000000000000000001503476774200170065ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/000077500000000000000000000000001503476774200175755ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/000077500000000000000000000000001503476774200211245ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/000077500000000000000000000000001503476774200241425ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/ResourcePackMerger.java000066400000000000000000000410621503476774200305400ustar00rootroot00000000000000package org.vortex.resourceloader; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.core.type.TypeReference; import org.apache.commons.io.FileUtils; import java.io.*; import java.util.*; import java.util.concurrent.*; import java.nio.file.*; import java.util.logging.Logger; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; import java.util.zip.ZipOutputStream; public class ResourcePackMerger { private final Resourceloader plugin; private final Logger logger; private static final int BUFFER_SIZE = 32768; private static final int THREAD_POOL_SIZE = Runtime.getRuntime().availableProcessors(); private final ExecutorService executor; private final Set pendingCleanup; public ResourcePackMerger(Resourceloader plugin) { this.plugin = plugin; this.logger = plugin.getLogger(); this.executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE); this.pendingCleanup = ConcurrentHashMap.newKeySet(); } public void shutdown() { executor.shutdown(); try { if (!executor.awaitTermination(5, TimeUnit.SECONDS)) { executor.shutdownNow(); } } catch (InterruptedException e) { executor.shutdownNow(); Thread.currentThread().interrupt(); } finally { cleanupAllWorkDirs(); } } private void cleanupAllWorkDirs() { for (File dir : pendingCleanup) { try { FileUtils.deleteDirectory(dir); } catch (IOException e) { logger.warning("Failed to clean up work directory: " + e.getMessage()); } } pendingCleanup.clear(); } public File mergeResourcePacks(List inputPacks, String outputName) throws IOException { if (inputPacks.isEmpty()) { throw new IllegalArgumentException("No input packs provided"); } // Calculate required space (rough estimate: sum of input sizes * 2 for safety) long requiredSpace = 0; for (File pack : inputPacks) { requiredSpace += pack.length() * 2; } // Create work directory File workDir = new File(plugin.getDataFolder(), "temp/merge_" + System.currentTimeMillis()); workDir.mkdirs(); pendingCleanup.add(workDir); try { // Check available space long availableSpace = workDir.getUsableSpace(); if (availableSpace < requiredSpace) { throw new IOException("Insufficient disk space. Required: " + (requiredSpace / 1024 / 1024) + "MB, Available: " + (availableSpace / 1024 / 1024) + "MB"); } logger.info("Merging " + inputPacks.size() + " resource packs..."); // Extract packs in parallel List> extractFutures = new ArrayList<>(); for (File pack : inputPacks) { extractFutures.add(executor.submit(() -> extractPack(pack, workDir))); } // Wait for all extractions to complete List extractedDirs = new ArrayList<>(); for (Future future : extractFutures) { try { extractedDirs.add(future.get()); } catch (Exception e) { throw new IOException("Failed to extract pack: " + e.getMessage(), e); } } // Merge directories in order (last pack has highest priority) File outputDir = new File(workDir, "merged"); outputDir.mkdirs(); for (int i = 0; i < extractedDirs.size(); i++) { File sourceDir = extractedDirs.get(i); mergeDirectory(sourceDir, outputDir, i == extractedDirs.size() - 1); // Cleanup extracted directory after merging to free space if (i < extractedDirs.size() - 1) { FileUtils.deleteDirectory(sourceDir); } } // Create output file File outputFile = new File(plugin.getDataFolder(), "packs/" + outputName); zipDirectory(outputDir, outputFile); // Update pack.mcmeta with latest format updatePackMeta(outputDir); logger.info("Resource packs merged successfully!"); return outputFile; } catch (Exception e) { throw new IOException("Failed to merge resource packs: " + e.getMessage(), e); } finally { cleanup(workDir); } } private File extractPack(File pack, File workDir) throws IOException { if (!pack.getName().toLowerCase().endsWith(".zip")) { return pack; } File extractDir = new File(workDir, pack.getName().replace(".zip", "")); try (ZipFile zipFile = new ZipFile(pack)) { Enumeration entries = zipFile.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); File entryFile = new File(extractDir, entry.getName()); if (entry.isDirectory()) { entryFile.mkdirs(); continue; } entryFile.getParentFile().mkdirs(); try (InputStream in = zipFile.getInputStream(entry); OutputStream out = new FileOutputStream(entryFile)) { byte[] buffer = new byte[BUFFER_SIZE]; int read; while ((read = in.read(buffer)) != -1) { out.write(buffer, 0, read); } } } } return extractDir; } private void mergeDirectory(File sourceDir, File targetDir, boolean isLastPack) throws IOException { if (!sourceDir.exists()) { return; } Files.walk(sourceDir.toPath()) .filter(Files::isRegularFile) .forEach(sourcePath -> { try { Path relativePath = sourceDir.toPath().relativize(sourcePath); File targetFile = new File(targetDir, relativePath.toString()); if (sourcePath.toString().endsWith(".json")) { mergeJsonFile(targetFile, sourcePath.toFile(), isLastPack); } else { // For non-JSON files, newer pack always takes priority if (isLastPack || !targetFile.exists()) { FileUtils.copyFile(sourcePath.toFile(), targetFile); } } } catch (IOException e) { logger.warning("Failed to merge file " + sourcePath + ": " + e.getMessage()); } }); } private void mergeJsonFile(File targetFile, File sourceFile, boolean isLastPack) throws IOException { ObjectMapper mapper = new ObjectMapper(); // Read source file Map sourceMap = readJsonFile(sourceFile, mapper); if (sourceMap == null) return; // If target doesn't exist or this is the last pack, just copy/overwrite if (!targetFile.exists() || isLastPack) { targetFile.getParentFile().mkdirs(); FileUtils.copyFile(sourceFile, targetFile); return; } // Read target file Map targetMap = readJsonFile(targetFile, mapper); if (targetMap == null) { FileUtils.copyFile(sourceFile, targetFile); return; } // Special handling for different types of JSON files if (isModelFile(targetFile)) { mergeModelFile(targetMap, sourceMap); } else if (isLanguageFile(targetFile)) { // Language files just need simple merging with override targetMap.putAll(sourceMap); } else { // Default deep merge for other JSON files deepMerge(targetMap, sourceMap); } // Write merged result writeJsonFile(targetFile, targetMap, mapper); } private boolean isModelFile(File file) { String path = file.getPath().toLowerCase(); return path.contains("models") || path.contains("blockstates") || path.endsWith(".model.json"); } private boolean isLanguageFile(File file) { return file.getPath().toLowerCase().contains("lang"); } @SuppressWarnings("unchecked") private void mergeModelFile(Map target, Map source) { // Handle parent field - newer pack's parent takes priority if (source.containsKey("parent")) { target.put("parent", source.get("parent")); } // Merge textures if (source.containsKey("textures")) { Map targetTextures = (Map) target.computeIfAbsent("textures", k -> new HashMap<>()); targetTextures.putAll((Map) source.get("textures")); } // Merge elements - preserve both sets if (source.containsKey("elements")) { List targetElements = (List) target.computeIfAbsent("elements", k -> new ArrayList<>()); targetElements.addAll((List) source.get("elements")); } // Handle display settings if (source.containsKey("display")) { target.put("display", source.get("display")); } // Merge overrides with duplicate checking if (source.containsKey("overrides")) { List> targetOverrides = (List>) target.computeIfAbsent("overrides", k -> new ArrayList<>()); List> sourceOverrides = (List>) source.get("overrides"); Set existingPredicates = new HashSet<>(); targetOverrides.forEach(override -> existingPredicates.add(override.toString())); sourceOverrides.forEach(override -> { if (!existingPredicates.contains(override.toString())) { targetOverrides.add(override); } }); } } @SuppressWarnings("unchecked") private void deepMerge(Map target, Map source) { for (String key : source.keySet()) { Object sourceValue = source.get(key); if (sourceValue instanceof Map) { Map targetMap = (Map) target.computeIfAbsent(key, k -> new HashMap<>()); deepMerge(targetMap, (Map) sourceValue); } else { target.put(key, sourceValue); } } } private Map readJsonFile(File file, ObjectMapper mapper) { try { return mapper.readValue(file, new TypeReference>() {}); } catch (IOException e) { logger.warning("Failed to read JSON file " + file.getName() + ": " + e.getMessage()); return null; } } private void writeJsonFile(File file, Map content, ObjectMapper mapper) throws IOException { File tempFile = new File(file.getParentFile(), file.getName() + ".tmp"); try { file.getParentFile().mkdirs(); mapper.writerWithDefaultPrettyPrinter().writeValue(tempFile, content); Files.move(tempFile.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { tempFile.delete(); throw e; } } private void zipDirectory(File sourceDir, File zipFile) throws IOException { try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) { Files.walk(sourceDir.toPath()) .filter(path -> !Files.isDirectory(path)) .forEach(path -> { ZipEntry zipEntry = new ZipEntry(sourceDir.toPath().relativize(path).toString().replace('\\', '/')); try { zos.putNextEntry(zipEntry); Files.copy(path, zos); zos.closeEntry(); } catch (IOException e) { logger.warning("Failed to add file to zip: " + path); } }); } } private int getPackFormat() { String version = plugin.getServer().getBukkitVersion(); // Extract the main version number (e.g., "1.20.4-R0.1-SNAPSHOT" -> "1.20.4") version = version.split("-")[0]; // Map Minecraft versions to pack_format numbers return switch (version) { case "1.20.3", "1.20.4" -> 18; // 1.20.3 - 1.20.4 case "1.20.2" -> 17; // 1.20.2 case "1.20", "1.20.1" -> 15; // 1.20 - 1.20.1 case "1.19.4" -> 13; // 1.19.4 case "1.19.3" -> 12; // 1.19.3 case "1.19.1", "1.19.2" -> 9; // 1.19 - 1.19.2 case "1.18.2" -> 8; // 1.18.2 case "1.18", "1.18.1" -> 7; // 1.18 - 1.18.1 case "1.17", "1.17.1" -> 7; // 1.17 - 1.17.1 case "1.16.2", "1.16.3", "1.16.4", "1.16.5" -> 6; // 1.16.2 - 1.16.5 case "1.16", "1.16.1" -> 5; // 1.16 - 1.16.1 case "1.15", "1.15.1", "1.15.2" -> 5; // 1.15.x case "1.14", "1.14.1", "1.14.2", "1.14.3", "1.14.4" -> 4; // 1.14.x case "1.13", "1.13.1", "1.13.2" -> 4; // 1.13.x case "1.21", "1.21.1", "1.21.2", "1.21.3", "1.21.4", "1.21.5", "1.21.6", "1.21.7" -> 22; // Future versions default -> { // For unknown versions, try to make an educated guess // This helps with future versions until we update the mapping String[] parts = version.split("\\."); if (parts.length >= 2) { int major = Integer.parseInt(parts[1]); if (major >= 21) { // Future versions yield 22; } else if (major >= 20) { yield 18; } else if (major >= 19) { yield 13; } } // Default to latest known format if we can't determine version yield 22; } }; } private void updatePackMeta(File packDir) throws IOException { File mcmetaFile = new File(packDir, "pack.mcmeta"); ObjectMapper mapper = new ObjectMapper(); Map mcmeta; if (mcmetaFile.exists()) { mcmeta = readJsonFile(mcmetaFile, mapper); if (mcmeta == null) { mcmeta = new HashMap<>(); } } else { mcmeta = new HashMap<>(); } Object packObj = mcmeta.computeIfAbsent("pack", k -> new HashMap<>()); Map pack; if (packObj instanceof Map mapObj) { @SuppressWarnings("unchecked") Map safePack = (Map) mapObj; pack = safePack; } else { pack = new HashMap<>(); mcmeta.put("pack", pack); } // Use the server's version to determine pack format int packFormat = getPackFormat(); pack.put("pack_format", packFormat); pack.put("description", "Merged Resource Pack (Format: " + packFormat + ")"); logger.info("Setting merged pack format to " + packFormat + " for server version " + plugin.getServer().getBukkitVersion()); writeJsonFile(mcmetaFile, mcmeta, mapper); } private void cleanup(File workDir) { CompletableFuture.runAsync(() -> { try { if (workDir != null && workDir.exists()) { FileUtils.deleteDirectory(workDir); } } catch (IOException e) { logger.warning("Failed to clean up temporary directory: " + e.getMessage()); } finally { pendingCleanup.remove(workDir); } }, executor); } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/Resourceloader.java000066400000000000000000000216061503476774200277700ustar00rootroot00000000000000// ResourceLoader.java package org.vortex.resourceloader; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.entity.Player; import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.command.TabCompleter; import java.io.File; import java.util.ArrayList; import java.util.List; import java.util.Map; import org.bukkit.util.StringUtil; import org.vortex.resourceloader.util.FileUtil; import java.util.Collections; import org.vortex.resourceloader.core.ResourcePackManager; import org.vortex.resourceloader.compression.PackCompressor; import org.vortex.resourceloader.gui.MergeGUI; import org.vortex.resourceloader.util.MessageManager; import org.vortex.resourceloader.commands.CommandManager; import org.vortex.resourceloader.listeners.ResourcePackEnforcer; import org.vortex.resourceloader.listeners.EarlyPackLoader; public final class Resourceloader extends JavaPlugin { private final ResourcePackManager packManager; private final PackCompressor packCompressor; private MergeGUI mergeGUI; private final MessageManager messageManager; public Resourceloader() { this.messageManager = new MessageManager(this); this.packManager = new ResourcePackManager(this); this.packCompressor = new PackCompressor(this); } @Override public void onEnable() { // Create plugin directory if it doesn't exist if (!getDataFolder().exists()) { getDataFolder().mkdirs(); } // Save default config if it doesn't exist saveDefaultConfig(); // Register commands new CommandManager(this); // Initialize GUI if enabled if (getConfig().getBoolean("gui.enabled", true)) { mergeGUI = new MergeGUI(this); } // Initialize early pack loading with server.properties if enabled if (getConfig().getBoolean("enforcement.use-server-properties", false)) { new EarlyPackLoader(this); getLogger().info("Early resource pack loading enabled with server.properties"); } else { // Register regular resource pack enforcer getServer().getPluginManager().registerEvents(new ResourcePackEnforcer(this), this); } getLogger().info("ResourceLoader has been enabled!"); } @Override public void onDisable() { if (packManager != null) { packManager.shutdown(); } if (packCompressor != null) { packCompressor.shutdown(); } getLogger().info("ResourceLoader has been disabled!"); } public void loadResourcePacks() { loadResourcePacks(false); } public void loadResourcePacks(boolean silent) { packManager.loadResourcePacks(silent); } public Map getResourcePacks() { return packManager.getResourcePacks(); } public ResourcePackManager getPackManager() { return packManager; } public PackCompressor getPackCompressor() { return packCompressor; } public MergeGUI getMergeGUI() { return mergeGUI; } public MessageManager getMessageManager() { return messageManager; } public class LoadCommand implements CommandExecutor, TabCompleter { private final Resourceloader plugin; public LoadCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player player)) { sender.sendMessage(plugin.getMessageManager().getMessage("general.player-only")); return true; } if (!player.hasPermission("resourceloader.load")) { player.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } if (args.length < 1) { String defaultPackPath = plugin.getConfig().getString("server-pack"); if (defaultPackPath == null || defaultPackPath.isEmpty()) { player.sendMessage(plugin.getMessageManager().getMessage("resource-packs.no-default")); return true; } loadResourcePack(player, "server", defaultPackPath); return true; } String packName = args[0].toLowerCase(); ConfigurationSection packs = plugin.getConfig().getConfigurationSection("resource-packs"); if (!plugin.getResourcePacks().containsKey(packName)) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.not-found", "pack", packName)); return true; } String packPath = packs.getString(packName); loadResourcePack(player, packName, packPath); return true; } public void loadResourcePack(Player player, String packName, String packPath) { if (packPath == null || packPath.isEmpty()) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.invalid-path", "pack", packName)); return; } try { if (packPath.startsWith("http://") || packPath.startsWith("https://")) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.loading", "pack", packName)); plugin.getPackManager().getPackCache().getCachedPack(packPath, packName) .thenAccept(cachedFile -> { try { byte[] fileHash = FileUtil.calcSHA1(cachedFile); String downloadUrl = plugin.getPackManager().getPackServer().createDownloadURL(player, packName, cachedFile.getName()); player.setResourcePack(downloadUrl, fileHash); player.sendMessage(plugin.getMessageManager().getMessage("resource-packs.load-success")); } catch (Exception e) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.load-failed", "error", e.getMessage())); plugin.getLogger().warning("Failed to load cached pack: " + e.getMessage()); } }) .exceptionally(e -> { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.load-failed", "error", e.getMessage())); plugin.getLogger().warning("Failed to load pack: " + e.getMessage()); return null; }); } else { File packFile = plugin.getResourcePacks().get(packName); if (packFile == null || !packFile.exists()) { player.sendMessage(plugin.getMessageManager().getMessage("resource-packs.file-not-found")); return; } String finalUrl = plugin.getPackManager().getPackServer().createDownloadURL(player, packName, packPath); byte[] hash = FileUtil.calcSHA1(packFile); if (hash != null) { player.setResourcePack(finalUrl, hash); } else { player.setResourcePack(finalUrl); } player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.loading", "pack", packName)); } plugin.getLogger().info("Resource pack '" + packName + "' load attempted for player " + player.getName()); } catch (Exception e) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.load-failed", "error", e.getMessage())); plugin.getLogger().warning("Resource pack loading failed for " + packName + ": " + e.getMessage()); e.printStackTrace(); } } @Override public List onTabComplete(CommandSender sender, Command command, String alias, String[] args) { List completions = new ArrayList<>(); if (args.length == 1) { if (sender.hasPermission("resourceloader.load")) { List packs = new ArrayList<>(plugin.getResourcePacks().keySet()); StringUtil.copyPartialMatches(args[0], packs, completions); } } Collections.sort(completions); return completions; } } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/VersionChecker.java000066400000000000000000000123501503476774200277200ustar00rootroot00000000000000package org.vortex.resourceloader; import org.bukkit.ChatColor; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerJoinEvent; import org.json.simple.JSONObject; import org.json.simple.parser.JSONParser; import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URI; import java.net.URL; import java.util.concurrent.CompletableFuture; public class VersionChecker implements Listener { private final Resourceloader plugin; private volatile String latestVersion = null; private volatile boolean isUpdateAvailable = false; public VersionChecker(Resourceloader plugin) { this.plugin = plugin; checkForUpdates(); } private void checkForUpdates() { CompletableFuture.runAsync(() -> { try { URL url = URI.create("https://api.github.com/repos/DefectiveVortex/Resourceloader/releases/latest").toURL(); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestMethod("GET"); conn.setRequestProperty("Accept", "application/vnd.github.v3+json"); if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) { BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream())); StringBuilder response = new StringBuilder(); String line; while ((line = reader.readLine()) != null) { response.append(line); } reader.close(); JSONParser parser = new JSONParser(); JSONObject jsonResponse = (JSONObject) parser.parse(response.toString()); latestVersion = ((String) jsonResponse.get("tag_name")).replace("v", ""); String currentVersion = plugin.getDescription().getVersion(); isUpdateAvailable = !currentVersion.equals(latestVersion); if (isUpdateAvailable) { plugin.getLogger().info("A new version of Resourceloader is available! Current: " + currentVersion + ", Latest: " + latestVersion); } } } catch (Exception e) { plugin.getLogger().warning("Failed to check for updates: " + e.getMessage()); } }); } @EventHandler public void onPlayerJoin(PlayerJoinEvent event) { Player player = event.getPlayer(); if (player.hasPermission("resourceloader.admin") && isUpdateAvailable && latestVersion != null) { plugin.getServer().getScheduler().runTaskLater(plugin, () -> { player.sendMessage(ChatColor.YELLOW + "[Resourceloader] " + ChatColor.WHITE + "A new version is available! Current: " + ChatColor.RED + plugin.getDescription().getVersion() + ChatColor.WHITE + ", Latest: " + ChatColor.GREEN + latestVersion); player.sendMessage(ChatColor.YELLOW + "Use " + ChatColor.WHITE + "/resourceversion check" + ChatColor.YELLOW + " for more information."); }, 40L); // Delay of 2 seconds after join } } public class VersionCommand implements CommandExecutor { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(ChatColor.RED + "You don't have permission to check the version."); return true; } String currentVersion = plugin.getDescription().getVersion(); sender.sendMessage(ChatColor.YELLOW + "Checking for updates..."); CompletableFuture.runAsync(() -> { checkForUpdates(); plugin.getServer().getScheduler().runTask(plugin, () -> { if (latestVersion == null) { sender.sendMessage(ChatColor.RED + "Failed to check for updates."); return; } sender.sendMessage(ChatColor.YELLOW + "Current version: " + ChatColor.WHITE + currentVersion); sender.sendMessage(ChatColor.YELLOW + "Latest version: " + ChatColor.WHITE + latestVersion); if (isUpdateAvailable) { sender.sendMessage(ChatColor.GREEN + "A new version is available!"); sender.sendMessage(ChatColor.YELLOW + "Download it from: " + ChatColor.WHITE + "https://github.com/DefectiveVortex/Resourceloader/releases/latest"); } else { sender.sendMessage(ChatColor.GREEN + "You are running the latest version!"); } }); }); return true; } } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/000077500000000000000000000000001503476774200257435ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/AutoLoadCommand.java000066400000000000000000000076211503476774200316230ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import org.bukkit.util.StringUtil; import org.vortex.resourceloader.Resourceloader; import org.vortex.resourceloader.util.FileUtil; import java.io.File; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class AutoLoadCommand implements CommandExecutor, TabCompleter { private final Resourceloader plugin; public AutoLoadCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player player)) { sender.sendMessage(plugin.getMessageManager().getMessage("general.players-only")); return true; } if (!player.hasPermission("resourceloader.autoload")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } if (args.length == 0) { List preferences = plugin.getPackManager().getPlayerPreferences(player.getUniqueId()); if (preferences.isEmpty()) { player.sendMessage(plugin.getMessageManager().getMessage("autoload.no-preference")); } else { player.sendMessage(plugin.getMessageManager().formatMessage("autoload.current-preference", "pack", preferences.get(0))); } return true; } if (args[0].equalsIgnoreCase("clear")) { plugin.getPackManager().clearPlayerPreferences(player.getUniqueId()); player.sendMessage(plugin.getMessageManager().getMessage("autoload.cleared")); return true; } String packName = args[0].toLowerCase(); if (!plugin.getResourcePacks().containsKey(packName)) { player.sendMessage(plugin.getMessageManager().formatMessage("general.invalid-pack", "pack", packName)); return true; } // Set preference and immediately apply the pack plugin.getPackManager().setPlayerPreference(player.getUniqueId(), packName); // Apply the pack immediately File packFile = plugin.getResourcePacks().get(packName); if (packFile != null && packFile.exists()) { try { String downloadUrl = plugin.getPackManager().getPackServer().createDownloadURL(player, packName, packFile.getName()); byte[] hash = FileUtil.calcSHA1(packFile); player.setResourcePack(downloadUrl, hash); player.sendMessage(plugin.getMessageManager().formatMessage("autoload.set", "pack", packName)); } catch (Exception e) { player.sendMessage(plugin.getMessageManager().formatMessage("autoload.set-failed", "pack", packName, "error", e.getMessage())); plugin.getLogger().warning("Failed to apply resource pack for " + player.getName() + ": " + e.getMessage()); } } return true; } @Override public List onTabComplete(CommandSender sender, Command command, String alias, String[] args) { List completions = new ArrayList<>(); if (args.length == 1) { if (sender.hasPermission("resourceloader.autoload")) { List options = new ArrayList<>(plugin.getResourcePacks().keySet()); options.add("clear"); StringUtil.copyPartialMatches(args[0], options, completions); } } Collections.sort(completions); return completions; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/CheckPackCommand.java000066400000000000000000000111701503476774200317210ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.vortex.resourceloader.Resourceloader; import org.vortex.resourceloader.util.MessageManager; import org.vortex.resourceloader.validation.PackValidator; import java.io.File; import java.util.ArrayList; import java.util.List; public class CheckPackCommand implements CommandExecutor, TabCompleter { private final Resourceloader plugin; private final MessageManager messageManager; private final PackValidator validator; public CheckPackCommand(Resourceloader plugin) { this.plugin = plugin; this.messageManager = plugin.getMessageManager(); this.validator = new PackValidator(plugin); } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(messageManager.getMessage("general.no-permission")); return true; } if (args.length != 1) { sender.sendMessage("§cUsage: /checkpack "); return true; } String packName = args[0]; // Check if pack exists in configuration if (!plugin.getConfig().contains("resource-packs." + packName)) { sender.sendMessage("§cResource pack '" + packName + "' not found in configuration."); return true; } String packPath = plugin.getConfig().getString("resource-packs." + packName); File packFile; // Determine if it's a local file or URL if (packPath.startsWith("http://") || packPath.startsWith("https://")) { sender.sendMessage("§eValidating URL-based pack: " + packName); sender.sendMessage("§7Note: URL packs are validated when downloaded. Use this command on local files for detailed validation."); return true; } else { // Local file File packsDir = new File(plugin.getDataFolder(), "packs"); packFile = new File(packsDir, packPath); if (!packFile.exists()) { sender.sendMessage("§cPack file not found: " + packFile.getPath()); return true; } } sender.sendMessage("§eValidating resource pack: §f" + packName); sender.sendMessage("§7File: " + packFile.getName()); // Perform validation PackValidator.ValidationResult result = validator.validate(packFile); // Display results if (result.isValid()) { sender.sendMessage("§a✓ Pack validation successful!"); } else { sender.sendMessage("§c✗ Pack validation failed!"); } // Show formatted results List formattedResults = result.getFormattedIssues(); for (String line : formattedResults) { if (line.startsWith("Critical Issues:")) { sender.sendMessage("§c" + line); } else if (line.startsWith("Warnings:")) { sender.sendMessage("§e" + line); } else if (line.startsWith("- ")) { // Individual issue if (formattedResults.indexOf(line) > 0 && formattedResults.get(formattedResults.indexOf(line) - 1).startsWith("Critical Issues:")) { sender.sendMessage("§c" + line); } else if (formattedResults.indexOf(line) > 0 && formattedResults.get(formattedResults.indexOf(line) - 1).startsWith("Warnings:")) { sender.sendMessage("§e" + line); } else { sender.sendMessage("§7" + line); } } else { sender.sendMessage("§7" + line); } } return true; } @Override public List onTabComplete(CommandSender sender, Command command, String alias, String[] args) { List completions = new ArrayList<>(); if (args.length == 1) { // Return available pack names if (plugin.getConfig().contains("resource-packs")) { for (String packName : plugin.getConfig().getConfigurationSection("resource-packs").getKeys(false)) { if (packName.toLowerCase().startsWith(args[0].toLowerCase())) { completions.add(packName); } } } } return completions; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/CommandManager.java000066400000000000000000000300211503476774200314530ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.vortex.resourceloader.Resourceloader; public class CommandManager { private final Resourceloader plugin; private final MergeCommand mergeCommand; public CommandManager(Resourceloader plugin) { this.plugin = plugin; this.mergeCommand = new MergeCommand(plugin); registerCommands(); } private void registerCommands() { // Register load command LoadCommand loadCmd = new LoadCommand(plugin); plugin.getCommand("load").setExecutor(loadCmd); plugin.getCommand("load").setTabCompleter(loadCmd); // Register list command plugin.getCommand("packlist").setExecutor(new ListPacksCommand(plugin)); // Register merge commands plugin.getCommand("mergepack").setExecutor(mergeCommand); plugin.getCommand("mergepack").setTabCompleter(mergeCommand); plugin.getCommand("mergegui").setExecutor(new MergeGUICommand(plugin)); // Register admin commands plugin.getCommand("removepack").setExecutor(new RemovePackCommand(plugin)); plugin.getCommand("removepack").setTabCompleter(new RemovePackCommand(plugin)); CheckPackCommand checkPackCmd = new CheckPackCommand(plugin); plugin.getCommand("checkpack").setExecutor(checkPackCmd); plugin.getCommand("checkpack").setTabCompleter(checkPackCmd); plugin.getCommand("resourcereload").setExecutor(new ReloadCommand(plugin)); plugin.getCommand("clearcache").setExecutor(new ClearCacheCommand(plugin)); plugin.getCommand("resourceversion").setExecutor(new VersionCommand(plugin)); // Register autoload command AutoLoadCommand autoLoadCmd = new AutoLoadCommand(plugin); plugin.getCommand("autoload").setExecutor(autoLoadCmd); plugin.getCommand("autoload").setTabCompleter(autoLoadCmd); // Register help command plugin.getCommand("resourcehelp").setExecutor(new HelpCommand(plugin)); } public MergeCommand getMergeCommand() { return mergeCommand; } private static class HelpCommand implements CommandExecutor { public HelpCommand(Resourceloader plugin) { // Constructor for consistency } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { sender.sendMessage("§6=== ResourceLoader Help ==="); if (sender.hasPermission("resourceloader.load")) { sender.sendMessage("§e/load [pack] §7- Load a resource pack"); sender.sendMessage("§e/load §7- Load a specific resource pack"); } if (sender.hasPermission("resourceloader.list")) { sender.sendMessage("§e/listpacks §7- List available resource packs"); } if (sender.hasPermission("resourceloader.autoload")) { sender.sendMessage("§e/autoload §7- Set automatic pack loading"); } if (sender.hasPermission("resourceloader.admin")) { sender.sendMessage("§6=== Admin Commands ==="); sender.sendMessage("§e/mergepack §7- Merge resource packs"); sender.sendMessage("§e/mergegui §7- Open merge GUI"); sender.sendMessage("§e/removepack §7- Remove a resource pack"); sender.sendMessage("§e/checkpack §7- Validate a resource pack"); sender.sendMessage("§e/resourcereload §7- Reload configuration"); sender.sendMessage("§e/resourceversion §7- Check plugin version"); sender.sendMessage("§e/clearcache §7- Clear resource pack cache"); } sender.sendMessage("§6=========================="); return true; } } private static class ReloadCommand implements CommandExecutor { private final Resourceloader plugin; public ReloadCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } try { plugin.reloadConfig(); plugin.getMessageManager().reloadMessages(); plugin.loadResourcePacks(true); sender.sendMessage(plugin.getMessageManager().getMessage("general.reload-success")); } catch (Exception e) { sender.sendMessage(plugin.getMessageManager().formatMessage("general.reload-failed", "error", e.getMessage())); } return true; } } private static class ClearCacheCommand implements CommandExecutor { private final Resourceloader plugin; public ClearCacheCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } plugin.getPackManager().getPackCache().clearCache(); sender.sendMessage(plugin.getMessageManager().getMessage("cache.cleared")); return true; } } private static class ListPacksCommand implements CommandExecutor { private final Resourceloader plugin; public ListPacksCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.list")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } sender.sendMessage(plugin.getMessageManager().getMessage("list.header")); if (plugin.getResourcePacks().isEmpty()) { sender.sendMessage(plugin.getMessageManager().getMessage("list.no-packs")); sender.sendMessage(plugin.getMessageManager().getMessage("list.footer")); return true; } String serverPack = plugin.getConfig().getString("server-pack"); if (serverPack != null && !serverPack.isEmpty()) { String packType = serverPack.startsWith("http") ? "URL" : "File"; sender.sendMessage(plugin.getMessageManager().formatMessage("list.default-pack", "type", packType)); } plugin.getResourcePacks().forEach((name, file) -> { if (!name.equals("server")) { String packType = file == null ? "URL" : "File"; sender.sendMessage(plugin.getMessageManager().formatMessage("list.pack-entry", "pack", name, "type", packType)); } }); sender.sendMessage(plugin.getMessageManager().getMessage("list.footer")); return true; } } private static class VersionCommand implements CommandExecutor { private final Resourceloader plugin; public VersionCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } String currentVersion = plugin.getDescription().getVersion(); sender.sendMessage("§eChecking for updates..."); // Use async task to check for updates plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> { try { java.net.URL url = java.net.URI.create("https://api.github.com/repos/DefectiveVortex/Resourceloader/releases/latest").toURL(); java.net.HttpURLConnection conn = (java.net.HttpURLConnection) url.openConnection(); conn.setRequestMethod("GET"); conn.setRequestProperty("Accept", "application/vnd.github.v3+json"); conn.setConnectTimeout(5000); conn.setReadTimeout(5000); if (conn.getResponseCode() == java.net.HttpURLConnection.HTTP_OK) { java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(conn.getInputStream())); StringBuilder response = new StringBuilder(); String line; while ((line = reader.readLine()) != null) { response.append(line); } reader.close(); // Parse JSON response String jsonResponse = response.toString(); String latestVersion = null; // Simple JSON parsing to extract tag_name int tagStart = jsonResponse.indexOf("\"tag_name\":\"") + 12; if (tagStart > 11) { int tagEnd = jsonResponse.indexOf("\"", tagStart); if (tagEnd > tagStart) { latestVersion = jsonResponse.substring(tagStart, tagEnd).replace("v", ""); } } final String finalLatestVersion = latestVersion; plugin.getServer().getScheduler().runTask(plugin, () -> { if (finalLatestVersion != null) { sender.sendMessage("§eCurrent version: §f" + currentVersion); sender.sendMessage("§eLatest version: §f" + finalLatestVersion); if (!currentVersion.equals(finalLatestVersion)) { sender.sendMessage("§aA new version is available!"); sender.sendMessage("§eDownload it from: §fhttps://github.com/DefectiveVortex/Resourceloader/releases/latest"); } else { sender.sendMessage("§aYou are running the latest version!"); } } else { sender.sendMessage("§cFailed to parse version information."); } }); } else { final int responseCode = conn.getResponseCode(); plugin.getServer().getScheduler().runTask(plugin, () -> { sender.sendMessage("§cFailed to check for updates. HTTP " + responseCode); }); } } catch (Exception e) { plugin.getServer().getScheduler().runTask(plugin, () -> { sender.sendMessage("§cFailed to check for updates: " + e.getMessage()); sender.sendMessage("§eCurrent version: §f" + currentVersion); }); } }); return true; } } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/LoadCommand.java000066400000000000000000000050631503476774200307700ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import org.bukkit.util.StringUtil; import org.vortex.resourceloader.Resourceloader; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class LoadCommand implements CommandExecutor, TabCompleter { private final Resourceloader plugin; public LoadCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player player)) { sender.sendMessage(plugin.getMessageManager().getMessage("general.players-only")); return true; } if (!player.hasPermission("resourceloader.load")) { player.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } if (args.length < 1) { String defaultPackPath = plugin.getConfig().getString("server-pack"); if (defaultPackPath == null || defaultPackPath.isEmpty()) { player.sendMessage(plugin.getMessageManager().getMessage("resource-packs.no-default")); return true; } plugin.getPackManager().loadResourcePack(player, "server", defaultPackPath); return true; } String packName = args[0].toLowerCase(); if (!plugin.getResourcePacks().containsKey(packName)) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.not-found", "pack", packName)); return true; } String packPath = plugin.getConfig().getConfigurationSection("resource-packs").getString(packName); plugin.getPackManager().loadResourcePack(player, packName, packPath); return true; } @Override public List onTabComplete(CommandSender sender, Command command, String alias, String[] args) { List completions = new ArrayList<>(); if (args.length == 1 && sender.hasPermission("resourceloader.load")) { List packs = new ArrayList<>(plugin.getResourcePacks().keySet()); StringUtil.copyPartialMatches(args[0], packs, completions); } Collections.sort(completions); return completions; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/MergeCommand.java000066400000000000000000000106631503476774200311520ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.util.StringUtil; import org.vortex.resourceloader.Resourceloader; import org.vortex.resourceloader.ResourcePackMerger; import java.io.File; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; public class MergeCommand implements CommandExecutor, TabCompleter { private final Resourceloader plugin; private final AtomicBoolean isMerging; public MergeCommand(Resourceloader plugin) { this.plugin = plugin; this.isMerging = new AtomicBoolean(false); } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } if (args.length < 3) { sender.sendMessage(plugin.getMessageManager().getMessage("merge.invalid-usage")); return true; } if (isMerging.get()) { sender.sendMessage(plugin.getMessageManager().getMessage("merge.already-merging")); return true; } final String outputName = args[0].toLowerCase().endsWith(".zip") ? args[0] : args[0] + ".zip"; // Check if output pack already exists File outputFile = new File(plugin.getDataFolder(), "packs/" + outputName); if (outputFile.exists()) { sender.sendMessage(plugin.getMessageManager().formatMessage("merge.output-exists", "pack", outputName)); return true; } List packsToMerge = new ArrayList<>(); for (int i = 1; i < args.length; i++) { String packName = args[i]; File packFile = plugin.getResourcePacks().get(packName); if (packFile == null || !packFile.exists()) { sender.sendMessage(plugin.getMessageManager().formatMessage("merge.invalid-pack", "pack", packName)); return true; } packsToMerge.add(packFile); } if (packsToMerge.size() < 2) { sender.sendMessage(plugin.getMessageManager().getMessage("merge.no-packs")); return true; } isMerging.set(true); sender.sendMessage(plugin.getMessageManager().getMessage("merge.started")); plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> { try { ResourcePackMerger merger = new ResourcePackMerger(plugin); File result = merger.mergeResourcePacks(packsToMerge, outputName); plugin.getServer().getScheduler().runTask(plugin, () -> { if (result != null && result.exists()) { sender.sendMessage(plugin.getMessageManager().formatMessage("merge.success", "pack", outputName)); plugin.loadResourcePacks(true); } else { sender.sendMessage(plugin.getMessageManager().getMessage("merge.failed")); } isMerging.set(false); }); } catch (Exception e) { plugin.getServer().getScheduler().runTask(plugin, () -> { sender.sendMessage(plugin.getMessageManager().formatMessage("merge.failed", "error", e.getMessage())); isMerging.set(false); }); } }); return true; } @Override public List onTabComplete(CommandSender sender, Command command, String alias, String[] args) { List completions = new ArrayList<>(); if (!sender.hasPermission("resourceloader.admin")) { return completions; } if (args.length >= 2) { List packs = new ArrayList<>(plugin.getResourcePacks().keySet()); StringUtil.copyPartialMatches(args[args.length - 1], packs, completions); } Collections.sort(completions); return completions; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/MergeGUICommand.java000066400000000000000000000031361503476774200315140ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.ChatColor; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import org.vortex.resourceloader.Resourceloader; public class MergeGUICommand implements CommandExecutor { private final Resourceloader plugin; public MergeGUICommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { sender.sendMessage(ChatColor.RED + "This command can only be used by players."); return true; } if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(ChatColor.RED + "You don't have permission to use the resource pack merger."); return true; } if (args.length < 1) { sender.sendMessage(ChatColor.RED + "Usage: /mergegui "); return true; } String outputName = args[0]; if (!outputName.toLowerCase().endsWith(".zip")) { outputName += ".zip"; } if (!plugin.getConfig().getBoolean("gui.enabled", true)) { sender.sendMessage(ChatColor.RED + "The GUI feature is disabled in the configuration."); return true; } Player player = (Player) sender; plugin.getMergeGUI().openMergeGUI(player, outputName); return true; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/commands/RemovePackCommand.java000066400000000000000000000054031503476774200321430ustar00rootroot00000000000000package org.vortex.resourceloader.commands; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.util.StringUtil; import org.vortex.resourceloader.Resourceloader; import java.io.File; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class RemovePackCommand implements CommandExecutor, TabCompleter { private final Resourceloader plugin; public RemovePackCommand(Resourceloader plugin) { this.plugin = plugin; } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!sender.hasPermission("resourceloader.admin")) { sender.sendMessage(plugin.getMessageManager().getMessage("general.no-permission")); return true; } if (args.length != 1) { sender.sendMessage("§cUsage: /removepack "); return true; } String packName = args[0]; if (!plugin.getResourcePacks().containsKey(packName)) { sender.sendMessage("§cResource pack '" + packName + "' not found!"); return true; } File packFile = plugin.getResourcePacks().get(packName); if (packFile != null && packFile.exists()) { try { if (!packFile.delete()) { sender.sendMessage("§cFailed to remove resource pack '" + packName + "'!"); return true; } } catch (SecurityException e) { sender.sendMessage("§cFailed to remove resource pack '" + packName + "'!"); plugin.getLogger().warning("Failed to delete pack file: " + e.getMessage()); return true; } } // Remove from config plugin.getConfig().getConfigurationSection("resource-packs").set(packName, null); plugin.saveConfig(); // Remove from memory plugin.getResourcePacks().remove(packName); sender.sendMessage("§aSuccessfully removed resource pack '" + packName + "'!"); return true; } @Override public List onTabComplete(CommandSender sender, Command command, String alias, String[] args) { List completions = new ArrayList<>(); if (args.length == 1 && sender.hasPermission("resourceloader.admin")) { List packs = new ArrayList<>(plugin.getResourcePacks().keySet()); StringUtil.copyPartialMatches(args[0], packs, completions); } Collections.sort(completions); return completions; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/compression/000077500000000000000000000000001503476774200265035ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/compression/PackCompressor.java000066400000000000000000000230601503476774200323020ustar00rootroot00000000000000package org.vortex.resourceloader.compression; import org.bukkit.entity.Player; import org.vortex.resourceloader.Resourceloader; import java.io.*; import java.nio.file.*; import java.util.*; import java.util.concurrent.*; import java.util.logging.Logger; import java.util.zip.*; public class PackCompressor { private final Resourceloader plugin; private final Logger logger; private final Map> compressionCache; private final Path cacheDir; private final ExecutorService compressionExecutor; private static final int BUFFER_SIZE = 32768; // 32KB buffer private static final long MAX_PACK_SIZE = 100 * 1024 * 1024; // 100MB private static final int MAX_THREADS = 4; // Limit concurrent compression tasks private final Map> activeCompressions; public enum CompressionLevel { LOW(1), MEDIUM(6), HIGH(9); private final int level; CompressionLevel(int level) { this.level = level; } public int getLevel() { return level; } public static CompressionLevel fromString(String level) { try { return valueOf(level.toUpperCase()); } catch (IllegalArgumentException e) { return MEDIUM; } } } public PackCompressor(Resourceloader plugin) { this.plugin = plugin; this.logger = plugin.getLogger(); this.compressionCache = new ConcurrentHashMap<>(); this.cacheDir = plugin.getDataFolder().toPath().resolve("compression_cache"); this.compressionExecutor = new ThreadPoolExecutor( 2, MAX_THREADS, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy() ); this.activeCompressions = new ConcurrentHashMap<>(); initialize(); } private void initialize() { try { Files.createDirectories(cacheDir); cleanupOldCache(); } catch (IOException e) { logger.warning("Failed to initialize compression cache: " + e.getMessage()); } } public CompletableFuture getCompressedPack(File originalPack, CompressionLevel level) { if (!plugin.getConfig().getBoolean("compression.enabled", true)) { return CompletableFuture.completedFuture(originalPack); } // Validate file size if (originalPack.length() > MAX_PACK_SIZE) { logger.warning("Pack " + originalPack.getName() + " exceeds maximum size limit of " + (MAX_PACK_SIZE / 1024 / 1024) + "MB"); return CompletableFuture.completedFuture(originalPack); } String packName = originalPack.getName(); // Check if compression is already in progress CompletableFuture activeCompression = activeCompressions.get(packName); if (activeCompression != null && !activeCompression.isDone()) { return activeCompression; } Map packCache = compressionCache.computeIfAbsent( packName, key -> new ConcurrentHashMap<>() ); File cachedFile = packCache.get(level); if (cachedFile != null && cachedFile.exists() && cachedFile.lastModified() >= originalPack.lastModified()) { return CompletableFuture.completedFuture(cachedFile); } CompletableFuture future = CompletableFuture.supplyAsync(() -> { try { File compressedFile = compressPack(originalPack, level); packCache.put(level, compressedFile); return compressedFile; } catch (IOException e) { logger.warning("Failed to compress pack " + packName + ": " + e.getMessage()); return originalPack; } finally { activeCompressions.remove(packName); } }, compressionExecutor); activeCompressions.put(packName, future); return future; } private File compressPack(File originalPack, CompressionLevel level) throws IOException { String baseName = originalPack.getName().replaceFirst("[.][^.]+$", ""); File compressedFile = cacheDir.resolve( baseName + "_" + level.name().toLowerCase() + ".zip" ).toFile(); // Create temp file for safe compression File tempFile = new File(compressedFile.getParent(), compressedFile.getName() + ".tmp"); try (ZipFile sourceZip = new ZipFile(originalPack); ZipOutputStream zos = new ZipOutputStream( new BufferedOutputStream(new FileOutputStream(tempFile)))) { zos.setLevel(level.getLevel()); byte[] buffer = new byte[BUFFER_SIZE]; // Get total entries for progress tracking int totalEntries = Collections.list(sourceZip.entries()).size(); int processedEntries = 0; for (Enumeration entries = sourceZip.entries(); entries.hasMoreElements();) { ZipEntry entry = entries.nextElement(); ZipEntry newEntry = new ZipEntry(entry.getName()); // Preserve original entry metadata newEntry.setTime(entry.getTime()); newEntry.setComment(entry.getComment()); if (entry.getExtra() != null) { newEntry.setExtra(entry.getExtra()); } zos.putNextEntry(newEntry); if (!entry.isDirectory()) { try (InputStream in = new BufferedInputStream( sourceZip.getInputStream(entry), BUFFER_SIZE)) { int len; while ((len = in.read(buffer)) > 0) { zos.write(buffer, 0, len); } } } zos.closeEntry(); processedEntries++; if (processedEntries % 50 == 0 || processedEntries == totalEntries) { logger.info(String.format("Compressing %s: %d/%d entries (%.1f%%)", originalPack.getName(), processedEntries, totalEntries, (processedEntries * 100.0) / totalEntries)); } } } // Atomic rename of temp file to final file try { Files.move(tempFile.toPath(), compressedFile.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE); } catch (AtomicMoveNotSupportedException e) { // Fallback to non-atomic move if atomic is not supported Files.move(tempFile.toPath(), compressedFile.toPath(), StandardCopyOption.REPLACE_EXISTING); } return compressedFile; } public CompressionLevel getOptimalCompressionLevel(Player player) { if (!plugin.getConfig().getBoolean("compression.auto-select", true)) { String defaultLevel = plugin.getConfig().getString( "compression.default-level", "medium" ); return CompressionLevel.fromString(defaultLevel); } // Determine compression level based on player's ping and configured thresholds int ping = player.getPing(); int excellentThreshold = plugin.getConfig().getInt("compression.thresholds.excellent", 50); int goodThreshold = plugin.getConfig().getInt("compression.thresholds.good", 150); if (ping < excellentThreshold) { return CompressionLevel.LOW; } else if (ping < goodThreshold) { return CompressionLevel.MEDIUM; } else { return CompressionLevel.HIGH; } } private void cleanupOldCache() { try { int cacheDuration = plugin.getConfig().getInt("cache.expiry-days", 7); long expiryTime = System.currentTimeMillis() - (cacheDuration * 24 * 60 * 60 * 1000L); Files.walk(cacheDir) .filter(path -> Files.isRegularFile(path)) .forEach(path -> { try { if (Files.getLastModifiedTime(path).toMillis() < expiryTime) { Files.delete(path); logger.fine("Deleted expired cache file: " + path.getFileName()); } } catch (IOException e) { logger.warning("Failed to check/delete cached file: " + e.getMessage()); } }); } catch (IOException e) { logger.warning("Failed to clean compression cache: " + e.getMessage()); } } public void shutdown() { // Cancel any active compressions activeCompressions.values().forEach(future -> future.cancel(true)); activeCompressions.clear(); // Shutdown executor compressionExecutor.shutdown(); try { if (!compressionExecutor.awaitTermination(5, TimeUnit.SECONDS)) { compressionExecutor.shutdownNow(); } } catch (InterruptedException e) { compressionExecutor.shutdownNow(); Thread.currentThread().interrupt(); } } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/core/000077500000000000000000000000001503476774200250725ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/core/HashCacheManager.java000066400000000000000000000133211503476774200310370ustar00rootroot00000000000000package org.vortex.resourceloader.core; import org.vortex.resourceloader.Resourceloader; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Logger; /** * Manages SHA1 hash caching for resource packs to improve performance * by avoiding re-downloading unchanged packs. */ public class HashCacheManager { private final Logger logger; private final ConcurrentHashMap hashCache; public HashCacheManager(Resourceloader plugin) { this.logger = plugin.getLogger(); this.hashCache = new ConcurrentHashMap<>(); loadCache(); } /** * Calculate SHA1 hash for a file */ public String calculateSHA1(File file) { try { MessageDigest sha1 = MessageDigest.getInstance("SHA-1"); try (FileInputStream fis = new FileInputStream(file)) { byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = fis.read(buffer)) != -1) { sha1.update(buffer, 0, bytesRead); } } byte[] hashBytes = sha1.digest(); StringBuilder sb = new StringBuilder(); for (byte b : hashBytes) { sb.append(String.format("%02x", b)); } return sb.toString(); } catch (NoSuchAlgorithmException | IOException e) { logger.warning("Failed to calculate SHA1 hash for " + file.getName() + ": " + e.getMessage()); return null; } } /** * Get cached hash for a file, or calculate and cache it if not present */ public String getOrCalculateHash(File file) { String filePath = file.getAbsolutePath(); long lastModified = file.lastModified(); CachedHash cached = hashCache.get(filePath); if (cached != null && cached.lastModified == lastModified) { return cached.hash; } // Calculate new hash String hash = calculateSHA1(file); if (hash != null) { hashCache.put(filePath, new CachedHash(hash, lastModified)); saveCache(); } return hash; } /** * Check if two files have the same hash */ public boolean haveSameHash(File file1, File file2) { String hash1 = getOrCalculateHash(file1); String hash2 = getOrCalculateHash(file2); return hash1 != null && hash1.equals(hash2); } /** * Check if a remote pack URL has changed by comparing hashes */ public boolean hasUrlChanged(String url, String currentHash) { CachedHash cached = hashCache.get("url:" + url); return cached == null || !cached.hash.equals(currentHash); } /** * Cache hash for a URL-based pack */ public void cacheUrlHash(String url, String hash) { hashCache.put("url:" + url, new CachedHash(hash, System.currentTimeMillis())); saveCache(); } /** * Clear cache for a specific file or URL */ public void clearCache(String identifier) { hashCache.remove(identifier); saveCache(); } /** * Clear all cached hashes */ public void clearAllCache() { hashCache.clear(); saveCache(); logger.info("Hash cache cleared"); } /** * Clean up expired cache entries */ public void cleanupExpiredEntries() { long cutoffTime = System.currentTimeMillis() - (7 * 24 * 60 * 60 * 1000L); // 7 days final int[] removed = {0}; hashCache.entrySet().removeIf(entry -> { if (entry.getKey().startsWith("url:") && entry.getValue().lastModified < cutoffTime) { removed[0]++; return true; } return false; }); if (removed[0] > 0) { logger.info("Cleaned up " + removed[0] + " expired hash cache entries"); saveCache(); } } /** * Get cache statistics */ public CacheStats getStats() { int fileEntries = 0; int urlEntries = 0; for (String key : hashCache.keySet()) { if (key.startsWith("url:")) { urlEntries++; } else { fileEntries++; } } return new CacheStats(fileEntries, urlEntries); } private void loadCache() { // For now, just initialize empty cache // In a full implementation, this would load from JSON file hashCache.clear(); logger.info("Hash cache initialized"); } private void saveCache() { // For now, just log the save operation // In a full implementation, this would save to JSON file // We'll keep it simple since we already have a lot of functionality } /** * Represents a cached hash with timestamp */ private static class CachedHash { final String hash; final long lastModified; CachedHash(String hash, long lastModified) { this.hash = hash; this.lastModified = lastModified; } } /** * Cache statistics */ public static class CacheStats { public final int fileEntries; public final int urlEntries; CacheStats(int fileEntries, int urlEntries) { this.fileEntries = fileEntries; this.urlEntries = urlEntries; } public int getTotalEntries() { return fileEntries + urlEntries; } } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/core/ResourcePackCache.java000066400000000000000000000243131503476774200312520ustar00rootroot00000000000000package org.vortex.resourceloader.core; import org.bukkit.Bukkit; import org.bukkit.boss.BarColor; import org.bukkit.boss.BarStyle; import org.bukkit.boss.BossBar; import org.bukkit.entity.Player; import org.vortex.resourceloader.Resourceloader; import java.io.*; import java.net.URI; import java.net.HttpURLConnection; import java.nio.file.*; import java.security.MessageDigest; import java.util.HashMap; import java.util.Map; import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.logging.Logger; public class ResourcePackCache { private final Resourceloader plugin; private final Logger logger; private final Path cacheDir; private final Map etagCache; private final Map downloadBars; public ResourcePackCache(Resourceloader plugin) { this.plugin = plugin; this.logger = plugin.getLogger(); this.cacheDir = plugin.getDataFolder().toPath().resolve("cache"); this.etagCache = new HashMap<>(); this.downloadBars = new HashMap<>(); try { Files.createDirectories(cacheDir); cleanOldCache(); } catch (IOException e) { logger.warning("Failed to create cache directory: " + e.getMessage()); } } public CompletableFuture getCachedPack(String url, String packName) { return getCachedPack(url, packName, null); } public CompletableFuture getCachedPack(String url, String packName, Player player) { if (!plugin.getConfig().getBoolean("cache.enabled", true)) { return CompletableFuture.supplyAsync(() -> { try { Path tempFile = Files.createTempFile("resourcepack_", ".zip"); downloadPack(url, tempFile, player); return tempFile.toFile(); } catch (IOException e) { logger.warning("Failed to download resource pack " + packName + ": " + e.getMessage()); throw new RuntimeException(e); } }); } return CompletableFuture.supplyAsync(() -> { try { String cachedEtag = etagCache.get(url); Path cachePath = cacheDir.resolve(packName + "_" + getUrlHash(url) + ".zip"); if (Files.exists(cachePath)) { HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection(); conn.setRequestMethod("HEAD"); if (cachedEtag != null) { conn.setRequestProperty("If-None-Match", cachedEtag); } int responseCode = conn.getResponseCode(); if (responseCode == HttpURLConnection.HTTP_NOT_MODIFIED) { logger.info("Using cached version of " + packName); return cachePath.toFile(); } String newEtag = conn.getHeaderField("ETag"); if (newEtag != null && newEtag.equals(cachedEtag)) { return cachePath.toFile(); } } logger.info("Downloading and caching " + packName); downloadPack(url, cachePath, player); return cachePath.toFile(); } catch (IOException e) { logger.warning("Failed to cache resource pack " + packName + ": " + e.getMessage()); throw new RuntimeException("Failed to cache resource pack: " + e.getMessage(), e); } catch (Exception e) { logger.warning("Unexpected error while caching resource pack " + packName + ": " + e.getMessage()); throw new RuntimeException("Unexpected error while caching resource pack: " + e.getMessage(), e); } }); } private void downloadPack(String url, Path destination, Player player) throws IOException { HttpURLConnection conn = null; BossBar progressBar = null; try { conn = (HttpURLConnection) URI.create(url).toURL().openConnection(); conn.setRequestMethod("GET"); conn.setRequestProperty("User-Agent", "Resourceloader/2.1"); conn.setConnectTimeout(15000); conn.setReadTimeout(30000); int responseCode = conn.getResponseCode(); if (responseCode != HttpURLConnection.HTTP_OK) { throw new IOException("Failed to download resource pack. Server returned code: " + responseCode); } String etag = conn.getHeaderField("ETag"); if (etag != null) { etagCache.put(url, etag); } Files.createDirectories(destination.getParent()); long contentLength = conn.getContentLengthLong(); // Create progress bar if we have a player and know the content length if (player != null && contentLength > 0) { progressBar = createProgressBar(player); } try (InputStream in = new BufferedInputStream(conn.getInputStream()); OutputStream out = new BufferedOutputStream(Files.newOutputStream(destination))) { byte[] buffer = new byte[8192]; long totalBytesRead = 0; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); totalBytesRead += bytesRead; if (progressBar != null && contentLength > 0) { double progress = (double) totalBytesRead / contentLength; updateProgressBar(progressBar, progress); } } } } finally { if (conn != null) { conn.disconnect(); } if (progressBar != null) { removeProgressBar(progressBar); } } } private BossBar createProgressBar(Player player) { if (!Bukkit.isPrimaryThread()) { CompletableFuture future = new CompletableFuture<>(); Bukkit.getScheduler().runTask(plugin, () -> { BossBar bar = createProgressBarSync(player); future.complete(bar); }); try { return future.get(); } catch (Exception e) { return null; } } return createProgressBarSync(player); } private BossBar createProgressBarSync(Player player) { BossBar bar = Bukkit.createBossBar( "Downloading Resource Pack...", BarColor.BLUE, BarStyle.SOLID ); bar.setProgress(0.0); bar.addPlayer(player); downloadBars.put(player.getUniqueId(), bar); return bar; } private void updateProgressBar(BossBar bar, double progress) { if (!Bukkit.isPrimaryThread()) { Bukkit.getScheduler().runTask(plugin, () -> updateProgressBarSync(bar, progress)); return; } updateProgressBarSync(bar, progress); } private void updateProgressBarSync(BossBar bar, double progress) { bar.setProgress(Math.min(1.0, Math.max(0.0, progress))); bar.setTitle(String.format("Downloading Resource Pack... %.1f%%", progress * 100)); } private void removeProgressBar(BossBar bar) { if (!Bukkit.isPrimaryThread()) { Bukkit.getScheduler().runTask(plugin, () -> removeProgressBarSync(bar)); return; } removeProgressBarSync(bar); } private void removeProgressBarSync(BossBar bar) { bar.removeAll(); for (Player player : bar.getPlayers()) { downloadBars.remove(player.getUniqueId()); } } private String getUrlHash(String url) { try { MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] hash = digest.digest(url.getBytes()); StringBuilder hexString = new StringBuilder(); for (byte b : hash) { String hex = Integer.toHexString(0xff & b); if (hex.length() == 1) hexString.append('0'); hexString.append(hex); } return hexString.toString().substring(0, 8); } catch (Exception e) { return String.valueOf(url.hashCode()); } } private void cleanOldCache() { int expiryDays = plugin.getConfig().getInt("cache.expiry-days", 7); long expiryMillis = System.currentTimeMillis() - (expiryDays * 24 * 60 * 60 * 1000L); try { Files.walk(cacheDir) .filter(Files::isRegularFile) .forEach(file -> { try { if (Files.getLastModifiedTime(file).toMillis() < expiryMillis) { Files.delete(file); logger.info("Deleted expired cache file: " + file.getFileName()); } } catch (IOException e) { logger.warning("Failed to check/delete cache file: " + e.getMessage()); } }); } catch (IOException e) { logger.warning("Failed to clean cache directory: " + e.getMessage()); } } public void clearCache() { try { Files.walk(cacheDir) .filter(Files::isRegularFile) .forEach(file -> { try { Files.delete(file); } catch (IOException e) { logger.warning("Failed to delete cache file: " + file.getFileName()); } }); etagCache.clear(); logger.info("Resource pack cache cleared"); } catch (IOException e) { logger.warning("Failed to clear cache directory: " + e.getMessage()); } } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/core/ResourcePackManager.java000066400000000000000000000324371503476774200316270ustar00rootroot00000000000000package org.vortex.resourceloader.core; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.entity.Player; import org.vortex.resourceloader.Resourceloader; import org.vortex.resourceloader.util.FileUtil; import java.io.File; import java.util.Map; import java.util.HashMap; import java.util.logging.Logger; import java.util.UUID; import java.util.List; import java.util.ArrayList; import java.util.concurrent.ConcurrentHashMap; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardCopyOption; import org.bukkit.configuration.file.YamlConfiguration; public class ResourcePackManager { private final Resourceloader plugin; private final Logger logger; private final Map resourcePacks; private final ResourcePackCache packCache; private final ResourcePackServer packServer; private final ResourcePackWatcher packWatcher; private final Map> playerPreferences; private final Path preferencesFile; public ResourcePackManager(Resourceloader plugin) { this.plugin = plugin; this.logger = plugin.getLogger(); this.resourcePacks = new HashMap<>(); this.packCache = new ResourcePackCache(plugin); this.packServer = new ResourcePackServer(plugin); this.packWatcher = new ResourcePackWatcher(plugin, this); this.playerPreferences = new ConcurrentHashMap<>(); this.preferencesFile = plugin.getDataFolder().toPath().resolve("preferences.yml"); loadPreferences(); loadResourcePacks(true); packServer.start(); } private void loadPreferences() { if (!Files.exists(preferencesFile)) { return; } try { YamlConfiguration config = YamlConfiguration.loadConfiguration(preferencesFile.toFile()); for (String uuidStr : config.getKeys(false)) { UUID playerId = UUID.fromString(uuidStr); playerPreferences.put(playerId, config.getStringList(uuidStr)); } } catch (Exception e) { logger.warning("Failed to load player preferences: " + e.getMessage()); } } private void savePreferences() { try { YamlConfiguration config = new YamlConfiguration(); for (Map.Entry> entry : playerPreferences.entrySet()) { config.set(entry.getKey().toString(), entry.getValue()); } config.save(preferencesFile.toFile()); } catch (IOException e) { logger.warning("Failed to save player preferences: " + e.getMessage()); } } public List getPlayerPreferences(UUID playerId) { return playerPreferences.getOrDefault(playerId, new ArrayList<>()); } public void setPlayerPreference(UUID playerId, String packName) { List preferences = playerPreferences.computeIfAbsent(playerId, k -> new ArrayList<>()); preferences.remove(packName); preferences.add(0, packName); int maxPreferences = plugin.getConfig().getInt("statistics.max-preferences", 5); if (preferences.size() > maxPreferences) { preferences.subList(maxPreferences, preferences.size()).clear(); } savePreferences(); } public void clearPlayerPreferences(UUID playerId) { playerPreferences.remove(playerId); savePreferences(); } public void loadResourcePacks(boolean silent) { resourcePacks.clear(); File packDirectory = getResourcePackDirectory(); if (!packDirectory.exists()) { packDirectory.mkdirs(); } // Load default server pack String serverPack = plugin.getConfig().getString("server-pack"); if (serverPack != null && !serverPack.isEmpty()) { File serverPackFile = new File(packDirectory, serverPack); if (serverPackFile.exists()) { resourcePacks.put("server", serverPackFile); if (!silent) { logger.info("Loaded default server pack: " + serverPack); } } } // Load additional packs ConfigurationSection packs = plugin.getConfig().getConfigurationSection("resource-packs"); if (packs != null) { for (String key : packs.getKeys(false)) { String packPath = packs.getString(key); if (packPath != null && !packPath.startsWith("http")) { File packFile = new File(packDirectory, packPath); if (packFile.exists()) { resourcePacks.put(key, packFile); if (!silent) { logger.info("Loaded resource pack: " + key); } } else { logger.warning("Resource pack file not found: " + packPath); } } else if (packPath != null) { resourcePacks.put(key, null); if (!silent) { logger.info("Registered external resource pack URL: " + key); } } } } } public void loadResourcePack(Player player, String packName, String packPath) { if (packPath == null || packPath.isEmpty()) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.invalid-pack", "pack", packName)); return; } try { if (packPath.startsWith("http://") || packPath.startsWith("https://")) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.loading", "pack", packName)); packCache.getCachedPack(packPath, packName) .thenAccept(cachedFile -> { try { byte[] fileHash = FileUtil.calcSHA1(cachedFile); String downloadUrl = packServer.createDownloadURL(player, packName, cachedFile.getName()); player.setResourcePack(downloadUrl, fileHash); player.sendMessage(plugin.getMessageManager().getMessage("resource-packs.load-success")); } catch (Exception e) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.load-failed", "error", e.getMessage())); logger.warning("Failed to load cached pack: " + e.getMessage()); } }) .exceptionally(e -> { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.load-failed", "error", e.getMessage())); logger.warning("Failed to load pack: " + e.getMessage()); return null; }); } else { File packFile = resourcePacks.get(packName); if (packFile == null || !packFile.exists()) { player.sendMessage(plugin.getMessageManager().getMessage("resource-packs.invalid-pack")); return; } String finalUrl = packServer.createDownloadURL(player, packName, packPath); byte[] hash = FileUtil.calcSHA1(packFile); if (hash != null) { player.setResourcePack(finalUrl, hash); } else { player.setResourcePack(finalUrl); } player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.loading", "pack", packName)); } logger.info("Resource pack '" + packName + "' load attempted for player " + player.getName()); } catch (Exception e) { player.sendMessage(plugin.getMessageManager().formatMessage("resource-packs.load-failed", "error", e.getMessage())); logger.warning("Resource pack loading failed: " + e.getMessage()); } } private File getResourcePackDirectory() { String customPath = plugin.getConfig().getString("storage.resource-pack-directory", ""); if (!customPath.isEmpty()) { File customDir = new File(customPath); if (customDir.exists() || customDir.mkdirs()) { return customDir; } logger.warning("Failed to use custom resource pack directory: " + customPath); } return new File(plugin.getDataFolder(), "packs"); } public Map getResourcePacks() { return resourcePacks; } public ResourcePackCache getPackCache() { return packCache; } public ResourcePackServer getPackServer() { return packServer; } public void shutdown() { packServer.stop(); packWatcher.shutdown(); savePreferences(); } private String sanitizePackName(String packName) { // Remove file extension if present if (packName.toLowerCase().endsWith(".zip")) { packName = packName.substring(0, packName.length() - 4); } // First, convert to lowercase for consistency packName = packName.toLowerCase(); // Replace spaces, periods and special characters with underscores packName = packName.replaceAll("[\\s.]+", "_"); // Remove any other non-alphanumeric characters except underscores packName = packName.replaceAll("[^a-z0-9_]", ""); // Remove multiple consecutive underscores packName = packName.replaceAll("_+", "_"); // Remove leading and trailing underscores packName = packName.replaceAll("^_+|_+$", ""); // If name is empty after sanitization, use a default if (packName.isEmpty()) { packName = "resource_pack"; } return packName; } public void handleNewResourcePack(File packFile) { if (!packFile.getName().toLowerCase().endsWith(".zip")) { return; } // Reload config to avoid wiping unrelated sections plugin.reloadConfig(); String originalName = packFile.getName(); String sanitizedName = sanitizePackName(originalName); File packDirectory = getResourcePackDirectory(); File newFile = new File(packDirectory, sanitizedName + ".zip"); try { // Check if the file is already in the correct format if (packFile.getName().equals(sanitizedName + ".zip") && packFile.getParentFile().equals(packDirectory)) { newFile = packFile; } else { // Find a unique name if needed int counter = 1; while (newFile.exists()) { String nextName = sanitizedName + "_" + counter; if (!isPackNameInConfig(nextName)) { newFile = new File(packDirectory, nextName + ".zip"); break; } counter++; } Files.move(packFile.toPath(), newFile.toPath(), StandardCopyOption.REPLACE_EXISTING); } // Get or create the resource-packs section ConfigurationSection packs = plugin.getConfig().getConfigurationSection("resource-packs"); if (packs == null) { packs = plugin.getConfig().createSection("resource-packs"); } // Remove any old entry for the original file name String oldKey = null; for (String key : packs.getKeys(false)) { String value = packs.getString(key); if (value != null && value.equals(originalName)) { oldKey = key; break; } } if (oldKey != null) { packs.set(oldKey, null); resourcePacks.remove(oldKey); } // Generate a unique key for the config String configKey = getUniqueConfigKey(sanitizedName, packs); packs.set(configKey, newFile.getName()); resourcePacks.put(configKey, newFile); plugin.saveConfig(); logger.info("Added new resource pack: " + configKey + " (file: " + newFile.getName() + ")"); } catch (IOException e) { logger.warning("Failed to process new resource pack " + packFile.getName() + ": " + e.getMessage()); } } private boolean isPackNameInConfig(String name) { ConfigurationSection packs = plugin.getConfig().getConfigurationSection("resource-packs"); if (packs == null) { return false; } for (String key : packs.getKeys(false)) { String packPath = packs.getString(key); if (packPath != null && packPath.equals(name + ".zip")) { return true; } } return false; } private String getUniqueConfigKey(String baseName, ConfigurationSection packs) { String key = baseName; int counter = 1; while (packs.contains(key)) { key = baseName + "_" + counter; counter++; } return key; } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/core/ResourcePackServer.java000066400000000000000000000113471503476774200315200ustar00rootroot00000000000000package org.vortex.resourceloader.core; import com.sun.net.httpserver.HttpServer; import org.bukkit.entity.Player; import org.vortex.resourceloader.Resourceloader; import java.io.File; import java.io.IOException; import java.io.OutputStream; import java.net.InetSocketAddress; import java.nio.file.Files; import java.util.HashMap; import java.util.Map; import java.util.UUID; import java.util.logging.Logger; public class ResourcePackServer { private final Resourceloader plugin; private final Logger logger; private HttpServer server; private final Map playerTokens; public ResourcePackServer(Resourceloader plugin) { this.plugin = plugin; this.logger = plugin.getLogger(); this.playerTokens = new HashMap<>(); } public void start() { try { int port = plugin.getConfig().getInt("server-port", 40021); server = HttpServer.create(new InetSocketAddress(port), 0); // Secure endpoint for authenticated downloads server.createContext("/download", exchange -> { String query = exchange.getRequestURI().getQuery(); if (query == null || !query.contains("token=")) { exchange.sendResponseHeaders(403, -1); return; } String token = query.substring(query.indexOf("token=") + 6); String packPath = null; UUID playerId = null; for (Map.Entry entry : playerTokens.entrySet()) { if (entry.getValue().equals(token)) { playerId = entry.getKey(); break; } } if (playerId != null) { packPath = exchange.getRequestURI().getPath().substring("/download/".length()); playerTokens.remove(playerId); } if (packPath == null) { exchange.sendResponseHeaders(403, -1); return; } serveResourcePack(exchange, packPath); }); // Public endpoint for vanilla Minecraft client server.createContext("/public", exchange -> { if (!plugin.getConfig().getBoolean("enforcement.make-pack-public", false)) { exchange.sendResponseHeaders(403, -1); return; } String packPath = exchange.getRequestURI().getPath().substring("/public/".length()); serveResourcePack(exchange, packPath); }); server.setExecutor(null); server.start(); logger.info("Resource pack server started on port " + port); } catch (IOException e) { logger.severe("Failed to start resource pack server: " + e.getMessage()); } } private void serveResourcePack(com.sun.net.httpserver.HttpExchange exchange, String packPath) throws IOException { File packFile = new File(plugin.getDataFolder(), "packs/" + packPath); if (!packFile.exists()) { packFile = new File(plugin.getDataFolder(), "cache/" + packPath); } if (!packFile.exists()) { exchange.sendResponseHeaders(404, -1); return; } exchange.getResponseHeaders().set("Content-Type", "application/zip"); exchange.getResponseHeaders().set("Cache-Control", "public, max-age=31536000"); exchange.sendResponseHeaders(200, packFile.length()); try (OutputStream os = exchange.getResponseBody()) { Files.copy(packFile.toPath(), os); plugin.getLogger().info("Successfully served resource pack: " + packPath); } } public void stop() { if (server != null) { server.stop(0); logger.info("Resource pack server stopped"); } } public String createDownloadURL(Player player, String packName, String packPath) { String host = plugin.getConfig().getString("server-host", "localhost"); int port = plugin.getConfig().getInt("server-port", 40021); if (plugin.getConfig().getBoolean("enforcement.use-server-properties", false) && plugin.getConfig().getBoolean("enforcement.make-pack-public", false)) { return String.format("http://%s:%d/public/%s", host, port, packPath); } String token = UUID.randomUUID().toString(); playerTokens.put(player.getUniqueId(), token); return String.format("http://%s:%d/download/%s?token=%s", host, port, packPath, token); } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/core/ResourcePackWatcher.java000066400000000000000000000102771503476774200316500ustar00rootroot00000000000000package org.vortex.resourceloader.core; import org.vortex.resourceloader.Resourceloader; import java.io.File; import java.io.IOException; import java.nio.file.*; import java.util.Set; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Logger; public class ResourcePackWatcher { private final Resourceloader plugin; private final Logger logger; private final ResourcePackManager packManager; private WatchService watchService; private Thread watcherThread; private volatile boolean running = true; private final Set processingFiles = ConcurrentHashMap.newKeySet(); public ResourcePackWatcher(Resourceloader plugin, ResourcePackManager packManager) { this.plugin = plugin; this.logger = plugin.getLogger(); this.packManager = packManager; startWatcher(); } private void startWatcher() { try { watchService = FileSystems.getDefault().newWatchService(); File packsDir = new File(plugin.getDataFolder(), "packs"); if (!packsDir.exists()) { packsDir.mkdirs(); } Path packsPath = packsDir.toPath(); packsPath.register(watchService, StandardWatchEventKinds.ENTRY_CREATE); watcherThread = new Thread(() -> { while (running) { try { WatchKey key = watchService.take(); // Use a small delay to avoid duplicate events Thread.sleep(100); // Process all events at once List> events = key.pollEvents(); for (WatchEvent event : events) { if (event.kind() == StandardWatchEventKinds.ENTRY_CREATE) { Path newPath = ((Path) key.watchable()).resolve((Path) event.context()); File newFile = newPath.toFile(); if (newFile.getName().toLowerCase().endsWith(".zip") && processingFiles.add(newFile.getName())) { // Small delay to ensure file is fully written Thread.sleep(500); plugin.getServer().getScheduler().runTask(plugin, () -> { try { packManager.handleNewResourcePack(newFile); } finally { processingFiles.remove(newFile.getName()); } }); } } } key.reset(); } catch (InterruptedException e) { if (running) { logger.warning("Resource pack watcher interrupted"); } break; } catch (Exception e) { if (running) { logger.warning("Error in resource pack watcher: " + e.getMessage()); } } } }, "ResourcePackWatcher"); watcherThread.setDaemon(true); watcherThread.start(); } catch (IOException e) { logger.severe("Failed to start resource pack watcher: " + e.getMessage()); } } public void shutdown() { running = false; if (watcherThread != null) { watcherThread.interrupt(); } if (watchService != null) { try { watchService.close(); } catch (IOException e) { logger.warning("Error closing watch service: " + e.getMessage()); } } } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/gui/000077500000000000000000000000001503476774200247265ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/gui/MergeGUI.java000066400000000000000000000267011503476774200272030ustar00rootroot00000000000000package org.vortex.resourceloader.gui; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Material; import org.bukkit.Sound; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.inventory.InventoryClickEvent; import org.bukkit.event.inventory.InventoryCloseEvent; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; import org.vortex.resourceloader.Resourceloader; import java.io.File; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; public class MergeGUI implements Listener { private final Resourceloader plugin; private final Map> selectedPacks; private final Map outputNames; private final Set openInventories; private static final int MAX_PACKS = 45; // Maximum number of packs that can be displayed private static final Sound SELECT_SOUND = Sound.BLOCK_NOTE_BLOCK_PLING; private static final Sound ERROR_SOUND = Sound.BLOCK_NOTE_BLOCK_BASS; private static final Sound SUCCESS_SOUND = Sound.ENTITY_PLAYER_LEVELUP; public MergeGUI(Resourceloader plugin) { this.plugin = plugin; this.selectedPacks = new ConcurrentHashMap<>(); this.outputNames = new ConcurrentHashMap<>(); this.openInventories = ConcurrentHashMap.newKeySet(); plugin.getServer().getPluginManager().registerEvents(this, plugin); } public void openMergeGUI(Player player, String outputName) { // Validate output name if (!outputName.toLowerCase().endsWith(".zip")) { outputName += ".zip"; } // Get available packs and sort them List> availablePacks = plugin.getResourcePacks().entrySet().stream() .filter(entry -> entry.getValue() != null) .sorted(Map.Entry.comparingByKey()) .collect(Collectors.toList()); // Check if there are too many packs if (availablePacks.size() > MAX_PACKS) { player.sendMessage(ChatColor.RED + "Too many resource packs to display in GUI. Maximum: " + MAX_PACKS); return; } // Create inventory with appropriate size int size = Math.min(54, ((availablePacks.size() / 9) + 1) * 9 + 9); Inventory inv = Bukkit.createInventory(null, size, ChatColor.DARK_PURPLE + "Resource Pack Merger"); // Store player data outputNames.put(player.getUniqueId(), outputName); selectedPacks.put(player.getUniqueId(), new ArrayList<>()); openInventories.add(player.getUniqueId()); try { // Add available packs int slot = 0; for (Map.Entry entry : availablePacks) { ItemStack item = createPackItem(entry.getKey(), entry.getValue()); inv.setItem(slot++, item); } // Add control buttons at the bottom row int bottomRow = size - 9; inv.setItem(bottomRow + 0, createControlItem(Material.LIME_WOOL, "Merge Selected Packs", Arrays.asList("Click to merge the selected packs", "Output: " + outputName))); inv.setItem(bottomRow + 1, createControlItem(Material.YELLOW_WOOL, "Preview Merge", Collections.singletonList("Click to preview the merged pack"))); inv.setItem(bottomRow + 8, createControlItem(Material.RED_WOOL, "Cancel", Collections.singletonList("Click to cancel merging"))); player.openInventory(inv); } catch (Exception e) { plugin.getLogger().warning("Failed to create merge GUI: " + e.getMessage()); player.sendMessage(ChatColor.RED + "Failed to open merge GUI. Please try again."); cleanup(player.getUniqueId()); } } private ItemStack createPackItem(String name, File file) { ItemStack item = new ItemStack(Material.BOOK); ItemMeta meta = item.getItemMeta(); if (meta != null) { meta.setDisplayName(ChatColor.GOLD + name); List lore = new ArrayList<>(); lore.add(ChatColor.GRAY + "File: " + file.getName()); lore.add(ChatColor.GRAY + "Size: " + formatFileSize(file.length())); lore.add(""); lore.add(ChatColor.YELLOW + "Click to select/deselect"); meta.setLore(lore); item.setItemMeta(meta); } return item; } private String formatFileSize(long bytes) { if (bytes < 1024) return bytes + " B"; if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0); return String.format("%.1f MB", bytes / (1024.0 * 1024.0)); } private ItemStack createControlItem(Material material, String name, List lore) { ItemStack item = new ItemStack(material); ItemMeta meta = item.getItemMeta(); if (meta != null) { meta.setDisplayName(ChatColor.GOLD + name); List coloredLore = new ArrayList<>(); for (String line : lore) { coloredLore.add(ChatColor.GRAY + line); } meta.setLore(coloredLore); item.setItemMeta(meta); } return item; } @EventHandler public void onInventoryClick(InventoryClickEvent event) { if (!(event.getWhoClicked() instanceof Player player)) return; if (!openInventories.contains(player.getUniqueId())) return; if (!event.getView().getTitle().equals(ChatColor.DARK_PURPLE + "Resource Pack Merger")) return; event.setCancelled(true); ItemStack clicked = event.getCurrentItem(); if (clicked == null || !clicked.hasItemMeta() || clicked.getItemMeta() == null) return; List selectedList = selectedPacks.get(player.getUniqueId()); String outputName = outputNames.get(player.getUniqueId()); if (clicked.getType() == Material.BOOK || clicked.getType() == Material.ENCHANTED_BOOK) { handlePackSelection(player, event, clicked, selectedList); } else if (clicked.getType() == Material.LIME_WOOL) { handleMergeAction(player, selectedList, outputName); } else if (clicked.getType() == Material.YELLOW_WOOL) { handlePreviewAction(player, selectedList); } else if (clicked.getType() == Material.RED_WOOL) { player.closeInventory(); player.sendMessage(ChatColor.RED + "Merge operation cancelled."); player.playSound(player.getLocation(), Sound.UI_BUTTON_CLICK, 1.0f, 1.0f); } } private void handlePackSelection(Player player, InventoryClickEvent event, ItemStack clicked, List selectedList) { String packName = ChatColor.stripColor(clicked.getItemMeta().getDisplayName()); if (selectedList.contains(packName)) { selectedList.remove(packName); clicked.setType(Material.BOOK); player.playSound(player.getLocation(), SELECT_SOUND, 1.0f, 0.8f); } else { selectedList.add(packName); clicked.setType(Material.ENCHANTED_BOOK); player.playSound(player.getLocation(), SELECT_SOUND, 1.0f, 1.2f); } event.getInventory().setItem(event.getSlot(), clicked); // Update item lore with selection status ItemMeta meta = clicked.getItemMeta(); List lore = meta.getLore(); lore.set(lore.size() - 1, ChatColor.YELLOW + (selectedList.contains(packName) ? "✓ Selected" : "Click to select/deselect")); meta.setLore(lore); clicked.setItemMeta(meta); } private void handleMergeAction(Player player, List selectedList, String outputName) { if (selectedList.size() < 2) { player.sendMessage(ChatColor.RED + "Please select at least 2 packs to merge!"); player.playSound(player.getLocation(), ERROR_SOUND, 1.0f, 0.8f); return; } player.closeInventory(); player.playSound(player.getLocation(), SUCCESS_SOUND, 1.0f, 1.0f); executeMerge(player, selectedList, outputName); } private void handlePreviewAction(Player player, List selectedList) { if (selectedList.size() < 2) { player.sendMessage(ChatColor.RED + "Please select at least 2 packs to preview!"); player.playSound(player.getLocation(), ERROR_SOUND, 1.0f, 0.8f); return; } player.playSound(player.getLocation(), SELECT_SOUND, 1.0f, 1.0f); previewMerge(player, selectedList); } @EventHandler public void onInventoryClose(InventoryCloseEvent event) { if (!(event.getPlayer() instanceof Player player)) return; cleanup(player.getUniqueId()); } private void cleanup(UUID playerId) { openInventories.remove(playerId); selectedPacks.remove(playerId); outputNames.remove(playerId); } private void executeMerge(Player player, List packs, String outputName) { try { List packFiles = new ArrayList<>(); for (String packName : packs) { File packFile = plugin.getResourcePacks().get(packName); if (packFile != null && packFile.exists()) { packFiles.add(packFile); } } if (packFiles.size() < 2) { player.sendMessage(ChatColor.RED + "Error: Not enough valid packs selected!"); player.playSound(player.getLocation(), ERROR_SOUND, 1.0f, 0.8f); return; } player.sendMessage(ChatColor.YELLOW + "Merging " + packFiles.size() + " resource packs..."); plugin.getServer().dispatchCommand(player, "mergepack " + outputName + " " + String.join(" ", packs)); } catch (Exception e) { plugin.getLogger().warning("Failed to execute merge: " + e.getMessage()); player.sendMessage(ChatColor.RED + "Failed to merge packs. Please try again."); player.playSound(player.getLocation(), ERROR_SOUND, 1.0f, 0.8f); } } private void previewMerge(Player player, List packs) { try { player.sendMessage(ChatColor.YELLOW + "Selected packs to merge:"); long totalSize = 0; for (String pack : packs) { File packFile = plugin.getResourcePacks().get(pack); if (packFile != null && packFile.exists()) { long size = packFile.length(); totalSize += size; player.sendMessage(ChatColor.GRAY + "- " + pack + " (" + formatFileSize(size) + ")"); } } player.sendMessage(ChatColor.YELLOW + "Total size: " + formatFileSize(totalSize)); player.sendMessage(ChatColor.YELLOW + "Use the merge button to combine these packs."); } catch (Exception e) { plugin.getLogger().warning("Failed to preview merge: " + e.getMessage()); player.sendMessage(ChatColor.RED + "Failed to generate preview. Please try again."); player.playSound(player.getLocation(), ERROR_SOUND, 1.0f, 0.8f); } } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/listeners/000077500000000000000000000000001503476774200261525ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/listeners/EarlyPackLoader.java000066400000000000000000000210171503476774200320200ustar00rootroot00000000000000package org.vortex.resourceloader.listeners; import org.vortex.resourceloader.Resourceloader; import org.vortex.resourceloader.util.FileUtil; import java.io.*; import java.nio.charset.StandardCharsets; import java.nio.file.*; import java.util.ArrayList; import java.util.List; import java.util.Properties; public class EarlyPackLoader { private final Resourceloader plugin; private final Path serverPropertiesPath; private String originalResourcePack; private String originalResourcePackSha1; private String originalResourcePackPrompt; private boolean originalResourcePackRequired; private boolean useServerProperties; public EarlyPackLoader(Resourceloader plugin) { this.plugin = plugin; this.serverPropertiesPath = plugin.getServer().getWorldContainer().toPath().resolve("server.properties"); this.useServerProperties = plugin.getConfig().getBoolean("enforcement.use-server-properties", false); if (useServerProperties) { loadOriginalSettings(); updateServerProperties(); } } private void loadOriginalSettings() { try { Properties properties = new Properties(); try (InputStream input = Files.newInputStream(serverPropertiesPath)) { properties.load(input); } // Store original values originalResourcePack = properties.getProperty("resource-pack", ""); originalResourcePackSha1 = properties.getProperty("resource-pack-sha1", ""); originalResourcePackPrompt = properties.getProperty("resource-pack-prompt", ""); originalResourcePackRequired = Boolean.parseBoolean(properties.getProperty("require-resource-pack", "false")); } catch (IOException e) { plugin.getLogger().warning("Failed to load server.properties: " + e.getMessage()); } } private void updateServerProperties() { if (!plugin.getConfig().getBoolean("enforcement.enabled", false)) { // If enforcement is disabled and we previously set a pack, restore original settings if (isOurResourcePack()) { restoreOriginalSettings(); } return; } String serverPack = plugin.getConfig().getString("server-pack"); if (serverPack == null || serverPack.isEmpty()) { return; } try { Properties properties = new Properties(); try (InputStream input = Files.newInputStream(serverPropertiesPath)) { properties.load(input); } // Prepare the new values String packUrl; String packSha1 = ""; if (serverPack.startsWith("http")) { packUrl = serverPack; } else { File packFile = new File(plugin.getDataFolder(), "packs/" + serverPack); if (!packFile.exists()) { plugin.getLogger().warning("Resource pack file not found: " + serverPack); return; } if (plugin.getConfig().getBoolean("enforcement.make-pack-public", false)) { // Create a public URL without authentication String host = plugin.getConfig().getString("server-host", "localhost"); int port = plugin.getConfig().getInt("server-port", 40021); packUrl = String.format("http://%s:%d/public/%s", host, port, serverPack); // We need to modify our ResourcePackServer to handle public URLs plugin.getLogger().info("Using public URL for resource pack: " + packUrl); } else { plugin.getLogger().warning("Cannot use local file with server.properties unless make-pack-public is enabled"); return; } // Calculate SHA1 for local files try { byte[] hash = FileUtil.calcSHA1(packFile); if (hash != null) { packSha1 = bytesToHex(hash); } } catch (Exception e) { plugin.getLogger().warning("Failed to calculate pack hash: " + e.getMessage()); } } // Update properties properties.setProperty("resource-pack", packUrl); if (!packSha1.isEmpty()) { properties.setProperty("resource-pack-sha1", packSha1); } properties.setProperty("require-resource-pack", String.valueOf(plugin.getConfig().getBoolean("enforce.kick-on-decline", true))); // Save properties while preserving comments List lines = new ArrayList<>(); try (BufferedReader reader = Files.newBufferedReader(serverPropertiesPath)) { String line; while ((line = reader.readLine()) != null) { if (line.startsWith("resource-pack=")) { line = "resource-pack=" + packUrl; } else if (line.startsWith("resource-pack-sha1=")) { line = "resource-pack-sha1=" + packSha1; } else if (line.startsWith("require-resource-pack=")) { line = "require-resource-pack=" + properties.getProperty("require-resource-pack"); } lines.add(line); } } // Write back the file Files.write(serverPropertiesPath, lines, StandardCharsets.UTF_8); plugin.getLogger().info("Updated server.properties with resource pack settings"); } catch (IOException e) { plugin.getLogger().severe("Failed to update server.properties: " + e.getMessage()); } } private boolean isOurResourcePack() { if (!useServerProperties) { return false; } try { Properties properties = new Properties(); try (InputStream input = Files.newInputStream(serverPropertiesPath)) { properties.load(input); } String currentPack = properties.getProperty("resource-pack", ""); String serverPack = plugin.getConfig().getString("server-pack", ""); return currentPack.contains(serverPack) || (serverPack.startsWith("http") && currentPack.equals(serverPack)) || (!serverPack.startsWith("http") && currentPack.endsWith(serverPack)); } catch (IOException e) { return false; } } private void restoreOriginalSettings() { if (!useServerProperties) { return; } try { List lines = new ArrayList<>(); try (BufferedReader reader = Files.newBufferedReader(serverPropertiesPath)) { String line; while ((line = reader.readLine()) != null) { if (line.startsWith("resource-pack=")) { line = "resource-pack=" + originalResourcePack; } else if (line.startsWith("resource-pack-sha1=")) { line = "resource-pack-sha1=" + originalResourcePackSha1; } else if (line.startsWith("resource-pack-prompt=")) { line = "resource-pack-prompt=" + originalResourcePackPrompt; } else if (line.startsWith("require-resource-pack=")) { line = "require-resource-pack=" + originalResourcePackRequired; } lines.add(line); } } Files.write(serverPropertiesPath, lines, StandardCharsets.UTF_8); plugin.getLogger().info("Restored original resource pack settings in server.properties"); } catch (IOException e) { plugin.getLogger().severe("Failed to restore server.properties: " + e.getMessage()); } } private static String bytesToHex(byte[] hash) { StringBuilder hexString = new StringBuilder(); for (byte b : hash) { String hex = Integer.toHexString(0xff & b); if (hex.length() == 1) hexString.append('0'); hexString.append(hex); } return hexString.toString(); } public void cleanup() { if (useServerProperties && isOurResourcePack()) { restoreOriginalSettings(); } } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/listeners/ResourcePackEnforcer.java000066400000000000000000000245001503476774200330700ustar00rootroot00000000000000package org.vortex.resourceloader.listeners; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.event.player.PlayerResourcePackStatusEvent; import org.bukkit.event.server.PluginDisableEvent; import org.bukkit.scheduler.BukkitTask; import org.vortex.resourceloader.Resourceloader; import org.vortex.resourceloader.util.FileUtil; import java.io.File; import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; public class ResourcePackEnforcer implements Listener { private final Resourceloader plugin; private final Map retryAttempts; private final Map pendingRetries; private final Set restrictedPlayers; private final Map packLoading; private static final String[] RESTRICTED_COMMANDS = { "tp", "teleport", "spawn", "home", "warp", "tpa", "sethome", "setwarp", "back", "return" }; public ResourcePackEnforcer(Resourceloader plugin) { this.plugin = plugin; this.retryAttempts = new ConcurrentHashMap<>(); this.pendingRetries = new ConcurrentHashMap<>(); this.restrictedPlayers = ConcurrentHashMap.newKeySet(); this.packLoading = new ConcurrentHashMap<>(); // Register additional events plugin.getServer().getPluginManager().registerEvents(new RestrictedModeHandler(), plugin); } @EventHandler(priority = EventPriority.MONITOR) public void onPlayerJoin(PlayerJoinEvent event) { Player player = event.getPlayer(); if (player.hasPermission("resourceloader.bypass")) { plugin.getLogger().info("Player " + player.getName() + " has bypass permission, skipping pack loading"); return; } // Priority 1: Check for autoload preference first List preferences = plugin.getPackManager().getPlayerPreferences(player.getUniqueId()); if (!preferences.isEmpty()) { String preferredPack = preferences.get(0); plugin.getLogger().info("Loading autoload preference '" + preferredPack + "' for player " + player.getName()); tryLoadPack(player, preferredPack, true); return; } // Priority 2: Fall back to enforcement if no autoload preference if (plugin.getConfig().getBoolean("enforcement.enabled", false)) { String serverPack = plugin.getConfig().getString("server-pack"); if (serverPack != null && !serverPack.isEmpty()) { plugin.getLogger().info("Loading enforced server pack for player " + player.getName()); tryLoadPack(player, "server", false); return; } } plugin.getLogger().info("No autoload preference or enforcement configured for player " + player.getName()); } private void tryLoadPack(Player player, String packName, boolean isAutoload) { try { String packPath; if (packName.equals("server")) { packPath = plugin.getConfig().getString("server-pack"); if (packPath == null || packPath.isEmpty()) { plugin.getLogger().warning("Server pack is not configured but enforcement is enabled"); return; } } else { ConfigurationSection packs = plugin.getConfig().getConfigurationSection("resource-packs"); if (packs == null) { plugin.getLogger().warning("No resource packs configured for autoload pack: " + packName); return; } packPath = packs.getString(packName); if (packPath == null || packPath.isEmpty()) { plugin.getLogger().warning("Pack '" + packName + "' not found in configuration for player " + player.getName()); return; } } String logPrefix = isAutoload ? "Autoload" : "Enforcement"; plugin.getLogger().info(logPrefix + ": Attempting to load pack '" + packName + "' for player " + player.getName()); if (packPath.startsWith("http")) { plugin.getLogger().info(logPrefix + ": Loading URL-based pack from " + packPath); plugin.getPackManager().getPackCache().getCachedPack(packPath, packName, player) .thenAccept(cachedFile -> { if (!player.isOnline()) return; try { byte[] hash = FileUtil.calcSHA1(cachedFile); String downloadUrl = plugin.getPackManager().getPackServer() .createDownloadURL(player, packName, cachedFile.getName()); plugin.getServer().getScheduler().runTask(plugin, () -> { if (player.isOnline()) { if (hash != null) { player.setResourcePack(downloadUrl, hash); plugin.getLogger().info(logPrefix + ": Successfully sent pack '" + packName + "' to " + player.getName()); } else { player.setResourcePack(downloadUrl); plugin.getLogger().info(logPrefix + ": Successfully sent pack '" + packName + "' to " + player.getName() + " (no hash)"); } } }); } catch (Exception e) { plugin.getLogger().warning(logPrefix + ": Failed to load pack '" + packName + "' for " + player.getName() + ": " + e.getMessage()); } }) .exceptionally(e -> { plugin.getLogger().warning(logPrefix + ": Failed to cache pack '" + packName + "' for " + player.getName() + ": " + e.getMessage()); return null; }); } else { File packFile = new File(plugin.getDataFolder(), "packs/" + packPath); if (packFile.exists()) { plugin.getLogger().info(logPrefix + ": Loading local pack file: " + packFile.getName()); String downloadUrl = plugin.getPackManager().getPackServer() .createDownloadURL(player, packName, packPath); byte[] hash = FileUtil.calcSHA1(packFile); if (hash != null) { player.setResourcePack(downloadUrl, hash); plugin.getLogger().info(logPrefix + ": Successfully sent local pack '" + packName + "' to " + player.getName()); } else { player.setResourcePack(downloadUrl); plugin.getLogger().info(logPrefix + ": Successfully sent local pack '" + packName + "' to " + player.getName() + " (no hash)"); } } else { plugin.getLogger().warning(logPrefix + ": Pack file not found: " + packFile.getAbsolutePath()); } } } catch (Exception e) { String logPrefix = isAutoload ? "Autoload" : "Enforcement"; plugin.getLogger().warning(logPrefix + ": Failed to load pack '" + packName + "' for " + player.getName() + ": " + e.getMessage()); } } @EventHandler(priority = EventPriority.HIGH) public void onResourcePackStatus(PlayerResourcePackStatusEvent event) { Player player = event.getPlayer(); if (player.hasPermission("resourceloader.bypass")) { return; } switch (event.getStatus()) { case DECLINED: if (plugin.getConfig().getBoolean("enforce.kick-on-decline", true)) { player.kickPlayer(plugin.getMessageManager().getMessage("enforcement.declined")); } break; case FAILED_DOWNLOAD: if (plugin.getConfig().getBoolean("enforce.kick-on-fail", true)) { player.kickPlayer(plugin.getMessageManager().getMessage("enforcement.failed")); } break; default: break; } } private void cleanup(UUID playerId) { retryAttempts.remove(playerId); BukkitTask task = pendingRetries.remove(playerId); if (task != null) { task.cancel(); } restrictedPlayers.remove(playerId); packLoading.remove(playerId); } @EventHandler public void onPlayerQuit(PlayerQuitEvent event) { cleanup(event.getPlayer().getUniqueId()); } @EventHandler public void onPluginDisable(PluginDisableEvent event) { if (event.getPlugin() == plugin) { for (UUID playerId : pendingRetries.keySet()) { cleanup(playerId); } } } private class RestrictedModeHandler implements Listener { @EventHandler public void onPlayerCommand(org.bukkit.event.player.PlayerCommandPreprocessEvent event) { if (restrictedPlayers.contains(event.getPlayer().getUniqueId())) { String command = event.getMessage().substring(1).split(" ")[0].toLowerCase(); for (String restricted : RESTRICTED_COMMANDS) { if (command.equals(restricted)) { event.setCancelled(true); event.getPlayer().sendMessage(plugin.getMessageManager() .getMessage("enforcement.restricted-command")); return; } } } } @EventHandler public void onPlayerInteract(org.bukkit.event.player.PlayerInteractEvent event) { if (restrictedPlayers.contains(event.getPlayer().getUniqueId()) && plugin.getConfig().getBoolean("enforcement.restrict.prevent-interaction", true)) { event.setCancelled(true); } } } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/management/000077500000000000000000000000001503476774200262565ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/management/PackManager.java000066400000000000000000000275231503476774200313030ustar00rootroot00000000000000package org.vortex.resourceloader.management; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Player; import org.vortex.resourceloader.Resourceloader; import java.io.*; import java.nio.file.*; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.*; import java.util.concurrent.*; import java.util.logging.Logger; import java.util.zip.*; public class PackManager { private final Resourceloader plugin; private final Logger logger; private final Path backupDir; private final ScheduledExecutorService scheduler; private final Map packStats; private final Map> playerPreferences; private final Path statsFile; private final Path preferencesFile; private static final int DEFAULT_BACKUP_INTERVAL = 24; private static final int DEFAULT_MAX_PREFERENCES = 5; private static final int SHUTDOWN_TIMEOUT = 5; private volatile boolean isShutdown = false; public PackManager(Resourceloader plugin) { this.plugin = plugin; this.logger = plugin.getLogger(); this.backupDir = plugin.getDataFolder().toPath().resolve("backups"); this.statsFile = plugin.getDataFolder().toPath().resolve("statistics.yml"); this.preferencesFile = plugin.getDataFolder().toPath().resolve("preferences.yml"); this.scheduler = Executors.newScheduledThreadPool(1, r -> { Thread t = new Thread(r, "PackManager-Scheduler"); t.setDaemon(true); return t; }); this.packStats = new ConcurrentHashMap<>(); this.playerPreferences = new ConcurrentHashMap<>(); initialize(); } private void initialize() { try { Files.createDirectories(backupDir); loadStatistics(); loadPreferences(); setupBackupSchedule(); } catch (IOException e) { logger.severe("Failed to initialize pack manager: " + e.getMessage()); logger.severe("Some functionality may be limited. Please check file permissions and disk space."); } } public void createBackup() { if (isShutdown) { logger.warning("Attempted to create backup after shutdown"); return; } String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss")); Path backupFile = backupDir.resolve("backup_" + timestamp + ".zip"); Path tempFile = backupFile.resolveSibling(backupFile.getFileName().toString() + ".tmp"); try { Path packsDir = plugin.getDataFolder().toPath().resolve("packs"); if (!Files.exists(packsDir)) { logger.warning("Packs directory does not exist, skipping backup"); return; } try (ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream( Files.newOutputStream(tempFile), 8192))) { Files.walk(packsDir) .filter(path -> !Files.isDirectory(path)) .forEach(path -> { try { String zipPath = packsDir.relativize(path).toString(); zos.putNextEntry(new ZipEntry(zipPath)); Files.copy(path, zos); zos.closeEntry(); } catch (IOException e) { logger.warning("Failed to backup file " + path + ": " + e.getMessage()); } }); } // Atomic move of temp file to final backup file Files.move(tempFile, backupFile, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); cleanOldBackups(); logger.info("Created backup: " + backupFile.getFileName()); } catch (IOException e) { logger.severe("Failed to create backup: " + e.getMessage()); try { Files.deleteIfExists(tempFile); } catch (IOException ex) { logger.warning("Failed to cleanup temporary backup file: " + ex.getMessage()); } } } private void cleanOldBackups() { try { int keepCount = Math.max(1, plugin.getConfig().getInt("backup.keep-count", 5)); List backups = new ArrayList<>(); Files.list(backupDir) .filter(path -> path.toString().endsWith(".zip")) .sorted((a, b) -> b.getFileName().toString().compareTo(a.getFileName().toString())) .forEach(backups::add); if (backups.size() > keepCount) { for (int i = keepCount; i < backups.size(); i++) { try { Files.delete(backups.get(i)); } catch (IOException e) { logger.warning("Failed to delete old backup " + backups.get(i) + ": " + e.getMessage()); } } } } catch (IOException e) { logger.warning("Failed to clean old backups: " + e.getMessage()); } } private void setupBackupSchedule() { if (!plugin.getConfig().getBoolean("backup.enabled", true)) { return; } int interval = Math.max(1, plugin.getConfig().getInt("backup.interval-hours", DEFAULT_BACKUP_INTERVAL)); scheduler.scheduleAtFixedRate(this::createBackup, 1, interval, TimeUnit.HOURS); } public void recordPackUsage(String packName, Player player, boolean success, long loadTime) { if (isShutdown || !plugin.getConfig().getBoolean("statistics.enabled", true)) { return; } if (packName == null || packName.isEmpty()) { logger.warning("Attempted to record usage for null or empty pack name"); return; } PackStatistics stats = packStats.computeIfAbsent(packName, key -> new PackStatistics()); stats.recordUsage(success, loadTime); if (success && plugin.getConfig().getBoolean("statistics.save-preferences", true)) { recordPlayerPreference(player.getUniqueId(), packName); } saveStatistics(); } private void recordPlayerPreference(UUID playerId, String packName) { if (playerId == null || packName == null || packName.isEmpty()) { return; } List preferences = playerPreferences.computeIfAbsent(playerId, key -> new ArrayList<>()); preferences.remove(packName); preferences.add(0, packName); int maxPreferences = Math.max(1, plugin.getConfig().getInt("statistics.max-preferences", DEFAULT_MAX_PREFERENCES)); if (preferences.size() > maxPreferences) { preferences.subList(maxPreferences, preferences.size()).clear(); } savePreferences(); } public List getPlayerPreferences(UUID playerId) { if (playerId == null) { return Collections.emptyList(); } return new ArrayList<>(playerPreferences.getOrDefault(playerId, new ArrayList<>())); } private void loadStatistics() { if (!Files.exists(statsFile)) { return; } try { YamlConfiguration config = YamlConfiguration.loadConfiguration(statsFile.toFile()); for (String packName : config.getKeys(false)) { if (packName != null && !packName.isEmpty()) { PackStatistics stats = new PackStatistics(); stats.loadFromConfig(config.getConfigurationSection(packName)); packStats.put(packName, stats); } } } catch (Exception e) { logger.severe("Failed to load statistics: " + e.getMessage()); // Create backup of corrupted file try { Files.copy(statsFile, statsFile.resolveSibling("statistics.yml.bak"), StandardCopyOption.REPLACE_EXISTING); } catch (IOException ex) { logger.severe("Failed to backup corrupted statistics file: " + ex.getMessage()); } } } private void saveStatistics() { if (isShutdown) return; try { Path tempFile = statsFile.resolveSibling("statistics.yml.tmp"); YamlConfiguration config = new YamlConfiguration(); for (Map.Entry entry : packStats.entrySet()) { if (entry.getKey() != null && entry.getValue() != null) { entry.getValue().saveToConfig(config.createSection(entry.getKey())); } } config.save(tempFile.toFile()); Files.move(tempFile, statsFile, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { logger.severe("Failed to save statistics: " + e.getMessage()); } } private void loadPreferences() { if (!Files.exists(preferencesFile)) { return; } try { YamlConfiguration config = YamlConfiguration.loadConfiguration(preferencesFile.toFile()); for (String uuidStr : config.getKeys(false)) { try { UUID playerId = UUID.fromString(uuidStr); List prefs = config.getStringList(uuidStr); if (!prefs.isEmpty()) { playerPreferences.put(playerId, new ArrayList<>(prefs)); } } catch (IllegalArgumentException e) { logger.warning("Invalid UUID in preferences file: " + uuidStr); } } } catch (Exception e) { logger.severe("Failed to load preferences: " + e.getMessage()); try { Files.copy(preferencesFile, preferencesFile.resolveSibling("preferences.yml.bak"), StandardCopyOption.REPLACE_EXISTING); } catch (IOException ex) { logger.severe("Failed to backup corrupted preferences file: " + ex.getMessage()); } } } private void savePreferences() { if (isShutdown) return; try { Path tempFile = preferencesFile.resolveSibling("preferences.yml.tmp"); YamlConfiguration config = new YamlConfiguration(); for (Map.Entry> entry : playerPreferences.entrySet()) { if (entry.getKey() != null && !entry.getValue().isEmpty()) { config.set(entry.getKey().toString(), entry.getValue()); } } config.save(tempFile.toFile()); Files.move(tempFile, preferencesFile, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { logger.severe("Failed to save preferences: " + e.getMessage()); } } public void shutdown() { isShutdown = true; scheduler.shutdown(); try { if (!scheduler.awaitTermination(SHUTDOWN_TIMEOUT, TimeUnit.SECONDS)) { scheduler.shutdownNow(); } } catch (InterruptedException e) { scheduler.shutdownNow(); Thread.currentThread().interrupt(); } // Final save of data saveStatistics(); savePreferences(); } public Map getPackStats() { return Collections.unmodifiableMap(packStats); } public boolean isShutdown() { return isShutdown; } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/management/PackStatistics.java000066400000000000000000000047461503476774200320650ustar00rootroot00000000000000package org.vortex.resourceloader.management; import org.bukkit.configuration.ConfigurationSection; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; public class PackStatistics { private final AtomicInteger totalDownloads; private final AtomicInteger successfulDownloads; private final AtomicInteger failedDownloads; private final AtomicLong totalLoadTime; private final AtomicLong lastUsed; public PackStatistics() { this.totalDownloads = new AtomicInteger(0); this.successfulDownloads = new AtomicInteger(0); this.failedDownloads = new AtomicInteger(0); this.totalLoadTime = new AtomicLong(0); this.lastUsed = new AtomicLong(System.currentTimeMillis()); } public void recordUsage(boolean success, long loadTime) { totalDownloads.incrementAndGet(); if (success) { successfulDownloads.incrementAndGet(); totalLoadTime.addAndGet(loadTime); } else { failedDownloads.incrementAndGet(); } lastUsed.set(System.currentTimeMillis()); } public void loadFromConfig(ConfigurationSection config) { if (config == null) return; totalDownloads.set(config.getInt("total_downloads", 0)); successfulDownloads.set(config.getInt("successful_downloads", 0)); failedDownloads.set(config.getInt("failed_downloads", 0)); totalLoadTime.set(config.getLong("total_load_time", 0)); lastUsed.set(config.getLong("last_used", System.currentTimeMillis())); } public void saveToConfig(ConfigurationSection config) { config.set("total_downloads", totalDownloads.get()); config.set("successful_downloads", successfulDownloads.get()); config.set("failed_downloads", failedDownloads.get()); config.set("total_load_time", totalLoadTime.get()); config.set("last_used", lastUsed.get()); } public int getTotalDownloads() { return totalDownloads.get(); } public int getSuccessfulDownloads() { return successfulDownloads.get(); } public int getFailedDownloads() { return failedDownloads.get(); } public long getAverageLoadTime() { int successful = successfulDownloads.get(); return successful > 0 ? totalLoadTime.get() / successful : 0; } public long getLastUsed() { return lastUsed.get(); } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/util/000077500000000000000000000000001503476774200251175ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/util/FileUtil.java000066400000000000000000000124761503476774200275110ustar00rootroot00000000000000// FileUtil.java package org.vortex.resourceloader.util; import java.io.*; import java.nio.file.*; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.stream.Stream; import java.util.zip.*; import java.util.logging.Logger; public class FileUtil { private static final int BUFFER_SIZE = 8192; private static final String TEMP_PREFIX = "resourceloader_"; private static final String TEMP_SUFFIX = ".tmp"; public static byte[] calcSHA1(File file) throws IOException { if (file == null || !file.exists()) { throw new FileNotFoundException("File does not exist"); } try { MessageDigest digest = MessageDigest.getInstance("SHA-1"); try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file), BUFFER_SIZE)) { byte[] buffer = new byte[BUFFER_SIZE]; int read; while ((read = bis.read(buffer)) != -1) { digest.update(buffer, 0, read); } } return digest.digest(); } catch (NoSuchAlgorithmException e) { throw new IOException("SHA-1 algorithm not available", e); } } public static void validateZipFile(File file) throws IOException { if (file == null || !file.exists()) { throw new FileNotFoundException("File does not exist"); } try (ZipFile zipFile = new ZipFile(file)) { if (zipFile.size() == 0) { throw new IOException("ZIP file is empty"); } } catch (ZipException e) { throw new IOException("Invalid ZIP file format", e); } } public static long getFolderSize(Path folder) throws IOException { if (!Files.isDirectory(folder)) { throw new IllegalArgumentException("Path is not a directory: " + folder); } try (Stream walk = Files.walk(folder)) { return walk.filter(Files::isRegularFile) .mapToLong(p -> { try { return Files.size(p); } catch (IOException e) { return 0L; } }) .sum(); } } public static void safeMove(Path source, Path target) throws IOException { if (!Files.exists(source)) { throw new FileNotFoundException("Source file does not exist: " + source); } Path tempFile = null; try { // Create parent directories if they don't exist Files.createDirectories(target.getParent()); // Create temp file in the same directory as target tempFile = Files.createTempFile( target.getParent(), TEMP_PREFIX, TEMP_SUFFIX ); // Copy to temp file Files.copy(source, tempFile, StandardCopyOption.REPLACE_EXISTING); // Atomic move from temp to target try { Files.move(tempFile, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); } catch (AtomicMoveNotSupportedException e) { // Fallback to non-atomic move if atomic is not supported Files.move(tempFile, target, StandardCopyOption.REPLACE_EXISTING); } } finally { // Clean up temp file if it still exists if (tempFile != null) { try { Files.deleteIfExists(tempFile); } catch (IOException e) { // Log but don't throw - this is cleanup code Logger.getLogger(FileUtil.class.getName()) .warning("Failed to delete temporary file: " + tempFile); } } } } public static void cleanDirectory(Path directory) throws IOException { if (!Files.isDirectory(directory)) { throw new IllegalArgumentException("Path is not a directory: " + directory); } try (Stream walk = Files.walk(directory)) { walk.sorted((a, b) -> b.toString().length() - a.toString().length()) // Delete children first .forEach(path -> { try { Files.delete(path); } catch (IOException e) { // Log but continue with other files Logger.getLogger(FileUtil.class.getName()) .warning("Failed to delete: " + path); } }); } } public static String getFileExtension(String filename) { if (filename == null || filename.lastIndexOf(".") == -1) { return ""; } return filename.substring(filename.lastIndexOf(".") + 1); } public static boolean isValidResourcePack(File file) { if (file == null || !file.exists() || !file.isFile()) { return false; } String extension = getFileExtension(file.getName()).toLowerCase(); if (!extension.equals("zip")) { return false; } try { validateZipFile(file); return true; } catch (IOException e) { return false; } } }Resourceloader-2.2/src/main/java/org/vortex/resourceloader/util/MessageManager.java000066400000000000000000000137231503476774200306470ustar00rootroot00000000000000package org.vortex.resourceloader.util; import org.bukkit.ChatColor; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; import org.vortex.resourceloader.Resourceloader; import java.io.*; import java.nio.charset.StandardCharsets; import java.nio.file.*; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.regex.Pattern; public class MessageManager { private final Resourceloader plugin; private FileConfiguration messages; private String prefix; private final Map messageCache; private static final String DEFAULT_PREFIX = "&7[&6ResourceLoader&7] &r"; private static final Pattern PLACEHOLDER_PATTERN = Pattern.compile("%([^%]+)%"); private static final String DEFAULT_MESSAGES_FILE = "messages.yml"; private Path messagesFile; public MessageManager(Resourceloader plugin) { this.plugin = plugin; this.messageCache = new ConcurrentHashMap<>(); loadMessages(); } public void loadMessages() { try { messagesFile = plugin.getDataFolder().toPath().resolve(DEFAULT_MESSAGES_FILE); // Create messages file if it doesn't exist if (!Files.exists(messagesFile)) { Files.createDirectories(messagesFile.getParent()); plugin.saveResource(DEFAULT_MESSAGES_FILE, false); } // Load messages from file messages = YamlConfiguration.loadConfiguration(messagesFile.toFile()); messageCache.clear(); // Load default messages for missing keys try (InputStream defaultStream = plugin.getResource(DEFAULT_MESSAGES_FILE)) { if (defaultStream != null) { YamlConfiguration defaultMessages = YamlConfiguration.loadConfiguration( new InputStreamReader(defaultStream, StandardCharsets.UTF_8) ); messages.setDefaults(defaultMessages); messages.options().copyDefaults(true); // Save if defaults were copied if (messages.getDefaults() != null && !messages.getDefaults().getKeys(true).isEmpty()) { messages.save(messagesFile.toFile()); } } } // Load prefix with fallback prefix = formatMessage(messages.getString("prefix", DEFAULT_PREFIX)); } catch (IOException e) { plugin.getLogger().severe("Failed to load messages: " + e.getMessage()); plugin.getLogger().severe("Using default messages only"); messages = new YamlConfiguration(); prefix = formatMessage(DEFAULT_PREFIX); } } public String getMessage(String path) { return getMessage(path, true); } public String getMessage(String path, boolean addPrefix) { if (path == null || path.isEmpty()) { return ""; } String cacheKey = addPrefix ? path + "_prefixed" : path; return messageCache.computeIfAbsent(cacheKey, k -> { String message = messages.getString(path, ""); String formattedMessage = formatMessage(message); return addPrefix ? prefix + formattedMessage : formattedMessage; }); } public String getMessageNoPrefix(String path) { return getMessage(path, false); } public String formatMessage(String message) { if (message == null) { return ""; } return ChatColor.translateAlternateColorCodes('&', message); } public String formatMessage(String message, Map placeholders) { if (message == null) { return ""; } if (placeholders == null || placeholders.isEmpty()) { return formatMessage(message); } StringBuilder result = new StringBuilder(message); PLACEHOLDER_PATTERN.matcher(message).results().forEach(matchResult -> { String placeholder = matchResult.group(1); String value = placeholders.get(placeholder); if (value != null) { int start = matchResult.start(); int end = matchResult.end(); result.replace(start, end, value); } }); return formatMessage(result.toString()); } public String formatMessage(String path, Object... args) { if (args == null || args.length % 2 != 0) { return getMessage(path); } String message = getMessageNoPrefix(path); Map placeholders = new HashMap<>(); for (int i = 0; i < args.length; i += 2) { if (args[i] != null && args[i + 1] != null) { placeholders.put(args[i].toString(), args[i + 1].toString()); } } return prefix + formatMessage(message, placeholders); } public void reloadMessages() { loadMessages(); } public Set getMessageKeys() { return messages.getKeys(true); } public void setPrefix(String newPrefix) { if (newPrefix != null) { this.prefix = formatMessage(newPrefix); messageCache.clear(); // Clear cache since prefix affects prefixed messages } } public String getPrefix() { return prefix; } public boolean hasMessage(String path) { return messages.contains(path); } public void setMessage(String path, String message) throws IOException { if (path != null && message != null) { messages.set(path, message); messageCache.remove(path); messageCache.remove(path + "_prefixed"); messages.save(messagesFile.toFile()); } } } Resourceloader-2.2/src/main/java/org/vortex/resourceloader/validation/000077500000000000000000000000001503476774200262745ustar00rootroot00000000000000Resourceloader-2.2/src/main/java/org/vortex/resourceloader/validation/PackValidator.java000066400000000000000000000162321503476774200316670ustar00rootroot00000000000000package org.vortex.resourceloader.validation; import com.fasterxml.jackson.databind.ObjectMapper; import org.vortex.resourceloader.Resourceloader; import java.io.File; import java.io.IOException; import java.util.*; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; public class PackValidator { private final ObjectMapper mapper; private final List issues; public PackValidator(Resourceloader plugin) { this.mapper = new ObjectMapper(); this.issues = new ArrayList<>(); } public ValidationResult validate(File packFile) { issues.clear(); boolean isCritical = false; try { if (!packFile.exists()) { addIssue("Pack file does not exist", true); return new ValidationResult(false, issues); } if (!packFile.getName().toLowerCase().endsWith(".zip")) { addIssue("Pack file must be a ZIP file", true); return new ValidationResult(false, issues); } try (ZipFile zip = new ZipFile(packFile)) { // Check pack.mcmeta ZipEntry mcmetaEntry = zip.getEntry("pack.mcmeta"); if (mcmetaEntry == null) { addIssue("Missing pack.mcmeta file", true); isCritical = true; } else { validateMcMeta(zip, mcmetaEntry); } // Check assets directory boolean hasAssets = false; Enumeration entries = zip.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); if (entry.getName().startsWith("assets/")) { hasAssets = true; break; } } if (!hasAssets) { addIssue("Missing assets directory", true); isCritical = true; } // Validate JSON files Map> textureReferences = new HashMap<>(); entries = zip.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); if (entry.getName().endsWith(".json")) { validateJsonFile(zip, entry, textureReferences); } } // Validate texture references validateTextureReferences(zip, textureReferences); // Check for unnecessary files entries = zip.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); String name = entry.getName().toLowerCase(); if (name.contains("__macosx") || name.contains(".ds_store")) { addIssue("Contains unnecessary system files: " + entry.getName(), false); } } } catch (IOException e) { addIssue("Failed to read ZIP file: " + e.getMessage(), true); isCritical = true; } } catch (Exception e) { addIssue("Unexpected error during validation: " + e.getMessage(), true); isCritical = true; } return new ValidationResult(!isCritical, issues); } private void validateMcMeta(ZipFile zip, ZipEntry entry) { try { @SuppressWarnings("unchecked") Map mcmeta = mapper.readValue(zip.getInputStream(entry), Map.class); if (!mcmeta.containsKey("pack")) { addIssue("pack.mcmeta is missing 'pack' section", true); return; } @SuppressWarnings("unchecked") Map pack = (Map) mcmeta.get("pack"); if (!pack.containsKey("pack_format")) { addIssue("pack.mcmeta is missing 'pack_format'", true); } if (!pack.containsKey("description")) { addIssue("pack.mcmeta is missing 'description'", false); } } catch (IOException e) { addIssue("Invalid pack.mcmeta JSON: " + e.getMessage(), true); } } private void validateJsonFile(ZipFile zip, ZipEntry entry, Map> textureReferences) { try { @SuppressWarnings("unchecked") Map json = mapper.readValue(zip.getInputStream(entry), Map.class); // Collect texture references from models if (entry.getName().contains("/models/")) { if (json.containsKey("textures")) { Set textures = new HashSet<>(); @SuppressWarnings("unchecked") Map textureMap = (Map) json.get("textures"); textureMap.values().forEach(tex -> { if (!tex.startsWith("#")) { textures.add(tex); } }); if (!textures.isEmpty()) { textureReferences.put(entry.getName(), textures); } } } } catch (IOException e) { addIssue("Invalid JSON in " + entry.getName() + ": " + e.getMessage(), false); } } private void validateTextureReferences(ZipFile zip, Map> textureReferences) { textureReferences.forEach((model, textures) -> { textures.forEach(texture -> { String texturePath = "assets/minecraft/textures/" + texture + ".png"; if (zip.getEntry(texturePath) == null) { addIssue("Missing texture '" + texture + "' referenced in " + model, false); } }); }); } private void addIssue(String message, boolean critical) { issues.add(new ValidationIssue(message, critical)); } public record ValidationResult(boolean isValid, List issues) { public List getFormattedIssues() { List formatted = new ArrayList<>(); formatted.add("Validation Results:"); List criticalIssues = issues.stream() .filter(ValidationIssue::isCritical) .toList(); List warnings = issues.stream() .filter(i -> !i.isCritical()) .toList(); if (!criticalIssues.isEmpty()) { formatted.add("Critical Issues:"); criticalIssues.forEach(i -> formatted.add("- " + i.message())); } if (!warnings.isEmpty()) { formatted.add("Warnings:"); warnings.forEach(i -> formatted.add("- " + i.message())); } if (issues.isEmpty()) { formatted.add("No issues found!"); } return formatted; } } public record ValidationIssue(String message, boolean isCritical) {} } Resourceloader-2.2/src/main/resources/000077500000000000000000000000001503476774200200775ustar00rootroot00000000000000Resourceloader-2.2/src/main/resources/config.yml000066400000000000000000000064341503476774200220760ustar00rootroot00000000000000# ResourceLoader Configuration # For detailed documentation, visit: https://github.com/DefectiveVortex/Resourceloader #====================# # Resource Packs # #====================# # The default server resource pack that will be loaded when using /load without arguments # Examples: # Local file: "server-pack.zip" # URL: "https://example.com/server-pack.zip" server-pack: "" # Individual resource pack definitions # Format: # packname: "filename.zip" # For local files # packname: "https://..." # For external URLs resource-packs: # example1: "pack1.zip" # example2: "https://example.com/pack2.zip" # Storage configuration storage: # Custom directory for resource packs (absolute path) # Leave empty to use plugins/ResourceLoader/packs/ resource-pack-directory: "" # Automatic resource pack detection auto-detection: true #====================# # Server Settings # #====================# # Web server configuration for serving resource packs server: # The port to serve resource packs on (default: 40021) port: 40021 # Network settings (advanced) localhost: false # Set to true only for local testing address: "" # Leave empty for auto-detection fallback: localhost # Used if auto-detection fails #====================# # Performance # #====================# # Resource pack compression settings compression: # Enable compression of resource packs enabled: true # Compression level selection auto-select: true # Choose compression based on player's connection default-level: "medium" # Used when auto-select is false # Options: "low", "medium", "high" # Cache settings for downloaded resource packs cache: enabled: true expiry-days: 7 # How long to keep cached packs auto-cleanup: true # Automatically remove expired cache entries #====================# # Pack Management # #====================# # Backup configuration backup: enabled: true interval-hours: 24 # Hours between automatic backups keep-count: 5 # Number of backup files to retain # Usage statistics and player preferences statistics: enabled: true # Track pack usage and performance save-preferences: true # Remember player's last used packs max-preferences: 5 # Number of packs to remember per player #====================# # User Interface # #====================# # GUI settings for the pack merger gui: enabled: true show-preview: true # Show pack preview before merging conflict-handling: "ask" # How to handle conflicts: "ask", "overwrite", "skip" #====================# # Enforcement # #====================# # Resource pack enforcement settings # (Bypassed by default for server operators through 'resourceloader.bypass') enforcement: enabled: false kick-on-decline: true kick-on-fail: true restrict: prevent-interaction: true # Whether to use vanilla Minecraft's resource pack system by modifying server.properties # WARNING: This will override any existing resource pack settings in server.properties use-server-properties: false # If true, will create a public URL for the pack that doesn't require authentication # Only used when use-server-properties is true and a local file is used make-pack-public: false Resourceloader-2.2/src/main/resources/messages.yml000066400000000000000000000107521503476774200224360ustar00rootroot00000000000000# ResourceLoader Messages Configuration # Use & for color codes (e.g., &a for green, &c for red) # Use %player% for player name # Use %pack% for resource pack name # Use %size% for file sizes # Use %current% and %total% for progress numbers prefix: "&7[&eResourceLoader&7] &r" general: no-permission: "&cYou don't have permission to use this command." reload-success: "&aConfiguration reloaded successfully!" reload-failed: "&cFailed to reload configuration: %error%" invalid-pack: "&cResource pack '%pack%' not found!" players-only: "&cThis command can only be used by players." help: header: "&6=== ResourceLoader Help ===" load: "&e/load [pack] &7- Load a resource pack" load-specific: "&e/load &7- Load a specific resource pack" list: "&e/packlist &7- List available resource packs" admin-header: "&6=== Admin Commands ===" merge: "&e/mergepack &7- Merge resource packs" remove: "&e/removepack &7- Remove a resource pack" reload: "&e/resourcereload &7- Reload configuration" version: "&e/resourceversion &7- Check plugin version" cache: "&e/clearcache &7- Clear resource pack cache" footer: "&6==========================" resource-packs: loading: "&eLoading resource pack %pack%..." load-success: "&aResource pack loaded successfully!" load-failed: "&cFailed to load resource pack: %error%" download-started: "&eDownloading resource pack..." download-success: "&aResource pack downloaded, applying..." download-failed: "&cFailed to download resource pack. Please try again." invalid-url: "&cInvalid resource pack URL. Please contact an administrator." already-loading: "&cAlready loading a resource pack, please wait..." no-default: "&cNo default resource pack configured." not-found: "&cResource pack '%pack%' not found." file-not-found: "&cResource pack file not found." invalid-path: "&cInvalid path for resource pack '%pack%'." list: header: "&6=== Available Resource Packs ===" no-packs: "&7No resource packs available." default-pack: "&7Default Pack: &f%type%" pack-entry: "&7• &f%pack%" footer: "&6===========================" autoload: no-preference: "&eYou don't have a preferred resource pack set." current-preference: "&eYour current preferred pack is: &6%pack%" set: "&aSet &6%pack% &aas your preferred resource pack." set-failed: "&cFailed to apply resource pack &6%pack%&c: %error%" cleared: "&aCleared your resource pack preferences." loaded: "&aAutomatically loaded your preferred pack: &6%pack%" merge: started: "&7Starting to merge resource packs..." progress: "&7Merging pack &e%current%&7/&e%total%" success: "&aSuccessfully merged resource packs into: &e%pack%" failed: "&cFailed to merge resource packs: %error%" already-merging: "&cA merge operation is already in progress. Please wait." invalid-usage: "&cUsage: /mergepack [pack3...]" no-packs: "&cYou must specify at least two packs to merge!" invalid-pack: "&cResource pack '%pack%' not found!" output-exists: "&cA resource pack with name '%pack%' already exists!" cache: cleared: "&aResource pack cache has been cleared!" using-cached: "&7Using cached version of %pack%" downloading-new: "&7Downloading new version of %pack%" updates: available: "&eA new version is available! Current: &c%current%&e, Latest: &a%latest%" check-command: "&eUse &f/resourceversion check &efor more information." checking: "&eChecking for updates..." current-version: "&eCurrent version: &f%version%" latest-version: "&eLatest version: &f%version%" up-to-date: "&aYou are running the latest version!" check-failed: "&cFailed to check for updates." gui: title: "Resource Pack Merger" preview-title: "Pack Preview: %pack%" select-packs: "&eSelect packs to merge" conflict-detected: "&eConflict detected in: %file%" resolve-prompt: "&eHow would you like to resolve this conflict?" loading-preview: "&ePreparing preview..." backup: created: "&aCreated backup: %file%" failed: "&cFailed to create backup: %error%" cleaned: "&7Cleaned up old backup: %file%" statistics: recorded: "&7Recorded usage of pack: %pack%" preference-saved: "&7Saved pack preference for %player%" enforcement: declined: "&cYou must accept the resource pack to play on this server!" failed: "&cFailed to download the resource pack. Please try joining again!" retry: "&eRetrying resource pack download in %seconds% seconds..." Resourceloader-2.2/src/main/resources/plugin.yml000066400000000000000000000047601503476774200221270ustar00rootroot00000000000000name: Resourceloader version: '${project.version}' main: org.vortex.resourceloader.Resourceloader api-version: '1.13' author: DefectiveVortex description: A plugin for managing and merging Minecraft resource packs website: https://github.com/DefectiveVortex/Resourceloader commands: load: description: Load a resource pack usage: /load [pack] aliases: [resourceload] permission: resourceloader.load packlist: description: List available resource packs usage: /packlist aliases: [listpacks, resourcepacks] permission: resourceloader.list mergepack: description: Merge multiple resource packs usage: /mergepack [pack2...] aliases: [merge] permission: resourceloader.admin mergegui: description: Open the resource pack merge GUI usage: /mergegui aliases: [guimerge] permission: resourceloader.admin removepack: description: Remove a resource pack usage: /removepack aliases: [resourceremove] permission: resourceloader.admin checkpack: description: Validate a resource pack structure and content usage: /checkpack aliases: [validatepack, packcheck] permission: resourceloader.admin resourcereload: description: Reload the plugin configuration usage: /resourcereload aliases: [rreload] permission: resourceloader.admin clearcache: description: Clear the resource pack cache usage: /clearcache aliases: [cacheclear] permission: resourceloader.admin resourceversion: description: Check plugin version usage: /resourceversion aliases: [rversion] permission: resourceloader.admin autoload: description: Set your preferred resource pack usage: /autoload permission: resourceloader.autoload resourcehelp: description: Show plugin help usage: /resourcehelp aliases: [rhelp] permissions: resourceloader.load: description: Allows loading resource packs default: true resourceloader.list: description: Allows listing available resource packs default: true resourceloader.autoload: description: Allows setting resource pack for automatic loading default: true resourceloader.admin: description: Allows access to all admin commands default: op children: resourceloader.load: true resourceloader.list: true resourceloader.autoload: true resourceloader.bypass: description: Allows bypassing resource pack enforcement default: op