Upstream/WorldSystem
1
0
Fork 0
mirror of https://github.com/trainerlord/WorldSystem.git synced 2025-02-02 23:01:34 +01:00
Code Issues Projects Releases Wiki Activity

Changed host for autoupdate

Browse Source
This commit is contained in:
Butzlabben 2019-02-10 15:02:04 +01:00
parent 01bd06b845
commit 33e0c3de9f
18 changed files with 84 additions and 1054 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
WorldSystem/pom.xml
View File

@ -3,7 +3,7 @@
<modelVersion>4.0.0</modelVersion>
<groupId>de.butzlabben.world</groupId>
<artifactId>WorldSystem</artifactId>
<version>2.4.2</version>
<version>2.4.2.1</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.build.number>-</project.build.number>

166
WorldSystem/src/main/java/de/butzlabben/autoupdater/UpdateInformations.java
View File

@ -1,83 +1,83 @@
package de.butzlabben.autoupdater;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import de.butzlabben.world.WorldSystem;
/**
* @author Butzlabben
* @since 02.05.2018
*/
public class UpdateInformations {
private final String version, url, plugin;
private final boolean silent;
public static synchronized UpdateInformations getInformations() {
String json = callURL("https://seagiants.eu/worldsystem/info.php?version=" + WorldSystem.getInstance().getDescription().getVersion());
Gson gson = new GsonBuilder().create();
UpdateInformations ui = gson.fromJson(json, UpdateInformations.class);
return ui;
}
public static String callURL(String URL) {
StringBuilder sb = new StringBuilder();
URLConnection urlConn = null;
InputStreamReader in = null;
try {
URL url = new URL(URL);
urlConn = url.openConnection();
if (urlConn != null)
urlConn.setReadTimeout(60 * 1000);
if (urlConn != null && urlConn.getInputStream() != null) {
in = new InputStreamReader(urlConn.getInputStream(), Charset.defaultCharset());
BufferedReader bufferedReader = new BufferedReader(in);
if (bufferedReader != null) {
int cp;
while ((cp = bufferedReader.read()) != -1) {
sb.append((char) cp);
}
bufferedReader.close();
}
}
in.close();
} catch (Exception e) {
}
return sb.toString();
}
public String getVersion() {
return version;
}
public String getURL() {
return url;
}
public String getPlugin() {
return plugin;
}
public boolean isSilent() {
return silent;
}
public UpdateInformations(String version, String url, String plugin, boolean silent) {
this.version = version;
this.url = url;
this.plugin = plugin;
this.silent = silent;
}
}
package de.butzlabben.autoupdater;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import de.butzlabben.world.WorldSystem;
/**
* @author Butzlabben
* @since 02.05.2018
*/
public class UpdateInformations {
private final String version, url, plugin;
private final boolean silent;
public static synchronized UpdateInformations getInformations() {
String json = callURL("https://zendilu.net/butzlabben/worldsystem/info.php?version=" + WorldSystem.getInstance().getDescription().getVersion());
Gson gson = new GsonBuilder().create();
UpdateInformations ui = gson.fromJson(json, UpdateInformations.class);
return ui;
}
public static String callURL(String URL) {
StringBuilder sb = new StringBuilder();
URLConnection urlConn = null;
InputStreamReader in = null;
try {
URL url = new URL(URL);
urlConn = url.openConnection();
if (urlConn != null)
urlConn.setReadTimeout(60 * 1000);
if (urlConn != null && urlConn.getInputStream() != null) {
in = new InputStreamReader(urlConn.getInputStream(), Charset.defaultCharset());
BufferedReader bufferedReader = new BufferedReader(in);
if (bufferedReader != null) {
int cp;
while ((cp = bufferedReader.read()) != -1) {
sb.append((char) cp);
}
bufferedReader.close();
}
}
in.close();
} catch (Exception e) {
}
return sb.toString();
}
public String getVersion() {
return version;
}
public String getURL() {
return url;
}
public String getPlugin() {
return plugin;
}
public boolean isSilent() {
return silent;
}
public UpdateInformations(String version, String url, String plugin, boolean silent) {
this.version = version;
this.url = url;
this.plugin = plugin;
this.silent = silent;
}
}

61
WorldSystem/src/main/java/de/butzlabben/world/command/WSAddmemberCommand.java
View File

@ -1,61 +0,0 @@
package de.butzlabben.world.command;
import java.io.IOException;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.event.WorldAddmemberEvent;
public class WSAddmemberCommand implements CommandExecutor{
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if(args.length != 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage", WorldSystem.getInstance().getCommand("ws addmember").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
@SuppressWarnings("deprecation")
OfflinePlayer a = Bukkit.getOfflinePlayer(args[1]);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
if (a == null) {
p.sendMessage(MessageConfig.getNotRegistered().replaceAll("%player", args[1]));
return true;
} else if (wc.isMember(a.getUniqueId())) {
p.sendMessage(MessageConfig.getAlreadyMember());
return true;
}
WorldAddmemberEvent event = new WorldAddmemberEvent(a.getUniqueId(), dc.getWorldname(), p);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled())
return true;
wc.addMember(a.getUniqueId());
try {
wc.save();
} catch (IOException e) {
p.sendMessage(PluginConfig.getPrefix() + "§cSomething went wrong");
e.printStackTrace();
}
p.sendMessage(MessageConfig.getMemberAdded().replaceAll("%player", a.getName()));
return true;
}
}

26
WorldSystem/src/main/java/de/butzlabben/world/command/WSConfirmCommand.java
View File

@ -1,26 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import de.butzlabben.autoupdater.AutoUpdater;
import de.butzlabben.world.config.PluginConfig;
/**
* @author Butzlabben
* @since 02.05.2018
*/
public class WSConfirmCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (AutoUpdater.getInstance().confirmed()) {
cs.sendMessage(PluginConfig.getPrefix() + "§cAlready confirmed or no confirm needed");
return true;
}
AutoUpdater.getInstance().confirm();
cs.sendMessage(PluginConfig.getPrefix() + "§aAutoupdate confirmed, §crestart §ato apply changes");
return true;
}
}

76
WorldSystem/src/main/java/de/butzlabben/world/command/WSDeleteCommand.java
View File

@ -1,76 +0,0 @@
package de.butzlabben.world.command;
import java.io.File;
import org.apache.commons.io.FileUtils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.event.WorldDeleteEvent;
import de.butzlabben.world.wrapper.SystemWorld;
public class WSDeleteCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command arg1, String arg2, String[] args) {
if (args.length < 2) {
cs.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws delete").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(args[1]);
if (!dc.hasWorld()) {
cs.sendMessage(MessageConfig.getNoWorldOther());
return true;
}
String worldname = dc.getWorldname();
SystemWorld sw = SystemWorld.getSystemWorld(worldname);
WorldDeleteEvent event = new WorldDeleteEvent(cs, sw);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled())
return true;
if (sw != null && sw.isLoaded())
sw.directUnload(Bukkit.getWorld(worldname));
Bukkit.getScheduler().runTaskLater(WorldSystem.getInstance(), () -> {
OfflinePlayer op = dc.getOwner();
String uuid = op.getUniqueId().toString();
File dir = new File(PluginConfig.getWorlddir() + "/" + worldname);
if(!dir.exists())
dir = new File(Bukkit.getWorldContainer(), worldname);
if (dir.exists())
try {
FileUtils.deleteDirectory(dir);
} catch (Exception e) {
cs.sendMessage(MessageConfig.getUnknownError());
e.printStackTrace();
}
File dconfig = new File("plugins//WorldSystem//dependence.yml");
YamlConfiguration cfg = YamlConfiguration.loadConfiguration(dconfig);
cfg.set("Dependences." + uuid + ".ID", null);
cfg.set("Dependences." + uuid + ".ActualName", null);
cfg.set("Dependences." + uuid, null);
try {
cfg.save(dconfig);
} catch (Exception e) {
cs.sendMessage(MessageConfig.getUnknownError());
e.printStackTrace();
}
cs.sendMessage(MessageConfig.getDeleteWorldOther().replaceAll("%player", op.getName()));
if (op.isOnline()) {
Player p1 = Bukkit.getPlayer(op.getUniqueId());
p1.sendMessage(MessageConfig.getDeleteWorldOwn());
}
}, 10);
return true;
}
}

69
WorldSystem/src/main/java/de/butzlabben/world/command/WSDelmemberCommand.java
View File

@ -1,69 +0,0 @@
package de.butzlabben.world.command;
import java.io.IOException;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.event.WorldRemovememberEvent;
public class WSDelmemberCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws delmember").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
@SuppressWarnings("deprecation")
OfflinePlayer a = Bukkit.getOfflinePlayer(args[1]);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
if (a == null) {
p.sendMessage(MessageConfig.getNotRegistered().replaceAll("%player", args[1]));
return true;
} else if (!wc.isMember(a.getUniqueId())) {
p.sendMessage(MessageConfig.getNoMemberOwn());
return true;
}
WorldRemovememberEvent event = new WorldRemovememberEvent(a.getUniqueId(), dc.getWorldname(), p);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled())
return true;
wc.removeMember(a.getUniqueId());
if (a.isOnline()) {
Player t = (Player) a;
if (t.getWorld().getName().equals(new DependenceConfig(p).getWorldname())) {
t.teleport(PluginConfig.getSpawn());
t.setGameMode(PluginConfig.getSpawnGamemode());
}
}
try {
wc.save();
} catch (IOException e) {
p.sendMessage(PluginConfig.getPrefix() + "§cSomething went wrong");
e.printStackTrace();
}
p.sendMessage(MessageConfig.getMemberRemoved().replaceAll("%player", a.getName()));
return true;
}
}

52
WorldSystem/src/main/java/de/butzlabben/world/command/WSFireCommand.java
View File

@ -1,52 +0,0 @@
package de.butzlabben.world.command;
import java.io.IOException;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.event.WorldToggleFireEvent;
import de.butzlabben.world.wrapper.SystemWorld;
public class WSFireCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
Player p = (Player) cs;
if (args.length > 1) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws fire").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
boolean fire = wc.isFire();
WorldToggleFireEvent event = new WorldToggleFireEvent(p, SystemWorld.getSystemWorld(dc.getWorldname()), fire);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled())
return true;
wc.setFire(p.getUniqueId(), !fire);
try {
wc.save();
} catch (IOException e) {
p.sendMessage(PluginConfig.getPrefix() + "§cSomething went wrong");
e.printStackTrace();
}
fire = wc.isFire();
if (fire) {
p.sendMessage(MessageConfig.getToggleFireEnabled());
} else {
p.sendMessage(MessageConfig.getToggleFireDisabled());
}
return true;
}
}

62
WorldSystem/src/main/java/de/butzlabben/world/command/WSGetCommand.java
View File

@ -1,62 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.gui.WorldChooseGUI;
import de.butzlabben.world.wrapper.SystemWorld;
import de.butzlabben.world.wrapper.WorldTemplate;
import de.butzlabben.world.wrapper.WorldTemplateProvider;
public class WSGetCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
// create New Entry
DependenceConfig dc = new DependenceConfig(p);
if (dc.hasWorld()) {
p.sendMessage(MessageConfig.getWorldAlreadyExists());
return true;
}
if (PluginConfig.isMultiChoose()) {
if (args.length >= 2) {
String key = args[1];
WorldTemplate template = WorldTemplateProvider.getInstace().getTemplate(key);
if (template != null) {
create(p, template);
return true;
}
}
p.openInventory(new WorldChooseGUI().getInventory(p));
} else {
WorldTemplate template = WorldTemplateProvider.getInstace()
.getTemplate(PluginConfig.getDefaultWorldTemplate());
if(template != null)
create(p, template);
else {
p.sendMessage(PluginConfig.getPrefix() + "§cError in config at \"worldtemplates.default\"");
p.sendMessage(PluginConfig.getPrefix() + "§cPlease contact an administrator");
}
}
return true;
}
private void create(Player p, WorldTemplate template) {
Bukkit.getScheduler().runTask(WorldSystem.getInstance(), () -> {
if (SystemWorld.create(p, template))
p.sendMessage(MessageConfig.getSettingUpWorld());
});
}
}

49
WorldSystem/src/main/java/de/butzlabben/world/command/WSHomeCommand.java
View File

@ -1,49 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.wrapper.SystemWorld;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSHomeCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 1) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws home").getUsage()));
return true;
}
String worldname = p.getWorld().getName();
DependenceConfig dc = new DependenceConfig(p);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
WorldPlayer wp = new WorldPlayer(p, worldname);
if (wp.isOnSystemWorld()) {
SystemWorld.tryUnloadLater(Bukkit.getWorld(worldname));
}
SystemWorld sw = SystemWorld.getSystemWorld(dc.getWorldname());
if(sw == null) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
if (sw.isLoaded()) {
sw.teleportToWorldSpawn(p);
} else {
sw.load(p);
}
return true;
}
}

45
WorldSystem/src/main/java/de/butzlabben/world/command/WSInfoCommand.java
View File

@ -1,45 +0,0 @@
package de.butzlabben.world.command;
import java.util.Iterator;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSInfoCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
Player p = (Player) cs;
WorldPlayer wp = new WorldPlayer(p, p.getWorld().getName());
if (!wp.isOnSystemWorld()) {
p.sendMessage(MessageConfig.getNotOnWorld());
return true;
}
WorldConfig wc = WorldConfig.getWorldConfig(p.getWorld().getName());
int id = wc.getId();
String owner = wc.getOwnerName();
boolean fire = wc.isFire();
boolean tnt = wc.isTnt();
p.sendMessage(MessageConfig.getInfoOwner().replaceAll("%data", owner));
p.sendMessage(MessageConfig.getInfoId().replaceAll("%data", "" + id));
p.sendMessage(MessageConfig.getInfoTnt().replaceAll("%data",
tnt ? MessageConfig.getInfoEnabled() : MessageConfig.getInfoDisabled()));
p.sendMessage(MessageConfig.getInfoFire().replaceAll("%data",
fire ? MessageConfig.getInfoEnabled() : MessageConfig.getInfoDisabled()));
StringBuilder sb = new StringBuilder();
Iterator<String> it = wc.getMembersWithNames().values().iterator();
while (it.hasNext()) {
sb.append(it.next());
if(it.hasNext())
sb.append(" ");
}
p.sendMessage(MessageConfig.getInfoMember().replaceAll("%data", sb.toString().trim()));
return true;
}
}

48
WorldSystem/src/main/java/de/butzlabben/world/command/WSLeaveCommand.java
View File

@ -1,48 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.wrapper.SystemWorld;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSLeaveCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 1) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws leave").getUsage()));
return true;
}
String worldname = p.getWorld().getName();
WorldPlayer wp = new WorldPlayer(p, worldname);
if (wp.isOnSystemWorld()) {
// Extra safety for #2
if (PluginConfig.getSpawn().getWorld() == null) {
Bukkit.getConsoleSender().sendMessage(PluginConfig.getPrefix() + "§cThe spawn is not properly set");
cs.sendMessage(PluginConfig.getPrefix() + "§cThe spawn is not properly set");
return true;
}
p.teleport(PluginConfig.getSpawn());
p.setGameMode(PluginConfig.getSpawnGamemode());
World w = Bukkit.getWorld(p.getWorld().getName());
SystemWorld.tryUnloadLater(w);
} else {
p.sendMessage(MessageConfig.getNotOnWorld());
}
return true;
}
}

162
WorldSystem/src/main/java/de/butzlabben/world/command/WSResetCommand.java
View File

