Initial commit

Plugins/Snowfall/.gitignore

@@ -0,0 +1,113 @@
+# User-specific stuff
+.idea/
+
+*.iml
+*.ipr
+*.iws
+
+# IntelliJ
+out/
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+target/
+
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+.flattened-pom.xml
+
+# Common working directory
+run/

Plugins/Snowfall/pom.xml

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>de.craftix</groupId>
+    <artifactId>Snowfall</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+
+    <name>Snowfall</name>
+
+    <properties>
+        <java.version>1.8</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.1</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.4</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>spigot-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
+        </repository>
+
+        <repository>
+            <id>dmulloy2-repo</id>
+            <url>https://repo.dmulloy2.net/repository/public/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot</artifactId>
+            <version>1.18-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.comphenix.protocol</groupId>
+            <artifactId>ProtocolLib</artifactId>
+            <version>4.7.0</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>

Plugins/Snowfall/src/main/java/de/craftix/snowfall/Snowfall.java

@@ -0,0 +1,43 @@
+package de.craftix.snowfall;
+
+import com.comphenix.protocol.ProtocolLibrary;
+import de.craftix.snowfall.commands.*;
+import de.craftix.snowfall.utils.DBHandler;
+import de.craftix.snowfall.utils.PacketListener;
+import de.craftix.snowfall.utils.StarterpackHandler;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class Snowfall extends JavaPlugin {
+    private static Snowfall plugin;
+    private DBHandler handler;
+    private TabCompletion tabCompletion;
+
+    public void onEnable() {
+        plugin = this;
+        handler = new DBHandler();
+        tabCompletion = new TabCompletion();
+        getCommand("togglesnow").setExecutor(new ToggleSnowCmd(handler));
+        getCommand("togglesnow").setTabCompleter(tabCompletion);
+        getCommand("setsnowmode").setExecutor(new SetSnowModeCmd(handler));
+        getCommand("setsnowmode").setTabCompleter(tabCompletion);
+        new StarterpackHandler(handler);
+
+        ProtocolLibrary.getProtocolManager().addPacketListener(new PacketListener());
+
+        SnowCmd snowCmd = new SnowCmd();
+        getCommand("snow").setExecutor(snowCmd);
+        Bukkit.getPluginManager().registerEvents(snowCmd, this);
+    }
+
+    @Override
+    public void onDisable() {
+        handler.deactivate();
+        ProtocolLibrary.getProtocolManager().removePacketListeners(this);
+    }
+
+    public static Snowfall getPlugin() {
+        return plugin;
+    }
+
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/commands/SetSnowModeCmd.java

@@ -0,0 +1,42 @@
+package de.craftix.snowfall.commands;
+
+import de.craftix.snowfall.utils.DBHandler;
+import de.craftix.snowfall.utils.FlakesHandler;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class SetSnowModeCmd implements CommandExecutor {
+    private final DBHandler handler;
+
+    public SetSnowModeCmd(DBHandler handler) { this.handler = handler; }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) sender.sendMessage("§cDieser Command kann nur als spieler ausgeführt werden!");
+        else if (args.length > 1) return false;
+        else {
+            try {
+                Player p = (Player) sender;
+
+                if (args.length == 0) {
+                    p.sendMessage("§7Aktueller Modus: '§a" + FlakesHandler.SnowModes.getByMode(handler.getMode(p.getUniqueId())).getName() + "§7'");
+                    return true;
+                }
+
+                FlakesHandler.SnowModes mode = FlakesHandler.getSnowModeByName(args[0]);
+
+                if (mode != null) {
+                    handler.setMode(p.getUniqueId(), mode.getMode());
+                    FlakesHandler.refreshPlayerData();
+                    p.sendMessage("§7Du hast den Modus '§a" + mode.getName() + "§7' aktiviert");
+                }else {
+                    p.sendMessage("§cDieser Modus existiert nicht!");
+                    return true;
+                }
+            }catch (Exception ignored) {}
+        }
+        return true;
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/commands/SnowCmd.java

@@ -0,0 +1,90 @@
+package de.craftix.snowfall.commands;
+
+import com.comphenix.protocol.PacketType;
+import de.craftix.snowfall.utils.FlakesHandler;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+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.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+public class SnowCmd implements CommandExecutor, Listener {
+    private static final int INV_SIZE = 9*5;
+    private static final String INV_NAME = "Scheepartikel - Einstellungen";
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) sender.sendMessage("§cDieser Command kann nur als spieler ausgeführt werden!");
+        else openGui((Player) sender);
+        return true;
+    }
+
+    private void openGui(Player player) {
+        Inventory inv = Bukkit.createInventory(null, INV_SIZE, INV_NAME);
+
+        //Placeholders
+        ItemStack placeholder = createItem(Material.GRAY_STAINED_GLASS_PANE, " ");
+        for (int i = 0; i < INV_SIZE; i++) {
+            inv.setItem(i, placeholder);
+        }
+
+        ItemStack enable = createItem(Material.GREEN_STAINED_GLASS_PANE, "§aScheeflocken einschalten");
+        ItemStack disable = createItem(Material.RED_STAINED_GLASS_PANE, "§cScheeflocken ausschalten");
+
+        ItemStack always = createItem(Material.CLOCK, "§aModus: " + FlakesHandler.SnowModes.ALWAYS.getName());
+        ItemStack onlyClear = createItem(Material.SUNFLOWER, "§aModus: " + FlakesHandler.SnowModes.ONLY_CLEAR_WEATHER.getName());
+        ItemStack snowBiome = createItem(Material.SNOWBALL, "§aModus: " + FlakesHandler.SnowModes.ONLY_NIGHT_OR_SNOWBIOME.getName());
+
+        inv.setItem(12, enable);
+        inv.setItem(14, disable);
+
+        inv.setItem(29, always);
+        inv.setItem(31, onlyClear);
+        inv.setItem(33, snowBiome);
+
+        player.openInventory(inv);
+    }
+
+    private ItemStack createItem(Material material, String name) {
+        ItemStack item = new ItemStack(material);
+        ItemMeta itemMeta = item.getItemMeta();
+        itemMeta.setDisplayName(name);
+        item.setItemMeta(itemMeta);
+        return item;
+    }
+
+    @EventHandler
+    public void onInvClick(InventoryClickEvent event) {
+        if (event.getClickedInventory() == null || !event.getView().getTitle().equals(INV_NAME)) return;
+        event.setCancelled(true);
+        Player player = (Player) event.getWhoClicked();
+
+        switch (event.getCurrentItem().getType()) {
+            case GREEN_STAINED_GLASS_PANE:
+                player.performCommand("togglesnow true");
+                break;
+
+            case RED_STAINED_GLASS_PANE:
+                player.performCommand("togglesnow false");
+                break;
+
+            case CLOCK:
+                player.performCommand("setsnowmode ALWAYS");
+                break;
+
+            case SUNFLOWER:
+                player.performCommand("setsnowmode ONLY_CLEAR_WEATHER");
+                break;
+
+            case SNOWBALL:
+                player.performCommand("setsnowmode ONLY_NIGHT_OR_SNOWBIOME");
+        }
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/commands/TabCompletion.java

@@ -0,0 +1,17 @@
+package de.craftix.snowfall.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class TabCompletion implements TabCompleter {
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (command.getName().equalsIgnoreCase("togglesnow")) return Arrays.asList("true", "false");
+        if (command.getName().equalsIgnoreCase("setsnowmode")) return Arrays.asList("ONLY_NIGHT_OR_SNOWBIOME", "ONLY_CLEAR_WEATHER", "ALWAYS");
+        return null;
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/commands/ToggleSnowCmd.java

@@ -0,0 +1,40 @@
+package de.craftix.snowfall.commands;
+
+import de.craftix.snowfall.utils.DBHandler;
+import de.craftix.snowfall.utils.FlakesHandler;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ToggleSnowCmd implements CommandExecutor {
+    private DBHandler handler;
+
+    public ToggleSnowCmd(DBHandler handler) {
+        this.handler = handler;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) sender.sendMessage("§cDieser Command kann nur als spieler ausgeführt werden!");
+        else if (args.length > 1) return false;
+        else {
+            try {
+                Player p = (Player) sender;
+                boolean showSnow = handler.showSnow(p.getUniqueId());
+                if (args.length == 0) {
+                    showSnow = !showSnow;
+                }else {
+                    showSnow = Boolean.parseBoolean(args[0]);
+                }
+                handler.setShowSnow(p.getUniqueId(), showSnow);
+
+                FlakesHandler.refreshPlayerData();
+
+                String message = "§7Schneeflocken " + (showSnow ? "§aeingeschaltet" : "§causgeschaltet");
+                p.sendMessage(message);
+            }catch (Exception ignored) {}
+        }
+        return true;
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/utils/ConfigHandler.java

@@ -0,0 +1,44 @@
+package de.craftix.snowfall.utils;
+
+import de.craftix.snowfall.Snowfall;
+
+import java.io.File;
+import java.util.List;
+
+public class ConfigHandler {
+
+    public ConfigHandler() {
+        this.load();
+    }
+
+    private void load() {
+        if (!Snowfall.getPlugin().getDataFolder().exists()) {
+            Snowfall.getPlugin().getDataFolder().mkdir();
+        }
+
+        if (!(new File(Snowfall.getPlugin().getDataFolder(), "config.yml")).exists()) {
+            Snowfall.getPlugin().saveDefaultConfig();
+        }
+
+    }
+
+    public boolean isRealistic() {
+        return Snowfall.getPlugin().getConfig().getBoolean("realistic");
+    }
+
+    public int getAmount() {
+        return Snowfall.getPlugin().getConfig().getInt("amount");
+    }
+
+    public int getRadius() {
+        return Snowfall.getPlugin().getConfig().getInt("radius");
+    }
+
+    public List<String> getAllowedWorlds() {
+        return Snowfall.getPlugin().getConfig().getStringList("worlds");
+    }
+
+    public List<String> getForbiddenBiomes() {
+        return Snowfall.getPlugin().getConfig().getStringList("biomes");
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/utils/DBHandler.java

@@ -0,0 +1,53 @@
+package de.craftix.snowfall.utils;
+
+import java.sql.ResultSet;
+import java.util.UUID;
+
+public class DBHandler {
+    private SQLite sqLite;
+
+    public DBHandler() {
+        sqLite = new SQLite("./plugins/Snowfall/data.db");
+        sqLite.insert("CREATE TABLE IF NOT EXISTS Userdata (UUID STRING, Enabled BOOLEAN, Mode INTEGER)");
+    }
+
+    public boolean showSnow(UUID uuid) {
+        try {
+            ResultSet rs = sqLite.getData("SELECT * FROM Userdata WHERE UUID = \"" + uuid + "\"");
+            if (rs.next()) {
+                return rs.getBoolean("Enabled");
+            }
+        }catch (Exception e) { e.printStackTrace(); }
+        return true;
+    }
+
+    public void setShowSnow(UUID uuid, boolean value) {
+        try {
+            int mode = getMode(uuid);
+            sqLite.insert("DELETE FROM Userdata WHERE UUID = \"" + uuid + "\"");
+            sqLite.insert("INSERT INTO Userdata VALUES (\"" + uuid + "\", " + value + ", " + mode + ")");
+        }catch (Exception e) { e.printStackTrace(); }
+    }
+
+    public int getMode(UUID uuid) {
+        try {
+            ResultSet rs = sqLite.getData("SELECT * FROM Userdata WHERE UUID = \"" + uuid + "\"");
+            if (rs.next()) {
+                return rs.getInt("Mode");
+            }
+        }catch (Exception e) { e.printStackTrace(); }
+        return 0;
+    }
+
+    public void setMode(UUID uuid, int mode) {
+        try {
+            boolean enabled = showSnow(uuid);
+            sqLite.insert("DELETE FROM Userdata WHERE UUID = \"" + uuid + "\"");
+            sqLite.insert("INSERT INTO Userdata VALUES (\"" + uuid + "\", " + enabled + ", " + mode + ")");
+        }catch (Exception e) { e.printStackTrace(); }
+    }
+
+    public void deactivate() {
+        sqLite.disconnect();
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/utils/FlakesHandler.java

@@ -0,0 +1,175 @@
+package de.craftix.snowfall.utils;
+
+import de.craftix.snowfall.Snowfall;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.*;
+
+public class FlakesHandler {
+    private int version = Integer.valueOf(Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3].split("_")[1]);
+    private ConfigHandler config;
+    float radius;
+    int amount;
+    boolean realistic;
+    List<String> worlds;
+    List<String> biomes;
+    Random random;
+
+    private static DBHandler handler;
+    private static final Map<UUID, Boolean> showFlakes = new HashMap<>();
+
+    public FlakesHandler(ConfigHandler config, DBHandler handler) {
+        this.config = config;
+        this.radius = (float)config.getRadius();
+        this.amount = config.getAmount() / 4;
+        this.realistic = config.isRealistic();
+        this.worlds = config.getAllowedWorlds();
+        this.biomes = config.getForbiddenBiomes();
+        this.handler = handler;
+        this.createFlakes();
+    }
+
+    private void createFlakes() {
+        this.random = new Random();
+        (new BukkitRunnable() {
+            public void run() {
+                refreshPlayerData();
+            }
+        }).runTaskTimer(Snowfall.getPlugin(), 0L, 100L);
+
+        (new BukkitRunnable() {
+            public void run() {
+                for(int i = 0; i < FlakesHandler.this.amount; ++i) {
+                    float xAdditive = (FlakesHandler.this.random.nextFloat() - 0.5F) * FlakesHandler.this.radius * 2.0F;
+                    float max = (float)Math.sqrt((double)(FlakesHandler.this.radius * FlakesHandler.this.radius - xAdditive * xAdditive)) * 2.0F;
+                    float yAdditive = (FlakesHandler.this.random.nextFloat() - 0.5F) * max;
+                    float zAdditive = (FlakesHandler.this.random.nextFloat() - 0.5F) * max;
+                    Bukkit.getOnlinePlayers().forEach((player) -> {
+                        if (!showFlakes.containsKey(player.getUniqueId()) || !showFlakes.get(player.getUniqueId())) return;
+                        Location playerLoc = player.getLocation();
+                        if (FlakesHandler.this.worlds.contains(playerLoc.getWorld().getName()) && !FlakesHandler.this.biomes.contains(playerLoc.getBlock().getBiome().toString())) {
+                            Location loc = new Location(player.getWorld(), playerLoc.getX() + (double)xAdditive, playerLoc.getY() + (double)yAdditive, playerLoc.getZ() + (double)zAdditive);
+                            if (!FlakesHandler.this.realistic || (double)loc.getWorld().getHighestBlockYAt(loc) < loc.getY()) {
+                                try {
+                                    if (13 <= FlakesHandler.this.version) {
+                                        FlakesHandler.this.sendParticles(player, loc.getX(), loc.getY(), loc.getZ(), 0.0D, 10);
+                                    } else {
+                                        FlakesHandler.this.sendParticles(player, "FIREWORKS_SPARK", (float)loc.getX(), (float)loc.getY(), (float)loc.getZ(), new int[]{1});
+                                    }
+                                } catch (SecurityException | NoSuchMethodException | IllegalArgumentException | InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchFieldException | ClassNotFoundException var8) {
+                                    var8.printStackTrace();
+                                }
+                            }
+                        }
+
+                    });
+                }
+
+            }
+        }).runTaskTimer(Snowfall.getPlugin(), 0L, 2L);
+    }
+
+    public static void refreshPlayerData() {
+        Bukkit.getOnlinePlayers().forEach((player -> {
+            if (showFlakes.containsKey(player.getUniqueId()))
+                showFlakes.remove(player.getUniqueId());
+            showFlakes.put(player.getUniqueId(), handler.showSnow(player.getUniqueId()) && checkMode(player));
+        }));
+    }
+
+    private Class<?> getNMSClass(String nmsClassString) throws ClassNotFoundException {
+        String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3] + ".";
+        String name = "net.minecraft.server." + version + nmsClassString;
+        Class<?> nmsClass = Class.forName(name);
+        return nmsClass;
+    }
+
+    private Class<?> getCraftPlayerClass() throws ClassNotFoundException {
+        String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3];
+        String name = "org.bukkit.craftbukkit." + version + ".entity.CraftPlayer";
+        Class<?> nmsClass = Class.forName(name.replace("/", "."));
+        return nmsClass;
+    }
+
+    private Object getConnection(Player player) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+        Method getHandle = player.getClass().getMethod("getHandle");
+        Object nmsPlayer = getHandle.invoke(player);
+        Field conField = nmsPlayer.getClass().getField("playerConnection");
+        Object con = conField.get(nmsPlayer);
+        return con;
+    }
+
+    public void sendParticles(Player player, double x, double y, double z, double data, int amount) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
+        Class<?> cpClass = this.getCraftPlayerClass();
+        Class<?> particleClass = Class.forName("org.bukkit.Particle");
+        Method valueOf = particleClass.getMethod("valueOf", String.class);
+        Method spawnParticle = cpClass.getMethod("spawnParticle", particleClass, Double.TYPE, Double.TYPE, Double.TYPE, Integer.TYPE, Double.TYPE, Double.TYPE, Double.TYPE, Double.TYPE);
+        spawnParticle.invoke(cpClass.cast(player), valueOf.invoke(particleClass, "FIREWORKS_SPARK"), x, y, z, amount, 0.0D, 0.0D, 0.0D, data);
+    }
+
+    public void sendParticles(Player player, String particle, float x, float y, float z, int[] amount) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
+        Class<?> packetClass = this.getNMSClass("PacketPlayOutWorldParticles");
+        Class<?> particleClass = this.getNMSClass("EnumParticle");
+        Constructor<?> packetConstructor = packetClass.getConstructors()[1];
+        Method valueOf = particleClass.getMethod("valueOf", String.class);
+        Object packet = packetConstructor.newInstance(valueOf.invoke(particleClass, "FIREWORKS_SPARK"), true, x, y, z, 0.0F, 0.0F, 0.0F, 0.0F, 0, amount);
+        Method sendPacket = this.getNMSClass("PlayerConnection").getMethod("sendPacket", this.getNMSClass("Packet"));
+        sendPacket.invoke(this.getConnection(player), packet);
+    }
+
+    private static boolean checkMode(Player player) {
+        SnowModes mode = SnowModes.getByMode(handler.getMode(player.getUniqueId()));
+
+        switch (mode) {
+            case ALWAYS:
+                return true;
+
+            case ONLY_CLEAR_WEATHER:
+                return player.getWorld().isClearWeather();
+
+            case ONLY_NIGHT_OR_SNOWBIOME:
+                if ((player.getWorld().getBiome(player.getLocation()).toString().contains("FROZEN") ||
+                    player.getWorld().getBiome(player.getLocation()).toString().contains("SNOW") ||
+                    (player.getWorld().getTime() % 24000) > 12000) && player.getWorld().isClearWeather())
+                    return true;
+
+            default:
+                return false;
+        }
+    }
+
+    public enum SnowModes {
+        ONLY_NIGHT_OR_SNOWBIOME(0, "Nur nachts oder in Schneebiomen"),
+        ONLY_CLEAR_WEATHER(1, "Nur bei klarem Wetter"),
+        ALWAYS(2, "Immer");
+
+        private final int mode;
+        private final String name;
+        SnowModes(int mode, String name) { this.mode = mode; this.name = name; }
+        public int getMode() { return mode; }
+        public String getName() { return name; }
+
+        public static SnowModes getByMode(int modeId) {
+            for (SnowModes mode : values()) {
+                if (mode.getMode() == modeId)
+                    return mode;
+            }
+            return ONLY_NIGHT_OR_SNOWBIOME;
+        }
+    }
+
+    public static SnowModes getSnowModeByName(String name) {
+        for (SnowModes mode : SnowModes.values()) {
+            if (mode.name().equalsIgnoreCase(name))
+                return mode;
+        }
+        return null;
+    }
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/utils/PacketListener.java

@@ -0,0 +1,112 @@
+package de.craftix.snowfall.utils;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import de.craftix.snowfall.Snowfall;
+import net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import java.util.function.Consumer;
+
+public class PacketListener extends PacketAdapter {
+
+    public PacketListener() {
+        super(Snowfall.getPlugin(), PacketType.Play.Server.MAP_CHUNK);
+    }
+
+    @Override
+    public void onPacketSending(PacketEvent event) {
+        PacketContainer packet = event.getPacket();
+        PacketType type = event.getPacketType();
+        Player player = event.getPlayer();
+
+        if (type == PacketType.Play.Server.MAP_CHUNK && player.getWorld().getEnvironment() == World.Environment.NORMAL) {
+            modifyChunkPacket(player, packet, this::handle);
+        }
+    }
+
+    private void handle(BiomeBridge biomeBridge) {
+        World world = biomeBridge.getPlayer().getWorld();
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+                for (int y = -64; y < 320; y++) {
+                    biomeBridge.setBiome(x, y, z);
+                }
+            }
+        }
+    }
+
+    private void modifyChunkPacket(Player player, PacketContainer packet, Consumer<BiomeBridge> biomeBridgeConsumer) {
+        int chunkX = packet.getIntegers().readSafely(0);
+        int chunkZ = packet.getIntegers().readSafely(1);
+        ClientboundLevelChunkPacketData data = packet.getSpecificModifier(ClientboundLevelChunkPacketData.class).readSafely(0);
+
+        biomeBridgeConsumer.accept(new BiomeBridge() {
+            @Override
+            public int getChunkX() {
+                return chunkX;
+            }
+
+            @Override
+            public int getChunkZ() {
+                return chunkZ;
+            }
+
+            @Override
+            public Player getPlayer() {
+                return player;
+            }
+
+            @Override
+            public void setBiome(int x, int z) {
+                throw new UnsupportedOperationException("Not support 2D Biome Operations in this version!");
+            }
+
+            @Override
+            public void setBiome(int x, int y, int z) {
+                //TODO: Modify packet
+            }
+        });
+    }
+
+    private static class Maths {
+        private static final int e = (int)Math.round(Math.log(16.0D) / Math.log(2.0D)) - 2;
+        private static final int f = (int)Math.round(Math.log(256.0D) / Math.log(2.0D)) - 2;
+        public static final int a;
+        public static final int b;
+        public static final int c;
+        static {
+            a = 1 << e + e + f;
+            b = (1 << e) - 1;
+            c = (1 << f) - 1;
+        }
+
+        public static int biomeIndex(int i, int j, int k){
+            int l = i & b;
+            int i1 = clamp(j, 0, c);
+            int j1 = k & b;
+            return i1 << e + e | j1 << e | l;
+        }
+
+        private static int clamp(int var0, int var1, int var2) {
+            if (var0 < var1) {
+                return var1;
+            } else {
+                return Math.min(var0, var2);
+            }
+        }
+    }
+
+    private interface BiomeBridge {
+        int getChunkX();
+        int getChunkZ();
+        Player getPlayer();
+
+        void setBiome(int x, int z);
+        void setBiome(int x, int y, int z);
+    }
+
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/utils/SQLite.java

@@ -0,0 +1,62 @@
+package de.craftix.snowfall.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+
+public class SQLite {
+
+    protected String path;
+    protected Connection con;
+
+    public SQLite(String path) {
+        File file = new File(path);
+        if (!file.exists()) {
+            try {
+                file.getParentFile().mkdirs();
+                file.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        this.path = file.getAbsolutePath();
+        connect();
+    }
+
+    public void connect() {
+        if (isConnected()) return;
+        try {
+            con = DriverManager.getConnection("jdbc:sqlite:" + path);
+        }catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void disconnect() {
+        if (!isConnected()) return;
+        try {
+            con.close();
+            con = null;
+        }catch (Exception e) { e.printStackTrace(); }
+    }
+
+    public boolean isConnected() { return con != null; }
+
+    public void insert(String qry) {
+        if (!isConnected()) throw new NullPointerException("SQLite not connected");
+        try {
+            con.prepareStatement(qry).executeUpdate();
+        }catch (Exception e) { e.printStackTrace(); }
+    }
+
+    public ResultSet getData(String qry) {
+        if (!isConnected()) throw new NullPointerException("SQLite not connected");
+        try {
+            return con.prepareStatement(qry).executeQuery();
+        }catch (Exception e) { e.printStackTrace(); }
+        return null;
+    }
+
+}

Plugins/Snowfall/src/main/java/de/craftix/snowfall/utils/StarterpackHandler.java

@@ -0,0 +1,7 @@
+package de.craftix.snowfall.utils;
+
+public class StarterpackHandler {
+    public StarterpackHandler(DBHandler handler) {
+        new FlakesHandler(new ConfigHandler(), handler);
+    }
+}

Plugins/Snowfall/src/main/resources/config.yml

@@ -0,0 +1,41 @@
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+ # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# #     _____                                              _________                        # #
+ #     /  _  \__  _  __ ____   __________   _____   ____  /   _____/ ____   ______  _  __    #
+# #   /  /_\  \ \/ \/ // __ \ /  ___/  _ \ /     \_/ __ \ \_____  \ /    \ /  _ \ \/ \/ /   # #
+ #   /    |    \     /\  ___/ \___ (  <_> )  Y Y  \  ___/ /        \   |  (  <_> )     /     #
+# #  \____|__  /\/\_/  \___  >____  >____/|__|_|  /\___  >_______  /___|  /\____/ \/\_/     # #
+ #           \/            \/     \/            \/     \/        \/     \/                   #
+# #  dev: nurkert a.k.a. Werwideolf; v3.2                                                   # #
+ # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+
+#Specifies the radius in the snow flakes will spawn around the player.
+radius: 10
+
+#When true, snow will not be spawned under blocks.
+realistic: true
+
+#This is how many snow flakes will spawn per second
+amount: 50
+
+#A list of worlds where the plugin will spawn the particles
+worlds:
+- 'world'
+
+# A list of all biomes:
+# JUNGLE, SWAMPLAND, FOREST, TAIGA, DESERT, PLAINS, HELL, SKY, OCEAN, RIVER, EXTREME_HILLS, FROZEN_OCEAN,
+# FROZEN_RIVER, ICE_PLAINS, ICE_MOUNTAINS, MUSHROOM_ISLAND, MUSHROOM_SHORE, BEACH, DESERT_HILLS, FOREST_HILLS,
+# TAIGA_HILLS, SMALL_MOUNTAINS, JUNGLE, JUNGLE_HILLS, JUNGLE_EDGE, DEEP_OCEAN, STONE_BEACH, COLD_BEACH,
+# BIRCH_FOREST, BIRCH_FOREST_HILLS, ROOFED_FOREST, COLD_TAIGA, COLD_TAIGA_HILLS, MEGA_TAIGA, MEGA_TAIGA_HILLS,
+# EXTREME_HILLS_PLUS, SAVANNA, SAVANNA_PLATEAU, MESA, MESA_PLATEAU_FOREST, MESA_PLATEAU, SUNFLOWER_PLAINS,
+# DESERT_MOUNTAINS, FLOWER_FOREST, TAIGA_MOUNTAINS, SWAMPLAND_MOUNTAINS, ICE_PLAINS_SPIKES, JUNGLE_MOUNTAINS,
+# JUNGLE_EDGE_MOUNTAINS, COLD_TAIGA_MOUNTAINS, SAVANNA_MOUNTAINS, SAVANNA_PLATEAU_MOUNTAINS, MESA_BRYCE,
+# MESA_PLATEAU_FOREST_MOUNTAINS, MESA_PLATEAU_MOUNTAINS, BIRCH_FOREST_MOUNTAINS, BIRCH_FOREST_HILLS_MOUNTAINS,
+# ROOFED_FOREST_MOUNTAINS, MEGA_SPRUCE_TAIGA, EXTREME_HILLS_MOUNTAINS, EXTREME_HILLS_PLUS_MOUNTAINS,
+# MEGA_SPRUCE_TAIGA_HILLS
+#
+#A blacklist of biomes where the plugin will not spawn the particles
+biomes:
+- 'HELL'
+- 'DESERT'

Plugins/Snowfall/src/main/resources/plugin.yml

@@ -0,0 +1,20 @@
+name: Snowfall
+version: '${project.version}'
+main: de.craftix.snowfall.Snowfall
+api-version: 1.18
+depend: [ProtocolLib]
+
+commands:
+  togglesnow:
+    usage: /togglesnow <true | false>
+    description: Schalt die Schneeflocken an/aus
+
+  setsnowmode:
+    usage: /setsnowmode <mode>
+    description: Ändert den Modus der Schneeflocken
+
+  snow:
+    usage: /snow
+    description: Öffnet das Scheeflocken Menü
+
+  regeneratechunk: