change line endings
This commit is contained in:
Jack
@@ -1,391 +0,0 @@
|
||||
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.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 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);
|
||||
}
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
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().contains("time set"))
|
||||
|| (config.getBlockWeatherCommand() && config.isWeatherEnabled() && event.getMessage().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().contains("time set"))
|
||||
|| (config.getBlockWeatherCommand() && config.isWeatherEnabled() && event.getCommand().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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,203 +0,0 @@
|
||||
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.getWeatherLatitude(), config.getWeatherLongitude());
|
||||
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));
|
||||
int currentMinutes = currentTime.getHour() * 60 + currentTime.getMinute();
|
||||
|
||||
if (currentMinutes >= sunriseMinutes && currentMinutes < sunsetMinutes) {
|
||||
return ((currentMinutes - sunriseMinutes) / (sunsetMinutes - sunriseMinutes) * 13569) + 23041;
|
||||
} else {
|
||||
if (currentMinutes < sunriseMinutes)
|
||||
currentMinutes += 1440;
|
||||
|
||||
return ((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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
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));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
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.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 {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
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;
|
||||
|
||||
public class WeatherRequestObject {
|
||||
private boolean rain = false, thunder = false;
|
||||
|
||||
public WeatherRequestObject(String apiKey, String lat, String lon) throws IOException, ParseException, ConfigurationException {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
# RealTimeWeather Configuration File (v2.0.0)
|
||||
# You can find detailed instructions at: https://github.com/Jack1424/RealTimeWeather/wiki#editing-the-configuration-file
|
||||
|
||||
######################################## Real Time Weather Settings ##################################################
|
||||
# By default, RealTimeWeather will check if an update is available every 24 hours (1734000 ticks) #
|
||||
# You can change the interval here (or set to 0 to disable update checks) #
|
||||
# If this is disabled, RealTimeWeather will still check for updates on startup #
|
||||
# You can find a handy tick calculator here: https://mapmaking.fr/tick/ #
|
||||
UpdateCheckInterval: 1734000
|
||||
#
|
||||
# Set to true for various console messages when time and weather sync are executed #
|
||||
# This is useful if the plugin is not working, and you want to find out what's wrong #
|
||||
# This will also provide error messages even when an error is caught and managed by RTM #
|
||||
# Note: There will be no messages during a time sync because they happen very frequently #
|
||||
# Note: Unhandled plugin errors will still be logged regardless of the debug value #
|
||||
Debug: false
|
||||
######################################################################################################################
|
||||
|
||||
################################# TIME SYNC SETTINGS #################################################################
|
||||
# Set to true to enable time syncing, or false to disable #
|
||||
# All time-related settings will be ignored if this is set to false #
|
||||
SyncTime: false
|
||||
# #
|
||||
# By default, RealTimeWeather will apply the time sync settings below to all worlds #
|
||||
# End and nether worlds will not be synced #
|
||||
# If you ony want to enable time syncing in some worlds on your server, set this to false #
|
||||
TimeSyncAllWorlds: true
|
||||
# #
|
||||
# List the worlds that you want RealTimeWeather to sync the time in #
|
||||
# End and nether worlds will not be synced #
|
||||
# This only works if TimeSyncAllWorlds is set to false #
|
||||
TimeSyncWorlds:
|
||||
- world
|
||||
# #
|
||||
# Set to false to enable the /time set command (not recommended) #
|
||||
BlockTimeSetCommand: true
|
||||
# #
|
||||
# Prevent players from sleeping in beds at night (they will still be able to set their spawn point) #
|
||||
# If you disable this, strange things could happen #
|
||||
DisableBedsAtNight: true
|
||||
# The message sent to players when they try to sleep at night when beds are disabled #
|
||||
DisableBedsAtNightMessage: ''
|
||||
# #
|
||||
# You can change the time between time syncs from the default (5 seconds) below #
|
||||
TimeSyncInterval: 100
|
||||
# #
|
||||
# Enter the time zone that you want to sync your world(s) with #
|
||||
# This location CAN be different from your chosen weather location #
|
||||
# You can find a full list of timezones here: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones#List #
|
||||
Timezone: 'Etc/UTC'
|
||||
# #
|
||||
# Set to default to use "default" Minecraft sunrise/sunset times (always 5:02 AM and 6:36 PM respectfully) #
|
||||
# Set to real to sync the sunrise/sunset times with a real world location (configure below) #
|
||||
# Set to custom to use custom sunrise/sunset times (configure below) #
|
||||
SunriseSunset: default
|
||||
# Enter the latitude and longitude of the location that you want to sync the sunrise and sunset with #
|
||||
# If you set this to a place with no sunrise/sunset (like the North Pole), the default times will be used #
|
||||
# NOTE: You can find the latitude and longitude of a location at https://www.latlong.net/ #
|
||||
# This feature is provided for free by SunriseSunset.io #
|
||||
SunriseSunsetLatitude: '0'
|
||||
SunriseSunsetLongitude: '0'
|
||||
# Enter the times that you would like to use for sunrise and sunset #
|
||||
# You MUST include the seconds (even if they're just 00) #
|
||||
# Sunrise is defined as 23041 ticks and sunset is 12610 ticks in-game #
|
||||
SunriseCustomTime: '5:02:27 AM'
|
||||
SunsetCustomTime: '6:36:36 PM'
|
||||
######################################################################################################################
|
||||
|
||||
################################# WEATHER SYNC SETTINGS ##############################################################
|
||||
# Set to true to enable weather syncing, or false to disable #
|
||||
# All weather-related settings will be ignored if this is set to false #
|
||||
SyncWeather: false
|
||||
# #
|
||||
# By default, RealTimeWeather will apply the weather sync settings below to all worlds #
|
||||
# End and nether worlds will not be synced #
|
||||
# If you ony want to enable weather syncing in some worlds on your server, set this to false #
|
||||
WeatherSyncAllWorlds: true
|
||||
# #
|
||||
# List the worlds that you want RealTimeWeather to sync the weather in #
|
||||
# End and nether worlds will not be synced #
|
||||
# This only works if WeatherSyncAllWorlds is set to false #
|
||||
WeatherSyncWorlds:
|
||||
- world
|
||||
# #
|
||||
# Set to false to enable the /weather command (not recommended) #
|
||||
BlockWeatherCommand: true
|
||||
# #
|
||||
# Prevent players from sleeping in beds during a thunderstorm (they will still be able to set their spawn point) #
|
||||
# If you disable this, it could break weather syncing #
|
||||
DisableBedsDuringThunder: true
|
||||
# The message sent to players when they try to sleep during a thunderstorm when beds are disabled #
|
||||
DisableBedsDuringThunderMessage: ''
|
||||
# #
|
||||
# You can change the time between weather syncs from the default (5 minutes) below #
|
||||
# Setting this value below 200 (10 seconds) is not recommended #
|
||||
# The minimum safe value on a free API plan is 40 (2 seconds) #
|
||||
# You can find a handy tick calculator here: https://mapmaking.fr/tick/ #
|
||||
WeatherSyncInterval: 6000
|
||||
# #
|
||||
# In order to access the weather sync feature, create an account at https://openweathermap.org/ #
|
||||
# Then, create an API key at https://openweathermap.org/appid and copy it #
|
||||
# Finally, paste the API key below and DO NOT SHARE IT WITH OTHERS #
|
||||
APIKey: 'API_KEY'
|
||||
# #
|
||||
# Enter the latitude and longitude of the location that you want to sync your world(s) weather with #
|
||||
# NOTE: You can find the latitude and longitude of a location at https://www.latlong.net/ #
|
||||
WeatherLatitude: '0'
|
||||
WeatherLongitude: '0'
|
||||
# #
|
||||
######################################################################################################################
|
||||
@@ -1,8 +0,0 @@
|
||||
main: io.github.jack1424.realTimeWeather.RealTimeWeather
|
||||
name: RealTimeWeather
|
||||
version: '${version}'
|
||||
description: Sync your Minecraft server's time and weather with the real world
|
||||
api-version: '1.21'
|
||||
load: POSTWORLD
|
||||
author: Jack1424
|
||||
website: github.com/Jack1424/RealTimeWeather
|
||||
Reference in New Issue
Block a user