make time/weather command checks more strict (closes #19)

fix SunriseSunsetRequest to use right config values

.github/CODEOWNERS

@@ -1 +0,0 @@
-*   @Jack1424

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +1,3 @@
+#file: noinspection YAMLSchemaValidation
+#IntelliJ IDEA interprets this as another issue template so the above line is required
 blank_issues_enabled: false

.gitignore

@@ -1,36 +1,23 @@
-# =====================================
-# RealTimeWeather – Git ignore rules
-# =====================================
-
-# Gradle build & cache
-.gradle/
-build/
-
-# Gradle Wrapper – keep only the two required files
-!gradle/wrapper/gradle-wrapper.jar
-!gradle/wrapper/gradle-wrapper.properties
-gradle/wrapper/*
-
-# IDEs
-# IntelliJ IDEA
-.idea/
+# User-specific IDEA files
+.idea
 *.iml
-# VS Code
-.vscode/
-# Eclipse
+
+# Gradle build files
+.gradle
+**/build/
+!src/**/build/
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Avoid ignore Gradle wrappper properties
+!gradle-wrapper.properties
+
+# Cache of project
+.gradletasknamecache
+
+# Eclipse Gradle plugin generated files
+# Eclipse Core
 .project
+# JDT-specific (Eclipse Java Development Tools)
 .classpath
-.settings/
-
-# Generated output folders
-out/
-bin/
-
-# MacOS
-.DS_Store
-
-# Temp files
-*~
-*.swp
-*.tmp
-*.bak

build.gradle

@@ -1,9 +1,6 @@
-import io.papermc.paperweight.userdev.ReobfArtifactConfiguration
-
 plugins {
     id 'java'
-    id 'io.papermc.paperweight.userdev' version '2.0.0-beta.17'
-    id 'com.gradleup.shadow' version '8.3.6'
+    id 'io.github.goooler.shadow' version '8.1.8' // TODO: Temporarily using fork
 }
 
 group = 'io.github.jack1424'
@@ -12,37 +9,58 @@ version = '2.0.0-DEV'
 repositories {
     mavenCentral()
     maven {
-        url = 'https://repo.papermc.io/repository/maven-public/'
+        name = "papermc-repo"
+        url = "https://repo.papermc.io/repository/maven-public/"
+    }
+    maven {
+        name = "sonatype"
+        url = "https://oss.sonatype.org/content/groups/public/"
     }
 }
 
 dependencies {
-    paperweight.paperDevBundle('1.21.5-R0.1-SNAPSHOT')
-    implementation 'org.bstats:bstats-bukkit:3.1.0'
+    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
+    implementation("org.bstats:bstats-bukkit:3.0.2")
 }
 
 shadowJar {
-    archiveClassifier.set('')
-    relocate('org.bstats', 'io.github.jack1424.realtimeweather.libs.bstats')
-    minimize()
+    relocate('org.bstats', 'io.github.jack1424.realTimeWeather')
 }
 
 tasks.jar {
-    paperweight.reobfArtifactConfiguration = ReobfArtifactConfiguration.getMOJANG_PRODUCTION()
+    manifest {
+        attributes["paperweight-mappings-namespace"] = "mojang"
+    }
 }
 
 tasks.shadowJar {
-    paperweight.reobfArtifactConfiguration = ReobfArtifactConfiguration.getMOJANG_PRODUCTION()
+    manifest {
+        attributes["paperweight-mappings-namespace"] = "mojang"
+    }
 }
 
+def targetJavaVersion = 21
 java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+    def javaVersion = JavaVersion.toVersion(targetJavaVersion)
+    sourceCompatibility = javaVersion
+    targetCompatibility = javaVersion
+    if (JavaVersion.current() < javaVersion) {
+        toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
+    }
+}
+
+tasks.withType(JavaCompile).configureEach {
+    options.encoding = 'UTF-8'
+
+    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
+        options.release.set(targetJavaVersion)
+    }
 }
 
 processResources {
     def props = [version: version]
     inputs.properties props
-    filteringCharset = 'UTF-8'
+    filteringCharset 'UTF-8'
     filesMatching('plugin.yml') {
         expand props
     }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/io/github/jack1424/realTimeWeather/ConfigManager.java

@@ -0,0 +1,392 @@
+package io.github.jack1424.realTimeWeather;
+
+import io.github.jack1424.realTimeWeather.requests.WeatherRequestObject;
+import org.bukkit.World;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.json.simple.parser.ParseException;
+
+import javax.naming.ConfigurationException;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.time.zone.ZoneRulesException;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.TimeZone;
+
+public class ConfigManager {
+	private final RealTimeWeather rtw;
+	private final FileConfiguration configFile;
+	private TimeZone timeZone;
+	private boolean debug, timeEnabled, weatherEnabled, timeSyncAllWorlds, weatherSyncAllWorlds, blockTimeSetCommand, blockWeatherCommand, disableBedsAtNight, disableBedsDuringThunder;
+	private long updateCheckInterval, timeSyncInterval, weatherSyncInterval;
+	private String sunriseSunset, sunriseSunsetLatitude, sunriseSunsetLongitude, apiKey, weatherLatitude, weatherLongitude, disableBedsAtNightMessage, disableBedsDuringThunderMessage, sunriseCustomTime, sunsetCustomTime;
+	private HashSet<World> timeSyncWorlds, weatherSyncWorlds;
+
+	public ConfigManager(RealTimeWeather rtw) {
+		this.rtw = rtw;
+		configFile = rtw.getConfig();
+	}
+
+	public void refreshValues() {
+		setDebugEnabled(configFile.getBoolean("Debug"));
+
+		setTimeEnabled(configFile.getBoolean("SyncTime"));
+		if (isTimeEnabled())
+			try {
+				timeSyncWorlds = new HashSet<>();
+				setTimeSyncAllWorlds(configFile.getBoolean("TimeSyncAllWorlds"));
+				if (getTimeSyncAllWorlds()) {
+					for (World world : rtw.getServer().getWorlds())
+						if (world.getEnvironment() == World.Environment.NORMAL)
+							addTimeSyncWorld(world.getName());
+				} else {
+					for (String worldName : configFile.getStringList("TimeSyncWorlds"))
+						addTimeSyncWorld(worldName);
+				}
+				setBlockTimeSetCommand(configFile.getBoolean("BlockTimeSetCommand"));
+				setDisableBedsAtNight(configFile.getBoolean("DisableBedsAtNight"));
+				setDisableBedsAtNightMessage(configFile.getString("DisableBedsAtNightMessage"));
+				setTimeSyncInterval(configFile.getLong("TimeSyncInterval"));
+				setTimeZone(configFile.getString("Timezone"));
+				setSunriseSunset(configFile.getString("SunriseSunset"));
+				if (getSunriseSunset().equals("real")) {
+					setSunriseSunsetLatitude(configFile.getString("SunriseSunsetLatitude"));
+					setSunriseSunsetLongitude(configFile.getString("SunriseSunsetLongitude"));
+				} else if (getSunriseSunset().equals("custom")) {
+					setSunriseCustomTime(configFile.getString("SunriseCustomTime"));
+					setSunsetCustomTime(configFile.getString("SunsetCustomTime"));
+				}
+			} catch (ConfigurationException e) {
+				rtw.getLogger().severe((e.getMessage()));
+				rtw.getLogger().severe("Error loading time configuration. Check that the values in your configuration file are valid.");
+				rtw.getLogger().severe("Disabling time sync...");
+
+				setTimeEnabled(false);
+			}
+
+		setWeatherEnabled(configFile.getBoolean("SyncWeather"));
+		if (isWeatherEnabled())
+			try {
+				weatherSyncWorlds = new HashSet<>();
+				setWeatherSyncAllWorlds(configFile.getBoolean("WeatherSyncAllWorlds"));
+				if (getWeatherSyncAllWorlds()) {
+					for (World world : rtw.getServer().getWorlds())
+						if (world.getEnvironment() == World.Environment.NORMAL)
+							addWeatherSyncWorld(world.getName());
+				} else {
+					for (String worldName : configFile.getStringList("WeatherSyncWorlds"))
+						addWeatherSyncWorld(worldName);
+				}
+				setBlockWeatherCommand(configFile.getBoolean("BlockWeatherCommand"));
+				setDisableBedsDuringThunder(configFile.getBoolean("DisableBedsDuringThunder"));
+				setDisableBedsDuringThunderMessage(configFile.getString("DisableBedsDuringThunderMessage"));
+				setWeatherSyncInterval(configFile.getLong("WeatherSyncInterval"));
+				setAPIKey(configFile.getString("APIKey"));
+				setWeatherLatitude(configFile.getString("WeatherLatitude"));
+				setWeatherLongitude(configFile.getString("WeatherLongitude"));
+			} catch (ConfigurationException e) {
+				rtw.getLogger().severe(e.getMessage());
+				rtw.getLogger().severe("Error loading weather configuration. Check that the values in your configuration file are valid.");
+				rtw.getLogger().severe("Disabling weather sync...");
+
+				setWeatherEnabled(false);
+			}
+
+		setUpdateCheckInterval(configFile.getLong("UpdateCheckInterval"));
+	}
+
+	public long getUpdateCheckInterval() {
+		return updateCheckInterval;
+	}
+
+	public void setUpdateCheckInterval(long value) {
+		updateCheckInterval = value;
+		rtw.debug("updateCheckInterval set to " + value);
+	}
+
+	public boolean debugEnabled() {
+		return debug;
+	}
+
+	public void setDebugEnabled(boolean value) {
+		debug = value;
+		rtw.getLogger().warning("Debug set to " + value);
+	}
+
+	public boolean isTimeEnabled() {
+		return timeEnabled;
+	}
+
+	public void setTimeEnabled(boolean value) {
+		timeEnabled = value;
+		rtw.debug("SyncTime set to " + value);
+	}
+
+	public boolean getTimeSyncAllWorlds() {
+		return timeSyncAllWorlds;
+	}
+
+	public void setTimeSyncAllWorlds(boolean value) {
+		timeSyncAllWorlds = value;
+		rtw.debug("TimeSyncAllWorlds set to " + value);
+	}
+
+	public HashSet<World> getTimeSyncWorlds() {
+		return timeSyncWorlds;
+	}
+
+	public void addTimeSyncWorld(String worldName) throws ConfigurationException {
+		World world = rtw.getServer().getWorld(worldName);
+
+		if (world == null)
+			throw new ConfigurationException("World \"" + worldName + "\" cannot be found");
+
+		timeSyncWorlds.add(world);
+		rtw.debug("World \"" + worldName + "\" added to TimeSyncWorlds");
+	}
+
+	public boolean getBlockTimeSetCommand() {
+		return blockTimeSetCommand;
+	}
+
+	public void setBlockTimeSetCommand(boolean value) {
+		blockTimeSetCommand = value;
+		rtw.debug("BlockTimeSetCommand set to " + value);
+	}
+
+	public boolean getDisableBedsAtNight() {
+		return disableBedsAtNight;
+	}
+
+	public void setDisableBedsAtNight(boolean value) {
+		disableBedsAtNight = value;
+		rtw.debug("DisableBedsAtNight set to " + value);
+	}
+
+	public String getDisableBedsAtNightMessage() {
+		return disableBedsAtNightMessage;
+	}
+
+	public void setDisableBedsAtNightMessage(String value) {
+		disableBedsAtNightMessage = value;
+		rtw.debug("NightDisabledBedMessage set to " + value);
+	}
+
+	public long getTimeSyncInterval() {
+		return timeSyncInterval;
+	}
+
+	public void setTimeSyncInterval(long value) throws ConfigurationException {
+		if (value < 0)
+			throw new ConfigurationException("Time sync interval cannot be less than 0");
+
+		timeSyncInterval = value;
+		rtw.debug("TimeSyncInterval set to " + value);
+	}
+
+	public TimeZone getTimeZone() {
+		return timeZone;
+	}
+
+	public void setTimeZone(String value) throws ConfigurationException {
+		try {
+			timeZone = TimeZone.getTimeZone(ZoneId.of(Objects.requireNonNull(value)));
+		} catch (ZoneRulesException | NullPointerException e) {
+			throw new ConfigurationException("Timezone not valid");
+		}
+
+		rtw.debug("TimeZone set to " + value);
+	}
+
+	public String getSunriseSunset() {
+		return sunriseSunset;
+	}
+
+	public void setSunriseSunset(String value) throws ConfigurationException {
+		value = value.toLowerCase();
+		if (value.equals("default") || value.equals("real") || value.equals("custom")) {
+			sunriseSunset = value;
+			rtw.debug("SunriseSunset set to " + value);
+		} else {
+			throw new ConfigurationException("SunriseSunset value invalid (must be default or real or custom)");
+		}
+	}
+
+	public String getSunriseSunsetLatitude() {
+		return sunriseSunsetLatitude;
+	}
+
+	public void setSunriseSunsetLatitude(String value) {
+		sunriseSunsetLatitude = value;
+		rtw.debug("SunriseSunsetLatitude set to " + value);
+	}
+
+	public String getSunriseSunsetLongitude() {
+		return sunriseSunsetLongitude;
+	}
+
+	public void setSunriseSunsetLongitude(String value) {
+		sunriseSunsetLongitude = value;
+		rtw.debug("SunriseSunsetLongitude set to " + value);
+	}
+
+	public String getSunriseCustomTime() {
+		return sunriseCustomTime;
+	}
+
+	public void setSunriseCustomTime(String value) throws ConfigurationException {
+		try {
+			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("h:mm:ss a");
+			sunriseCustomTime = LocalTime.parse(value, formatter).format(formatter);
+			rtw.debug("SunriseCustomTime set to " + value);
+		} catch (DateTimeParseException e) {
+			throw new ConfigurationException("SunriseCustomTime value invalid (check format)");
+		}
+	}
+
+	public String getSunsetCustomTime() {
+		return sunsetCustomTime;
+	}
+
+	public void setSunsetCustomTime(String value) throws ConfigurationException {
+		try {
+			DateTimeFormatter formatter = DateTimeFormatter.ofPattern("h:mm:ss a");
+			sunsetCustomTime = LocalTime.parse(value, formatter).format(formatter);
+			rtw.debug("SunsetCustomTime set to " + value);
+		} catch (DateTimeParseException e) {
+			throw new ConfigurationException("SunsetCustomTime value invalid (check format)");
+		}
+	}
+
+	public boolean isWeatherEnabled() {
+		return weatherEnabled;
+	}
+
+	public void setWeatherEnabled(boolean value) {
+		weatherEnabled = value;
+		rtw.debug("SyncWeather set to " + value);
+	}
+
+	public boolean getWeatherSyncAllWorlds() {
+		return weatherSyncAllWorlds;
+	}
+
+	public void setWeatherSyncAllWorlds(boolean value) {
+		weatherSyncAllWorlds = value;
+		rtw.debug("WeatherSyncAllWorlds set to " + value);
+	}
+
+	public HashSet<World> getWeatherSyncWorlds() {
+		return weatherSyncWorlds;
+	}
+
+	public void addWeatherSyncWorld(String worldName) throws ConfigurationException {
+		World world = rtw.getServer().getWorld(worldName);
+
+		if (world == null)
+			throw new ConfigurationException("World \"" + worldName + "\" cannot be found");
+
+		weatherSyncWorlds.add(world);
+		rtw.debug("World \"" + worldName + "\" added to WeatherSyncWorlds");
+	}
+
+	public boolean getBlockWeatherCommand() {
+		return blockWeatherCommand;
+	}
+
+	public void setBlockWeatherCommand(boolean value) {
+		blockWeatherCommand = value;
+		rtw.debug("BlockWeatherCommand set to " + value);
+	}
+
+	public boolean getDisableBedsDuringThunder() {
+		return disableBedsDuringThunder;
+	}
+
+	public void setDisableBedsDuringThunder(boolean value) {
+		disableBedsDuringThunder = value;
+		rtw.debug("DisableBedsDuringThunder set to " + value);
+	}
+
+	public String getDisableBedsDuringThunderMessage() {
+		return disableBedsDuringThunderMessage;
+	}
+
+	public void setDisableBedsDuringThunderMessage(String value) {
+		disableBedsDuringThunderMessage = value;
+		rtw.debug("ThunderDisabledBedMessage set to " + value);
+	}
+
+	public long getWeatherSyncInterval() {
+		return weatherSyncInterval;
+	}
+
+	public void setWeatherSyncInterval(long value) throws ConfigurationException {
+		if (value < 0)
+			throw new ConfigurationException("WeatherSyncInterval cannot be less than 0");
+
+		weatherSyncInterval = value;
+		rtw.debug("WeatherSyncInterval set to " + value);
+	}
+
+	public String getAPIKey() {
+		return apiKey;
+	}
+
+	public void setAPIKey(String value) throws ConfigurationException {
+		try {
+			new WeatherRequestObject(Objects.requireNonNull(value), "0", "0");
+		} catch (NullPointerException e) {
+			throw new ConfigurationException("The APIKey cannot be blank");
+		}
+		catch (IOException | ParseException | URISyntaxException e) {
+			rtw.getLogger().severe(e.getMessage());
+			throw new ConfigurationException("There was an error when validating this APIKey (this does not mean that the API key is invalid)");
+		}
+
+		apiKey = value;
+		rtw.debug("APIKey set to " + value);
+	}
+
+	public String getWeatherLatitude() {
+		return weatherLatitude;
+	}
+
+	public void setWeatherLatitude(String value) throws ConfigurationException {
+		try {
+			double doubleValue = Double.parseDouble(Objects.requireNonNull(value));
+			if (doubleValue < -90 || doubleValue > 90)
+				throw new ConfigurationException("The entered latitude cannot be less than -90 or greater than 90");
+		} catch (NullPointerException e) {
+			throw new ConfigurationException("The latitude cannot be blank");
+		} catch (NumberFormatException e) {
+			throw new ConfigurationException("The entered latitude might not be a number (or is too long)");
+		}
+
+		weatherLatitude = value;
+		rtw.debug("Latitude set to " + value);
+	}
+
+	public String getWeatherLongitude() {
+		return weatherLongitude;
+	}
+
+	public void setWeatherLongitude(String value) throws ConfigurationException {
+		try {
+			double doubleValue = Double.parseDouble(Objects.requireNonNull(value));
+			if (doubleValue < -180 || doubleValue > 180)
+				throw new ConfigurationException("The entered longitude cannot be less than -180 or greater than 180");
+		} catch (NullPointerException e) {
+			throw new ConfigurationException("The longitude cannot be blank");
+		} catch (NumberFormatException e) {
+			throw new ConfigurationException("The entered longitude might not be a number (or is too long)");
+		}
+
+		weatherLongitude = value;
+		rtw.debug("Longitude set to " + value);
+	}
+}

src/main/java/io/github/jack1424/realTimeWeather/EventHandlers.java

@@ -0,0 +1,54 @@
+package io.github.jack1424.realTimeWeather;
+
+import org.bukkit.World;
+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.PlayerBedEnterEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.server.ServerCommandEvent;
+
+public class EventHandlers implements Listener {
+	private final ConfigManager config;
+
+	public EventHandlers(RealTimeWeather rtw) {
+		config = rtw.getConfigManager();
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onCommandPreprocess(PlayerCommandPreprocessEvent event) {
+		if ((config.getBlockTimeSetCommand() && config.isTimeEnabled() && event.getMessage().toLowerCase().contains("time set "))
+				|| (config.getBlockWeatherCommand() && config.isWeatherEnabled() && event.getMessage().toLowerCase().contains("weather "))) {
+			event.setCancelled(true);
+			event.getPlayer().sendMessage("Command disabled by RealTimeWeather");
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onConsoleCommand(ServerCommandEvent event) {
+		if ((config.getBlockTimeSetCommand() && config.isTimeEnabled() && event.getCommand().toLowerCase().contains("time set "))
+				|| (config.getBlockWeatherCommand() && config.isWeatherEnabled() && event.getCommand().toLowerCase().contains("weather "))) {
+			event.setCancelled(true);
+			event.getSender().sendMessage("Command disabled by RealTimeWeather");
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerBedEnter(PlayerBedEnterEvent event) {
+		Player player = event.getPlayer();
+		World playerWorld = player.getWorld();
+		long worldTime = playerWorld.getTime();
+
+		if (config.isTimeEnabled() && config.getDisableBedsAtNight() && ((!playerWorld.hasStorm() && worldTime >= 12542 && worldTime <= 23459)
+			|| (playerWorld.hasStorm() && worldTime >= 12010 && worldTime <= 23991))) {
+			event.setCancelled(true);
+			player.sendMessage(config.getDisableBedsAtNightMessage());
+		}
+
+		if (config.isWeatherEnabled() && config.getDisableBedsDuringThunder() && playerWorld.isThundering()) {
+			event.setCancelled(true);
+			player.sendMessage(config.getDisableBedsDuringThunderMessage());
+		}
+	}
+}

src/main/java/io/github/jack1424/realTimeWeather/RealTimeWeather.java

@@ -0,0 +1,203 @@
+package io.github.jack1424.realTimeWeather;
+
+import io.github.jack1424.realTimeWeather.requests.*;
+import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bukkit.GameRule;
+import org.bukkit.World;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import javax.naming.ConfigurationException;
+import java.time.LocalTime;
+import java.util.Calendar;
+import java.util.logging.Logger;
+
+public final class RealTimeWeather extends JavaPlugin {
+	private Logger logger;
+	private ConfigManager config;
+
+	@Override
+	public void onEnable() {
+		logger = getLogger();
+		logger.info("Starting...");
+
+		logger.info("Loading configuration...");
+		saveDefaultConfig();
+		config = new ConfigManager(this);
+		config.refreshValues();
+
+		debug("TimeSync: " + config.isTimeEnabled());
+		if (config.isTimeEnabled())
+			setupTime();
+
+		debug("WeatherSync: " + config.isWeatherEnabled());
+		if (config.isWeatherEnabled())
+			setupWeather();
+
+		getServer().getPluginManager().registerEvents(new EventHandlers(this), this);
+
+		debug("Enabling metrics...");
+		Metrics metrics = new Metrics(this, 16709);
+		metrics.addCustomChart(new SimplePie("weather_sync_enabled", () -> String.valueOf(config.isWeatherEnabled())));
+		metrics.addCustomChart(new SimplePie("sunrise_sunset_source", () -> String.valueOf(config.getSunriseSunset())));
+		metrics.addCustomChart(new SimplePie("time_sync_enabled", () -> String.valueOf(config.isTimeEnabled())));
+
+		logger.info("Started!");
+
+		logger.info("Checking for updates...");
+		logger.info(getUpdateCheck());
+
+		long updateCheckInterval = config.getUpdateCheckInterval();
+		if (config.getUpdateCheckInterval() > 0)
+			getServer().getScheduler().scheduleSyncRepeatingTask(this,  () -> logger.info(getUpdateCheck()), updateCheckInterval, updateCheckInterval);
+	}
+
+	@Override
+	public void onDisable() {
+		for (World world : getServer().getWorlds())
+			if (world.getEnvironment().equals(World.Environment.NORMAL)) {
+				debug("Re-enabling normal daylight and weather cycles...");
+
+				if (config.isTimeEnabled())
+					world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, true);
+				if (config.isWeatherEnabled())
+					world.setGameRule(GameRule.DO_WEATHER_CYCLE, true);
+			}
+
+		logger.info("Stopping...");
+	}
+
+	private void setupTime() {
+		debug("Enabling time zone sync...");
+		debug("Syncing time with " + config.getTimeZone().getDisplayName());
+
+		if (config.getSunriseSunset().equals("real"))
+			debug("Syncing sunrise/sunset with " + config.getSunriseSunsetLatitude() + " " + config.getSunriseSunsetLongitude());
+
+		if (config.getSunriseSunset().equals("custom"))
+			debug("Using custom sunrise/sunset times. Sunrise: " + config.getSunriseCustomTime() + ", Sunset: " + config.getSunsetCustomTime());
+
+		for (World world : config.getTimeSyncWorlds())
+			world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false);
+
+		getServer().getScheduler().scheduleSyncRepeatingTask(this, () -> {
+			if (config.isTimeEnabled()) {
+				Calendar cal = Calendar.getInstance(config.getTimeZone());
+				for (World world : config.getTimeSyncWorlds())
+					if (config.getSunriseSunset().equals("real")) {
+						SunriseSunsetRequestObject sunriseSunset;
+						try {
+							sunriseSunset = new SunriseSunsetRequestObject(config.getTimeZone(), config.getSunriseSunsetLatitude(), config.getSunriseSunsetLongitude());
+							world.setTime(calculateWorldTime(cal, sunriseSunset.getSunriseTime(), sunriseSunset.getSunsetTime()));
+						} catch (Exception e) {
+							logger.severe(e.getMessage());
+							logger.severe("Error getting sunrise/sunset times, using default sunrise/sunset times");
+
+							try {
+								config.setSunriseSunset("default");
+							} catch (ConfigurationException ex) {
+								throw new RuntimeException(ex);
+							}
+
+							world.setTime(calculateWorldTime(cal, "5:02:27 AM", "6:36:36 PM"));
+							return;
+						}
+					} else if (config.getSunriseSunset().equals("custom")) {
+						world.setTime(calculateWorldTime(cal, config.getSunriseCustomTime(), config.getSunsetCustomTime()));
+					} else
+						world.setTime(calculateWorldTime(cal, "5:02:27 AM", "6:36:36 PM"));
+			}
+		}, 0L, config.getTimeSyncInterval());
+
+		debug("Weather sync enabled");
+	}
+
+	private void setupWeather() {
+		debug("Enabling weather sync...");
+
+		try {
+			new WeatherRequestObject(config.getAPIKey(), config.getWeatherLatitude(), config.getWeatherLongitude());
+		} catch (Exception e) {
+			logger.severe(e.getMessage());
+			logger.severe("Disabling weather sync...");
+
+			config.setWeatherEnabled(false);
+			return;
+		}
+
+		for (World world : config.getWeatherSyncWorlds())
+			world.setGameRule(GameRule.DO_WEATHER_CYCLE, false);
+
+		getServer().getScheduler().scheduleSyncRepeatingTask(this, () -> {
+			debug("Syncing weather...");
+
+			try {
+				WeatherRequestObject request = new WeatherRequestObject(config.getAPIKey(), config.getWeatherLatitude(), config.getWeatherLongitude());
+
+				debug("Setting weather (Rain: " + request.isRaining() + ", Thunder: " + request.isThundering() + ")...");
+				for (World world : config.getWeatherSyncWorlds()) {
+					world.setStorm(request.isRaining());
+					world.setThundering(request.isThundering());
+				}
+			} catch (Exception e) {
+				logger.severe("There was an error when attempting to get weather information");
+				debug(e.getMessage());
+			}
+		}, 0L, config.getWeatherSyncInterval());
+
+		debug("Weather sync enabled");
+	}
+
+	private long calculateWorldTime(Calendar cal, String sunriseTime, String sunsetTime) {
+		String[] sunriseTimeSplit = sunriseTime.split(":");
+		String[] sunsetTimeSplit = sunsetTime.split(":");
+
+		long sunriseMinutes = Long.parseLong(sunriseTimeSplit[0]) * 60 + Long.parseLong(sunriseTimeSplit[1]) + Long.parseLong(sunriseTimeSplit[2].substring(0, 2)) / 60;
+		long sunsetMinutes = Long.parseLong(sunsetTimeSplit[0]) * 60 + Long.parseLong(sunsetTimeSplit[1]) + Long.parseLong(sunsetTimeSplit[2].substring(0, 2)) / 60;
+
+		if (sunriseTimeSplit[2].substring(3).equalsIgnoreCase("PM"))
+			sunriseMinutes += 720;
+		if (sunsetTimeSplit[2].substring(3).equalsIgnoreCase("PM"))
+			sunsetMinutes += 720;
+
+		LocalTime currentTime = LocalTime.of(cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
+		double currentMinutes = currentTime.getHour() * 60 + currentTime.getMinute();
+
+		if (currentMinutes >= sunriseMinutes && currentMinutes < sunsetMinutes) {
+			return (long) (((currentMinutes - sunriseMinutes) / (sunsetMinutes - sunriseMinutes)) * 13569) + 23041;
+		} else {
+			if (currentMinutes < sunriseMinutes)
+				currentMinutes += 1440;
+			
+			return (long) (((currentMinutes - sunsetMinutes) / (1440 - sunsetMinutes + sunriseMinutes)) * 13569) + 12610;
+		}
+	}
+
+	@SuppressWarnings("UnstableApiUsage")
+	public String getUpdateCheck() {
+		String currentVersion = this.getPluginMeta().getVersion();
+		String latestVersion;
+		try {
+			debug("Getting latest version...");
+			latestVersion = RequestFunctions.getLatestVersion();
+		} catch (Exception exception) {
+			debug(exception.getMessage());
+			return "There was an error getting the latest version";
+		}
+
+		if (currentVersion.equals(latestVersion)) {
+			return String.format("RealTimeWeather (v%s) is up to date!", currentVersion);
+		} else
+			return String.format("RealTimeWeather (v%s) is outdated! v%s is the latest version.", currentVersion, latestVersion);
+	}
+
+	public ConfigManager getConfigManager() {
+		return config;
+	}
+
+	public void debug(String message) {
+		if (config.debugEnabled()) {
+			logger.info("[DEBUG] " + message);
+		}
+	}
+}

src/main/java/io/github/jack1424/realTimeWeather/requests/RequestFunctions.java

@@ -0,0 +1,47 @@
+package io.github.jack1424.realTimeWeather.requests;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.Scanner;
+
+public class RequestFunctions {
+	public static Object makeRequest(String URLString) throws IOException, HTTPResponseException, ParseException, URISyntaxException {
+		int responseCode = getResponseCode(URLString);
+		if (responseCode > 399)
+			throw new HTTPResponseException(responseCode);
+
+		Scanner scanner = new Scanner(new URI(URLString).toURL().openStream());
+		StringBuilder response = new StringBuilder();
+		while (scanner.hasNextLine())
+			response.append(scanner.nextLine());
+		scanner.close();
+
+		return new JSONParser().parse(response.toString());
+	}
+
+	public static int getResponseCode(String URLString) throws IOException, URISyntaxException {
+		URL url = new URI(URLString).toURL();
+		HttpURLConnection con = (HttpURLConnection) url.openConnection();
+		con.setRequestMethod("GET");
+		con.connect();
+		return con.getResponseCode();
+	}
+
+	public static String getLatestVersion() throws Exception {
+		return ((JSONObject) ((JSONArray) makeRequest("https://api.modrinth.com/v2/project/WRA6ODcm/version")).getFirst()).get("version_number").toString();
+	}
+
+	public static class HTTPResponseException extends Exception {
+		public HTTPResponseException(int responseCode) {
+			super(String.valueOf(responseCode));
+		}
+	}
+}

src/main/java/io/github/jack1424/realTimeWeather/requests/SunriseSunsetRequestObject.java

@@ -0,0 +1,46 @@
+package io.github.jack1424.realTimeWeather.requests;
+
+import org.json.simple.JSONObject;
+import org.json.simple.parser.ParseException;
+
+import javax.naming.ConfigurationException;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+public class SunriseSunsetRequestObject {
+	private String sunriseTime, sunsetTime;
+
+	public SunriseSunsetRequestObject(TimeZone timeZone, String lat, String lon) throws IOException, ParseException, ConfigurationException, URISyntaxException {
+		JSONObject response;
+		try {
+			response = (JSONObject) ((JSONObject) RequestFunctions.makeRequest(String.format("https://api.sunrisesunset.io/json?lat=%s&lng=%s&timezone=UTC", lat, lon))).get("results");
+		} catch (RequestFunctions.HTTPResponseException e) {
+			throw new IOException("Server/client error (HTTP error " + e.getMessage() + ")");
+		}
+
+		sunriseTime = response.get("sunrise").toString();
+		sunsetTime = response.get("sunset").toString();
+
+		if (sunriseTime.equalsIgnoreCase("null") || sunsetTime.equalsIgnoreCase("null"))
+			throw new ConfigurationException("Time(s) returned null. Check the sunrise/sunset longitude and latitude.");
+
+		DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("h:mm:ss a");
+		LocalDate currentDate = LocalDate.now(ZoneId.of("UTC"));
+		sunriseTime = ZonedDateTime.of(currentDate, LocalTime.parse(sunriseTime, timeFormatter), ZoneId.of("UTC")).withZoneSameInstant(timeZone.toZoneId()).format(timeFormatter);
+		sunsetTime = ZonedDateTime.of(currentDate, LocalTime.parse(sunsetTime, timeFormatter), ZoneId.of("UTC")).withZoneSameInstant(timeZone.toZoneId()).format(timeFormatter);
+	}
+
+	public String getSunriseTime() {
+		return sunriseTime;
+	}
+
+	public String getSunsetTime() {
+		return sunsetTime;
+	}
+}

src/main/java/io/github/jack1424/realTimeWeather/requests/WeatherRequestObject.java

@@ -0,0 +1,52 @@
+package io.github.jack1424.realTimeWeather.requests;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.ParseException;
+
+import javax.naming.ConfigurationException;
+import java.io.IOException;
+import java.net.ProtocolException;
+import java.net.URISyntaxException;
+
+public class WeatherRequestObject {
+	private boolean rain = false, thunder = false;
+
+	public WeatherRequestObject(String apiKey, String lat, String lon) throws IOException, ParseException, ConfigurationException, URISyntaxException {
+		JSONArray conditions;
+		try {
+			conditions = (JSONArray) ((JSONObject) RequestFunctions.makeRequest(String.format("https://api.openweathermap.org/data/2.5/weather?lat=%s&lon=%s&appid=%s", lat, lon, apiKey))).get("weather");
+		} catch (RequestFunctions.HTTPResponseException e) {
+			int responseCode = Integer.parseInt(e.getMessage());
+			if (responseCode > 499) {
+				throw new ProtocolException("Server/client error (HTTP error " + responseCode + ")");
+			} else if (responseCode > 399) {
+				String message = "Error when getting weather information: ";
+
+				if (responseCode == 401)
+					throw new ConfigurationException(message + "API key invalid. Check the Wiki for troubleshooting steps.");
+				else
+					throw new ProtocolException(message + "Unknown error");
+			} else {
+				throw new IOException("Server/client error (HTTP error " + e.getMessage() + ")");
+			}
+		}
+
+		for (Object rawCondition : conditions) {
+			int id = Integer.parseInt(String.valueOf(((JSONObject) rawCondition).get("id")));
+			while (id >= 10)
+				id /= 10;
+
+			rain = id == 2 || id == 3 || id == 5 || id == 6;
+			thunder = id == 2;
+		}
+	}
+
+	public boolean isRaining() {
+		return rain;
+	}
+
+	public boolean isThundering() {
+		return thunder;
+	}
+}

src/main/java/io/github/jack1424/realtimeweather/RealTimeWeather.java

@@ -1,30 +0,0 @@
-package io.github.jack1424.realtimeweather;
-
-import org.bstats.bukkit.Metrics;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.util.logging.Logger;
-
-public final class RealTimeWeather extends JavaPlugin {
-	private final Logger logger = getLogger();
-
-	@Override
-	public void onEnable() {
-		logger.info("Starting...");
-
-		// TODO: Revamp metrics?
-		Metrics metrics = new Metrics(this, 16709);
-		/*
-		metrics.addCustomChart(new SimplePie("weather_sync_enabled", () -> String.valueOf(config.isWeatherEnabled())));
-		metrics.addCustomChart(new SimplePie("sunrise_sunset_source", () -> String.valueOf(config.getSunriseSunset())));
-		metrics.addCustomChart(new SimplePie("time_sync_enabled", () -> String.valueOf(config.isTimeEnabled())));
-		*/
-
-		logger.info("Started!");
-	}
-
-	@Override
-	public void onDisable() {
-		logger.info("Stopping...");
-	}
-}

src/main/resources/plugin.yml

@@ -1,9 +1,8 @@
+main: io.github.jack1424.realTimeWeather.RealTimeWeather
 name: RealTimeWeather
 version: '${version}'
-main: io.github.jack1424.realtimeweather.RealTimeWeather
 description: Sync your Minecraft server's time and weather with the real world
-author: Jack1424
+api-version: '1.21'
 load: POSTWORLD
-website: https://github.com/Jack1424/RealTimeWeather
-api-version: '1.21.5'
-folia-supported: true
+author: Jack1424
+website: github.com/Jack1424/RealTimeWeather