@ -1,162 +0,0 @@
package de.butzlabben.world.command;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import org.apache.commons.io.FileUtils;
import org.bukkit.Bukkit;
import org.bukkit.World.Environment;
import org.bukkit.WorldCreator;
import org.bukkit.WorldType;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.event.WorldResetEvent;
import de.butzlabben.world.gui.WorldChooseGUI;
import de.butzlabben.world.wrapper.SystemWorld;
import de.butzlabben.world.wrapper.WorldTemplate;
import de.butzlabben.world.wrapper.WorldTemplateProvider;
public class WSResetCommand implements CommandExecutor {
private ArrayList<Player> toConfirm = new ArrayList<>();
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
Player p = (Player) cs;
if (args.length > 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws reset").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
String worldname = dc.getWorldname();
SystemWorld sw = SystemWorld.getSystemWorld(worldname);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
if (args.length > 1) {
if (args[1].equals("confirm")) {
if (sw.isLoaded())
sw.directUnload(Bukkit.getWorld(worldname));
if (!toConfirm.contains(p)) {
p.sendMessage(MessageConfig.getNoRequestSend());
return true;
}
WorldResetEvent event = new WorldResetEvent(cs, sw);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled())
return true;
if (sw.isLoaded()) {
p.sendMessage(MessageConfig.getWorldStillLoaded());
return true;
}
File f = new File(PluginConfig.getWorlddir() + "/" + worldname);
if (!PluginConfig.isMultiChoose()) {
WorldTemplate template = WorldTemplateProvider.getInstace()
.getTemplate(PluginConfig.getDefaultWorldTemplate());
if (template != null)
createWorld(p, worldname, f, new File(template.getPath()), sw);
else {
p.sendMessage(PluginConfig.getPrefix() + "§cError in config at \"worldtemplates.default\"");
p.sendMessage(PluginConfig.getPrefix() + "§cPlease contact an administrator");
}
} else {
WorldChooseGUI.letChoose(p, (template) -> {
if (template != null)
createWorld(p, worldname, f, new File(template.getPath()), sw);
else {
p.sendMessage(PluginConfig.getPrefix() + "§cError in config at \"worldtemplates.default\"");
p.sendMessage(PluginConfig.getPrefix() + "§cPlease contact an administrator");
}
});
}
} else {
p.sendMessage(MessageConfig.getInvalidInput().replaceAll("input", args[0]));
return true;
}
} else if (args.length == 1) {
if (sw.isLoaded())
sw.directUnload(Bukkit.getWorld(worldname));
if (toConfirm.contains(p)) {
p.sendMessage(MessageConfig.getRequestAlreadySent());
return true;
}
int time = PluginConfig.getRequestExpire();
p.sendMessage(MessageConfig.getConfirmRequest().replaceAll("%command", "/ws reset confirm"));
p.sendMessage(MessageConfig.getTimeUntilExpires().replaceAll("%time", String.valueOf(time)));
toConfirm.add(p);
Bukkit.getScheduler().runTaskLater(WorldSystem.getInstance(), () -> {
if (toConfirm.contains(p)) {
p.sendMessage(MessageConfig.getRequestExpired());
toConfirm.remove(p);
}
}, time * 20L);
}
return true;
}
private void createWorld(Player p, String worldname, File f, File exampleworld, SystemWorld sw) {
File[] files = f.listFiles();
for (File file : files) {
if (file.getName().equals("worldconfig.yml"))
continue;
FileUtils.deleteQuietly(file);
}
try {
if (exampleworld.isDirectory())
FileUtils.copyDirectory(exampleworld, f);
toConfirm.remove(p);
FileUtils.moveDirectoryToDirectory(f, Bukkit.getWorldContainer(), false);
WorldConfig config = WorldConfig.getWorldConfig(worldname);
config.setHome(null);
config.save();
p.sendMessage(MessageConfig.getWorldReseted());
// For fast worldcreating after reset
WorldCreator creator = new WorldCreator(worldname);
long seed = PluginConfig.getSeed();
Environment env = PluginConfig.getEnvironment();
WorldType type = PluginConfig.getWorldType();
if (seed != 0)
creator.seed(seed);
creator.type(type);
creator.environment(env);
String generator = PluginConfig.getGenerator();
if (!generator.trim().isEmpty())
creator.generator(generator);
sw.setCreating(true);
// For #16
WorldSystem.getInstance().getAdapter().create(creator, sw, () -> {
if (p != null && p.isOnline())
p.sendMessage(MessageConfig.getWorldCreated());
});
} catch (IOException e) {
e.printStackTrace();
p.sendMessage(MessageConfig.getUnknownError());
System.err.println("Couldn't reset world of " + p.getName());
}
}
}

43
WorldSystem/src/main/java/de/butzlabben/world/command/WSSethomeCommand.java
View File

@ -1,43 +0,0 @@
package de.butzlabben.world.command;
import java.io.IOException;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.wrapper.WorldPlayer;
/**
* @author Butzlabben
* @since 14.08.2018
*/
public class WSSethomeCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String arg2, String[] args) {
Player p = (Player) cs;
WorldPlayer wp = new WorldPlayer(p);
if (!wp.isOnSystemWorld()) {
p.sendMessage(MessageConfig.getNotOnWorld());
return true;
}
if (!wp.isOwnerofWorld()) {
p.sendMessage(MessageConfig.getNoPermission());
return true;
}
WorldConfig config = WorldConfig.getWorldConfig(p.getWorld().getName());
config.setHome(p.getLocation());
try {
config.save();
p.sendMessage(MessageConfig.getHomeSet());
} catch (IOException e) {
p.sendMessage(MessageConfig.getUnknownError() + ": " + e.getMessage());
e.printStackTrace();
}
return true;
}
}

66
WorldSystem/src/main/java/de/butzlabben/world/command/WSTPCommand.java
View File

@ -1,66 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.wrapper.SystemWorld;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSTPCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws tp").getUsage()));
return true;
}
// There where some problems with /ws tp <own name>
if(args[1].equalsIgnoreCase(p.getName()) || args[1].equalsIgnoreCase(p.getUniqueId().toString())) {
p.chat("/ws home");
return true;
}
DependenceConfig dc = new DependenceConfig(args[1]);
String worldname = dc.getWorldNamebyOfflinePlayer();
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOther());
return true;
}
SystemWorld sw = SystemWorld.getSystemWorld(worldname);
WorldPlayer wp1 = new WorldPlayer(p, p.getWorld().getName());
WorldPlayer wp = new WorldPlayer(p, worldname);
if (p.getWorld().getName().equals(worldname)) {
sw.teleportToWorldSpawn(p);
return true;
}
if (!p.hasPermission("ws.tp.world")) {
if (!wp.isMemberofWorld(worldname) && !wp.isOwnerofWorld()) {
p.sendMessage(MessageConfig.getNoMemberOther());
return true;
}
}
if (wp1.isOnSystemWorld()) {
World w = p.getWorld();
SystemWorld.tryUnloadLater(w);
}
if (sw != null)
if (!sw.isLoaded()) {
sw.load(p);
} else {
sw.teleportToWorldSpawn(p);
}
return true;
}
}

52
WorldSystem/src/main/java/de/butzlabben/world/command/WSTnTCommand.java
View File

@ -1,52 +0,0 @@
package de.butzlabben.world.command;
import java.io.IOException;
import org.bukkit.Bukkit;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.event.WorldToggleTntEvent;
import de.butzlabben.world.wrapper.SystemWorld;
public class WSTnTCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
Player p = (Player) cs;
if(args.length > 1) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage", WorldSystem.getInstance().getCommand("ws tnt").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
boolean tnt = wc.isTnt();
WorldToggleTntEvent event = new WorldToggleTntEvent(p, SystemWorld.getSystemWorld(dc.getWorldname()), tnt);
Bukkit.getPluginManager().callEvent(event);
if (event.isCancelled())
return true;
wc.setTnt(p.getUniqueId(), !tnt);
try {
wc.save();
} catch (IOException e) {
p.sendMessage(PluginConfig.getPrefix() + "§cSomething went wrong");
e.printStackTrace();
}
tnt = wc.isTnt();
if (tnt) {
p.sendMessage(MessageConfig.getToggleTntEnabled());
} else {
p.sendMessage(MessageConfig.getToggleTntDisabled());
}
return true;
}
}

53
WorldSystem/src/main/java/de/butzlabben/world/command/WSToggleBuildCommand.java
View File

@ -1,53 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSToggleBuildCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws togglebuild").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
@SuppressWarnings("deprecation")
OfflinePlayer a = Bukkit.getOfflinePlayer(args[1]);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
if (!wc.isMember(a.getUniqueId())) {
p.sendMessage(MessageConfig.getNoMemberOwn());
return true;
}
WorldPlayer wp = new WorldPlayer(a, dc.getWorldname());
if (wp.isOwnerofWorld()) {
p.sendMessage(PluginConfig.getPrefix() + "§cYou are the owner");
return true;
}
if (wp.toggleBuild()) {
p.sendMessage(MessageConfig.getToggleBuildEnabled().replaceAll("%player", a.getName()));
} else {
p.sendMessage(MessageConfig.getToggleBuildDisabled().replaceAll("%player", a.getName()));
}
return true;
}
}

53
WorldSystem/src/main/java/de/butzlabben/world/command/WSToggleGMCommand.java
View File

@ -1,53 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSToggleGMCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws togglegm").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
@SuppressWarnings("deprecation")
OfflinePlayer a = Bukkit.getOfflinePlayer(args[1]);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
if (!wc.isMember(a.getUniqueId())) {
p.sendMessage(MessageConfig.getNoMemberOwn());
return true;
}
WorldPlayer wp = new WorldPlayer(a, dc.getWorldname());
if (wp.isOwnerofWorld()) {
p.sendMessage(PluginConfig.getPrefix() + "§cYou are the owner");
return true;
}
if (wp.toggleGamemode()) {
p.sendMessage(MessageConfig.getToggleGameModeEnabled().replaceAll("%player", a.getName()));
} else {
p.sendMessage(MessageConfig.getToggleGameModeDisabled().replaceAll("%player", a.getName()));
}
return true;
}
}

53
WorldSystem/src/main/java/de/butzlabben/world/command/WSToggleTPCommand.java
View File

@ -1,53 +0,0 @@
package de.butzlabben.world.command;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import de.butzlabben.world.WorldSystem;
import de.butzlabben.world.config.DependenceConfig;
import de.butzlabben.world.config.MessageConfig;
import de.butzlabben.world.config.PluginConfig;
import de.butzlabben.world.config.WorldConfig;
import de.butzlabben.world.wrapper.WorldPlayer;
public class WSToggleTPCommand implements CommandExecutor {
@Override
public boolean onCommand(CommandSender cs, Command cmd, String label, String[] args) {
if (!(cs instanceof Player))
return true;
Player p = (Player) cs;
if (args.length != 2) {
p.sendMessage(MessageConfig.getWrongUsage().replaceAll("%usage",
WorldSystem.getInstance().getCommand("ws toggletp").getUsage()));
return true;
}
DependenceConfig dc = new DependenceConfig(p);
if (!dc.hasWorld()) {
p.sendMessage(MessageConfig.getNoWorldOwn());
return true;
}
@SuppressWarnings("deprecation")
OfflinePlayer a = Bukkit.getOfflinePlayer(args[1]);
WorldConfig wc = WorldConfig.getWorldConfig(dc.getWorldname());
if (!wc.isMember(a.getUniqueId())) {
p.sendMessage(MessageConfig.getNoMemberOwn());
return true;
}
WorldPlayer wp = new WorldPlayer(a, dc.getWorldname());
if (wp.isOwnerofWorld()) {
p.sendMessage(PluginConfig.getPrefix() + "§cYou are the owner");
return true;
}
if (wp.toggleTeleport()) {
p.sendMessage(MessageConfig.getToggleTeleportEnabled().replaceAll("%player", a.getName()));
} else {
p.sendMessage(MessageConfig.getToggleTeleportDisabled().replaceAll("%player", a.getName()));
}
return true;
}
}