commit 184d8c59cbc395f2af574212f0f55f8cf4df06d4 Author: BuildTools Date: Tue Jan 15 18:16:59 2019 +0100 Initial commit diff --git a/.idea/.name b/.idea/.name new file mode 100644 index 0000000..09564ec --- /dev/null +++ b/.idea/.name @@ -0,0 +1 @@ +Theme \ No newline at end of file diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..4dc3212 --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..15a15b2 --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..4b661a5 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,14 @@ + + + + + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..05431e9 --- /dev/null +++ b/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + + 1.8 + 1.8 + + + me.paradoxpixel + themepark + 1.1 + + + + org.spigotmc + spigot-api + 1.8.8-R0.1-SNAPSHOT + provided + + + \ No newline at end of file diff --git a/src/main/java/me/paradoxpixel/themepark/ThemeParkPlugin.java b/src/main/java/me/paradoxpixel/themepark/ThemeParkPlugin.java new file mode 100644 index 0000000..142b5d0 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/ThemeParkPlugin.java @@ -0,0 +1,118 @@ +package me.paradoxpixel.themepark; + +import me.paradoxpixel.themepark.attraction.AttractionMenu; +import me.paradoxpixel.themepark.attraction.sign.SignManager; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.command.MenuCommand; +import me.paradoxpixel.themepark.command.ThemeParkCommand; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.database.DatabaseHandler; +import me.paradoxpixel.themepark.gui.GUIListener; +import me.paradoxpixel.themepark.listener.ClickListener; +import me.paradoxpixel.themepark.listener.ChangeListener; +import me.paradoxpixel.themepark.listener.PlayerListener; +import me.paradoxpixel.themepark.listener.SignListener; +import org.bukkit.Bukkit; +import org.bukkit.command.CommandMap; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; +import java.lang.reflect.Field; + +public class ThemeParkPlugin extends JavaPlugin { + + private static ThemeParkPlugin instance; + private YamlConfig settings, attraction, message, signs, data; + private DatabaseHandler database; + + @Override + public void onEnable() { + instance = this; + loadConfig(); + loadListener(); + loadCommand(); + loadData(); + loadDatabase(); + } + + private void loadConfig() { + settings = new YamlConfig("settings", this); + attraction = new YamlConfig("attraction", this); + message = new YamlConfig("message", this); + signs = new YamlConfig("signs", this); + data = new YamlConfig("data", this); + } + + private void loadData() { + StatusManager.load(); + AttractionMenu.load(); + } + + private void loadDatabase() { + database = new DatabaseHandler(settings); + } + + private void loadCommand() { + getCommand("status").setExecutor(new MenuCommand()); + + String command = settings.getConfig().getString("command"); + if(command == null || command.isEmpty()) + return; + + try { + final Field bukkitCommandMap = Bukkit.getServer().getClass().getDeclaredField("commandMap"); + + bukkitCommandMap.setAccessible(true); + CommandMap commandMap = (CommandMap) bukkitCommandMap.get(Bukkit.getServer()); + + commandMap.register(command, new ThemeParkCommand(command)); + } catch(ReflectiveOperationException e) { + e.printStackTrace(); + } + } + + private void loadListener() { + PluginManager pm = Bukkit.getPluginManager(); + pm.registerEvents(new GUIListener(), this); + pm.registerEvents(new ClickListener(), this); + pm.registerEvents(new ChangeListener(), this); + pm.registerEvents(new SignListener(), this); + pm.registerEvents(new PlayerListener(), this); + } + + @Override + public void onDisable() { + AttractionMenu.save(); + SignManager.saveSigns(); + database.disconnect(); + instance = null; + } + + public static ThemeParkPlugin getInstance() { + return instance; + } + + public YamlConfig getSettings() { + return settings; + } + + public YamlConfig getAttraction() { + return attraction; + } + + public YamlConfig getMessage() { + return message; + } + + public YamlConfig getSigns() { + return signs; + } + + public YamlConfig getData() { + return data; + } + + public DatabaseHandler getDatabaseHandler() { + return database; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/action/TPUtils.java b/src/main/java/me/paradoxpixel/themepark/action/TPUtils.java new file mode 100644 index 0000000..c91c062 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/action/TPUtils.java @@ -0,0 +1,46 @@ +package me.paradoxpixel.themepark.action; + +import me.paradoxpixel.themepark.api.API; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.attraction.AttractionMenu; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.gui.GUIAction; +import me.paradoxpixel.themepark.utils.Message; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.entity.Minecart; +import org.bukkit.entity.Player; + +public class TPUtils extends GUIAction { + + private String id; + + public TPUtils(String id) { + this.id = id; + } + + @Override + public void click(Player player) { + player.closeInventory(); + Attraction attraction = API.getAttraction(id); + if(attraction == null) + return; + + if(!StatusManager.canTeleport(attraction.getStatus())) { + String message = Message.getMessage("attraction.teleport.status"); + message = message.replace("{name}", attraction.getName()); + message = message.replace("{status}", StatusManager.getName(attraction.getStatus())); + player.sendMessage(Utils.color(message)); + return; + } + + player.teleport(attraction.getLocation()); + if(player.isInsideVehicle()) + if(player.getVehicle() instanceof Minecart) + return; + + String message = Message.getMessage("attraction.teleport.success"); + message = message.replace("{name}", attraction.getName()); + player.sendMessage(Utils.color(message)); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/API.java b/src/main/java/me/paradoxpixel/themepark/api/API.java new file mode 100644 index 0000000..900fda3 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/API.java @@ -0,0 +1,148 @@ +package me.paradoxpixel.themepark.api; + +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.Region; +import me.paradoxpixel.themepark.api.event.attraction.AddAttractionEvent; +import me.paradoxpixel.themepark.api.event.attraction.RemoveAttractionEvent; +import me.paradoxpixel.themepark.api.event.region.AddRegionEvent; +import me.paradoxpixel.themepark.api.event.region.RemoveRegionEvent; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +public class API { + + private static LinkedHashMap regions = new LinkedHashMap<>(); + private static LinkedHashMap attractions = new LinkedHashMap<>(); + + public static void addRegion(Region region) { + if(isRegion(region.getId())) + return; + + if(regions.size() >= 6) + return; + + region = toLower(region); + regions.put(region.getId(), region); + + AddRegionEvent event = new AddRegionEvent(region); + Bukkit.getPluginManager().callEvent(event); + } + + public static boolean isRegion(String id) { + return regions.containsKey(id.toLowerCase()); + } + + public static boolean isRegionFull(String id) { + if(!isRegion(id)) + return false; + + return getRegion(id).getAttractions().size() >= 8; + } + + public static Region getRegion(String id) { + return regions.get(id.toLowerCase()); + } + + public static HashMap getRegions() { + return new LinkedHashMap<>(regions); + } + + public static void removeRegion(String id) { + if(!isRegion(id)) + return; + + HashMap map = new HashMap<>(attractions); + for(Map.Entry entry : map.entrySet()) { + Attraction attraction = entry.getValue(); + if(!attraction.getRegion_id().equalsIgnoreCase(id)) + continue; + + removeAttraction(attraction.getId()); + } + + RemoveRegionEvent event = new RemoveRegionEvent(getRegion(id)); + Bukkit.getPluginManager().callEvent(event); + regions.remove(id.toLowerCase()); + } + + public static void addAttraction(Attraction attraction) { + if(!isRegion(attraction.getRegion_id())) + return; + + if(isRegionFull(attraction.getRegion_id())) + return; + + if(isAttraction(attraction.getId())) + return; + + attraction = toLower(attraction); + getRegion(attraction.getRegion_id()).addAttraction(attraction); + attractions.put(attraction.getId(), attraction); + + AddAttractionEvent event = new AddAttractionEvent(attraction); + Bukkit.getPluginManager().callEvent(event); + } + + public static boolean isAttraction(String id) { + return attractions.containsKey(id.toLowerCase()); + } + + public static Attraction getAttraction(String id) { + return attractions.get(id.toLowerCase()); + } + + public static Attraction getAttractionFromName(String name) { + for(Attraction attraction : attractions.values()) { + if(!color(attraction.getName()).equals(name)) + continue; + + return attraction; + } + + return null; + } + + public static HashMap getAttractions() { + return new LinkedHashMap<>(attractions); + } + + public static void removeAttraction(String id) { + if(!isAttraction(id)) + return; + + Attraction attraction = getAttraction(id); + if(isRegion(attraction.getRegion_id())) + getRegion(attraction.getRegion_id()).removeAttraction(attraction); + + attractions.remove(id.toLowerCase()); + + RemoveAttractionEvent event = new RemoveAttractionEvent(attraction); + Bukkit.getPluginManager().callEvent(event); + } + + private static Region toLower(Region region) { + Region re = new Region(region.getId().toLowerCase(), + region.getName(), + region.getLore()); + + re.setAttractions(region.getAttractions()); + return re; + } + + private static Attraction toLower(Attraction attraction) { + return new Attraction(attraction.getId().toLowerCase(), + attraction.getName(), + attraction.getRegion_id().toLowerCase(), + attraction.getLocation(), + attraction.getType(), + attraction.getStatus()); + } + + private static String color(String string) { + return ChatColor.translateAlternateColorCodes('&', string); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/attraction/Attraction.java b/src/main/java/me/paradoxpixel/themepark/api/attraction/Attraction.java new file mode 100644 index 0000000..d8d8ec6 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/attraction/Attraction.java @@ -0,0 +1,72 @@ +package me.paradoxpixel.themepark.api.attraction; + +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.api.attraction.component.Type; +import me.paradoxpixel.themepark.api.event.attraction.PreStatusChangeEvent; +import me.paradoxpixel.themepark.api.event.attraction.StatusChangeEvent; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +public class Attraction { + + private String id, name, region_id; + private Location location; + private Type type; + private Status status; + + public Attraction(String id, String name, String region_id, Location location, Type type, Status status) { + this.id = id; + this.name = name; + this.region_id = region_id; + this.location = location; + this.type = type; + this.status = type.containsStatus(status) ? status : type.getDefefault(); + } + + public String getId() { + return id; + } + + public String getName() { + return name; + } + + public String getRegion_id() { + return region_id; + } + + public Location getLocation() { + return location; + } + + public void setLocation(Location location) { + this.location = location; + } + + public Type getType() { + return type; + } + + public Status getStatus() { + return status; + } + + public void setStatus(Status status, Player player) { + if(!type.hasStatus()) + return; + + if(!type.containsStatus(status)) + return; + + PreStatusChangeEvent event = new PreStatusChangeEvent(this, player, this.status, status); + Bukkit.getPluginManager().callEvent(event); + if(event.isCancelled()) + return; + + this.status = status; + StatusChangeEvent e = new StatusChangeEvent(this, player, this.status, status); + Bukkit.getPluginManager().callEvent(e); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/attraction/Region.java b/src/main/java/me/paradoxpixel/themepark/api/attraction/Region.java new file mode 100644 index 0000000..a41e236 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/attraction/Region.java @@ -0,0 +1,96 @@ +package me.paradoxpixel.themepark.api.attraction; + +import me.paradoxpixel.themepark.api.event.region.ChangeRegionEvent; +import org.bukkit.Bukkit; +import java.util.ArrayList; +import java.util.List; + +public class Region { + + private String id, name; + private List lore; + private ArrayList attractions; + + public Region(String id, String name, List lore) { + this.id = id; + this.name = name; + this.lore = lore; + this.attractions = new ArrayList<>(); + } + + public String getId() { + return id; + } + + public String getName() { + return name; + } + + public void setName(String string) { + if(string == null || string.equals("")) + return; + + String old = name; + name = string; + + ChangeRegionEvent event = new ChangeRegionEvent(this, old, string, lore, lore); + Bukkit.getPluginManager().callEvent(event); + } + + public List getLore() { + return lore; + } + + public void setLore(List lore) { + List old = lore; + this.lore = lore; + + ChangeRegionEvent event = new ChangeRegionEvent(this, name, name, old, lore); + Bukkit.getPluginManager().callEvent(event); + } + + public void setLore(int i, String string) { + if(lore.size() >= 4 || i >= 4) + return; + + List old = lore; + lore = new ArrayList<>(); + lore.addAll(old); + + if(!string.equals("NULL")) { + if (lore.size() >= i) + for (int a = 0; a <= (i - lore.size()); a++) + lore.add(" "); + + lore.set(i, string); + } else { + lore.remove(i); + } + + ChangeRegionEvent event = new ChangeRegionEvent(this, name, name, old, lore); + Bukkit.getPluginManager().callEvent(event); + } + + public ArrayList getAttractions() { + return attractions; + } + + public void setAttractions(ArrayList attractions) { + this.attractions = attractions; + } + + public void addAttraction(Attraction attraction) { + if(!isAttraction(attraction)) + attractions.add(attraction); + } + + public boolean isAttraction(Attraction attraction) { + return attractions.contains(attraction); + } + + public void removeAttraction(Attraction attraction) { + if(isAttraction(attraction)) + attractions.remove(attraction); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/attraction/component/Status.java b/src/main/java/me/paradoxpixel/themepark/api/attraction/component/Status.java new file mode 100644 index 0000000..78f03e5 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/attraction/component/Status.java @@ -0,0 +1,35 @@ +package me.paradoxpixel.themepark.api.attraction.component; + +public enum Status { + + CONSTRUCTION, OPEN, + CLOSED, MAINTENANCE, + MALFUNCTION, ACTIVE, + INACTIVE, GLOBAL; + + public static Status getStatus(String string) { + if(string == null) + return null; + + string = string.toUpperCase(); + switch(string) { + case "CONSTRUCTION": + return Status.CONSTRUCTION; + case "OPEN": + return Status.OPEN; + case "CLOSED": + return Status.CLOSED; + case "MAINTENANCE": + return Status.MAINTENANCE; + case "MALFUNCTION": + return Status.MALFUNCTION; + case "ACTIVE": + return Status.ACTIVE; + case "INACTIVE": + return Status.INACTIVE; + default: + return null; + } + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/attraction/component/Type.java b/src/main/java/me/paradoxpixel/themepark/api/attraction/component/Type.java new file mode 100644 index 0000000..9339df6 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/attraction/component/Type.java @@ -0,0 +1,59 @@ +package me.paradoxpixel.themepark.api.attraction.component; + +public enum Type { + + RIDE(true, Status.CLOSED, Status.CONSTRUCTION, Status.OPEN, Status.CLOSED, Status.MAINTENANCE, Status.MALFUNCTION), + SHOW(true, Status.CLOSED, Status.CONSTRUCTION, Status.ACTIVE, Status.INACTIVE), + GLOBAL(false, Status.GLOBAL); + + private boolean status; + private Status def; + private Status[] array; + + Type(boolean status, Status def, Status... array) { + this.status = status; + this.def = def; + this.array = array; + } + + public boolean hasStatus() { + return status; + } + + public Status getDefefault() { + return def; + } + + public boolean containsStatus(Status status) { + if(status == null) + return false; + + if(!hasStatus()) + return false; + + for(int i = 0; i < array.length; i++) + if(array[i] == status) + return true; + + return false; + } + + + public static Type getType(String string) { + if(string == null) + return null; + + string = string.toUpperCase(); + switch(string) { + case "RIDE": + return Type.RIDE; + case "SHOW": + return Type.SHOW; + case "GLOBAL": + return Type.GLOBAL; + default: + return null; + } + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/attraction/AddAttractionEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/AddAttractionEvent.java new file mode 100644 index 0000000..56899fe --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/AddAttractionEvent.java @@ -0,0 +1,29 @@ +package me.paradoxpixel.themepark.api.event.attraction; + +import me.paradoxpixel.themepark.api.attraction.Attraction; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class AddAttractionEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private Attraction attraction; + + public AddAttractionEvent(Attraction attraction) { + this.attraction = attraction; + } + + public Attraction getAttraction() { + return attraction; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} \ No newline at end of file diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/attraction/PreStatusChangeEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/PreStatusChangeEvent.java new file mode 100644 index 0000000..529e6da --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/PreStatusChangeEvent.java @@ -0,0 +1,61 @@ +package me.paradoxpixel.themepark.api.event.attraction; + +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import org.bukkit.entity.Player; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class PreStatusChangeEvent extends Event implements Cancellable { + + private static final HandlerList handlers = new HandlerList(); + + private boolean cancel; + private Attraction attraction; + private Player player; + private Status before, after; + + public PreStatusChangeEvent(Attraction attraction, Player player, Status before, Status after) { + this.attraction = attraction; + this.player = player; + this.before = before; + this.after = after; + cancel = false; + } + + @Override + public boolean isCancelled() { + return cancel; + } + + @Override + public void setCancelled(boolean b) { + cancel = b; + } + + public Attraction getAttraction() { + return attraction; + } + + public Player getPlayer() { + return player; + } + + public Status getStatusBefore() { + return before; + } + + public Status getStatusAfter() { + return after; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/attraction/RemoveAttractionEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/RemoveAttractionEvent.java new file mode 100644 index 0000000..a07cb09 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/RemoveAttractionEvent.java @@ -0,0 +1,29 @@ +package me.paradoxpixel.themepark.api.event.attraction; + +import me.paradoxpixel.themepark.api.attraction.Attraction; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class RemoveAttractionEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private Attraction attraction; + + public RemoveAttractionEvent(Attraction attraction) { + this.attraction = attraction; + } + + public Attraction getAttraction() { + return attraction; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} \ No newline at end of file diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/attraction/StatusChangeEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/StatusChangeEvent.java new file mode 100644 index 0000000..2e80350 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/attraction/StatusChangeEvent.java @@ -0,0 +1,48 @@ +package me.paradoxpixel.themepark.api.event.attraction; + +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import org.bukkit.entity.Player; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class StatusChangeEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private Attraction attraction; + private Player player; + private Status before, after; + + public StatusChangeEvent(Attraction attraction, Player player, Status before, Status after) { + this.attraction = attraction; + this.player = player; + this.before = before; + this.after = after; + } + + public Attraction getAttraction() { + return attraction; + } + + public Player getPlayer() { + return player; + } + + public Status getStatusBefore() { + return before; + } + + public Status getStatusAfter() { + return after; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/region/AddRegionEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/region/AddRegionEvent.java new file mode 100644 index 0000000..21fc13e --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/region/AddRegionEvent.java @@ -0,0 +1,30 @@ +package me.paradoxpixel.themepark.api.event.region; + +import me.paradoxpixel.themepark.api.attraction.Region; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class AddRegionEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private Region region; + + public AddRegionEvent(Region region) { + this.region = region; + } + + public Region getRegion() { + return region; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} + diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/region/ChangeRegionEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/region/ChangeRegionEvent.java new file mode 100644 index 0000000..5a8ae8a --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/region/ChangeRegionEvent.java @@ -0,0 +1,53 @@ +package me.paradoxpixel.themepark.api.event.region; + +import me.paradoxpixel.themepark.api.attraction.Region; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; +import java.util.List; + +public class ChangeRegionEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private Region region; + private String bname, aname; + private List blore, alore; + + public ChangeRegionEvent(Region region, String bname, String aname, List blore, List alore) { + this.region = region; + this.bname = bname; + this.aname = aname; + this.blore = blore; + this.alore = alore; + } + + public Region getRegion() { + return region; + } + + public String getNameBefore() { + return bname; + } + + public String getNameAfter() { + return aname; + } + + public List getLoreBefore() { + return blore; + } + + public List getLoreAfter() { + return alore; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + +} + diff --git a/src/main/java/me/paradoxpixel/themepark/api/event/region/RemoveRegionEvent.java b/src/main/java/me/paradoxpixel/themepark/api/event/region/RemoveRegionEvent.java new file mode 100644 index 0000000..8c7d47c --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/api/event/region/RemoveRegionEvent.java @@ -0,0 +1,30 @@ +package me.paradoxpixel.themepark.api.event.region; + +import me.paradoxpixel.themepark.api.attraction.Region; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class RemoveRegionEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private Region region; + + public RemoveRegionEvent(Region region) { + this.region = region; + } + + public Region getRegion() { + return region; + } + + public HandlerList getHandlers() { + return handlers; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + +} diff --git a/src/main/java/me/paradoxpixel/themepark/attraction/AttractionMenu.java b/src/main/java/me/paradoxpixel/themepark/attraction/AttractionMenu.java new file mode 100644 index 0000000..e3fae0c --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/attraction/AttractionMenu.java @@ -0,0 +1,170 @@ +package me.paradoxpixel.themepark.attraction; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.action.TPUtils; +import me.paradoxpixel.themepark.api.API; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.Region; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.api.attraction.component.Type; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.gui.GUI; +import me.paradoxpixel.themepark.gui.GUIItem; +import me.paradoxpixel.themepark.utils.ItemBuilder; +import me.paradoxpixel.themepark.utils.LocationUtils; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.configuration.ConfigurationSection; +import org.bukkit.entity.Player; +import java.util.HashMap; +import java.util.List; + +public class AttractionMenu { + + private static YamlConfig config = ThemeParkPlugin.getInstance().getAttraction(); + private static YamlConfig settings = ThemeParkPlugin.getInstance().getSettings(); + private static GUI gui; + + private static HashMap index = new HashMap<>(); + + public static void load() { + gui = new GUI(settings.getConfig().getString("menu.title"), 9); + loadData(); + loadItems(); + } + + public static void reload() { + loadItems(); + } + + public static void save() { + for(Region region : API.getRegions().values()) { + config.getConfig().set("region." + region.getId() + ".name", region.getName()); + config.getConfig().set("region." + region.getId() + ".lore", region.getLore()); + } + + for(Attraction attraction : API.getAttractions().values()) { + config.getConfig().set("attraction." + attraction.getId() + ".name", attraction.getName()); + config.getConfig().set("attraction." + attraction.getId() + ".region_id", attraction.getRegion_id()); + config.getConfig().set("attraction." + attraction.getId() + ".type", attraction.getType().toString()); + config.getConfig().set("attraction." + attraction.getId() + ".status", attraction.getStatus().toString()); + config.getConfig().set("attraction." + attraction.getId() + ".location", LocationUtils.toString(attraction.getLocation())); + } + + config.save(); + } + + private static void loadData() { + if(!config.getConfig().contains("region")) + return; + + if(!config.getConfig().isConfigurationSection("region")) + return; + + ConfigurationSection section = config.getConfig().getConfigurationSection("region"); + if(section.getKeys(false).isEmpty()) + return; + + for(String id : section.getKeys(false)) { + if(API.getRegions().size() >= 6) { + config.getConfig().set("regions." + id, null); + config.save(); + continue; + } + + String name = config.getConfig().getString("region." + id + ".name"); + List lore = config.getConfig().getStringList("region." + id + ".lore"); + + Region region = new Region(id, name, lore); + API.addRegion(region); + } + + if(!config.getConfig().contains("attraction")) + return; + + if(!config.getConfig().isConfigurationSection("attraction")) + return; + + section = config.getConfig().getConfigurationSection("attraction"); + if(section.getKeys(false).isEmpty()) + return; + + for(String id : section.getKeys(false)) { + String region_id = config.getConfig().getString("attraction." + id + ".region_id"); + if(!API.isRegion(region_id)) + continue; + + if(API.isRegionFull(region_id)) + continue; + + String name = config.getConfig().getString("attraction." + id + ".name"); + Location location = LocationUtils.toLocation(config.getConfig().getString("attraction." + id + ".location")); + Type type = Type.getType(config.getConfig().getString("attraction." + id + ".type")); + Status status = Status.getStatus(config.getConfig().getString("attraction." + id + ".status")); + + Attraction attraction = new Attraction(id, name, region_id, location, type, status); + API.addAttraction(attraction); + } + + for(Region region : API.getRegions().values()) + if(region.getAttractions().isEmpty()) + API.removeRegion(region.getId()); + } + + private static void loadItems() { + if(API.getRegions().values().size() == 0) + return; + + gui.clear(); + gui.setSize(API.getRegions().size() > 0 ? (API.getRegions().size() * 9) : 9); + for(Region region : API.getRegions().values()) { + if(!index.containsKey(region.getId())) + index.put(region.getId(), index.size() * 9); + + int i = index.get(region.getId()); + ItemBuilder builder = new ItemBuilder(Material.NAME_TAG); + builder.setName(region.getName()); + builder.setLore(region.getLore()); + + gui.addItem(i, new GUIItem(builder.getItem(), null, true)); + } + + for(Attraction attraction : API.getAttractions().values()) { + if(!API.isRegion(attraction.getRegion_id())) { + API.removeAttraction(attraction.getId()); + continue; + } + + if(!index.containsKey(attraction.getRegion_id())) + continue; + + int i = index.get(attraction.getRegion_id()); + boolean b = false; + for(int a = 1; a < 9; a++) { + if(!gui.hasItem(i + a)) { + i += a; + b = true; + break; + } + } + + if(!b) { + API.getRegion(attraction.getRegion_id()).removeAttraction(attraction); + API.removeAttraction(attraction.getId()); + continue; + } + + ItemBuilder builder = new ItemBuilder(StatusManager.getMaterial(attraction.getStatus()), 1, StatusManager.getData(attraction.getStatus())); + builder.setName(attraction.getName()); + builder.setLore(StatusManager.getName(attraction.getStatus())); + + gui.addItem(i, new GUIItem(builder.getItem(), new TPUtils(attraction.getId()), true)); + } + } + + public static void openMenu(Player player) { + player.openInventory(gui.getInventory()); + } + +} \ No newline at end of file diff --git a/src/main/java/me/paradoxpixel/themepark/attraction/sign/SignManager.java b/src/main/java/me/paradoxpixel/themepark/attraction/sign/SignManager.java new file mode 100644 index 0000000..554e154 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/attraction/sign/SignManager.java @@ -0,0 +1,142 @@ +package me.paradoxpixel.themepark.attraction.sign; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.utils.LocationUtils; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Sign; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class SignManager { + + private static YamlConfig config = ThemeParkPlugin.getInstance().getSigns(); + private static HashMap> signs = new HashMap<>(); + + public static void loadSigns(Attraction attraction) { + if(attraction == null) + return; + + if(!config.getConfig().contains("signs." + attraction.getId())) + return; + + if(!config.getConfig().isList("signs." + attraction.getId())) { + config.getConfig().set("signs." + attraction.getId(), null); + config.save(); + return; + } + + ArrayList array = new ArrayList<>(); + List locations = config.getConfig().getStringList("signs." + attraction.getId()); + for(String string : locations) { + Location location = LocationUtils.toLocation(string); + if(location == null) + continue; + + if(!(location.getBlock().getState() instanceof Sign)) + return; + + array.add(new StatusSign(attraction, location)); + } + + signs.put(attraction, array); + } + + public static void saveSigns() { + for(Map.Entry> entry : signs.entrySet()) { + List array = new ArrayList<>(); + for(StatusSign sign : entry.getValue()) + array.add(LocationUtils.toString(sign.getLocation())); + + config.getConfig().set("signs." + entry.getKey().getId(), new ArrayList<>()); + config.getConfig().set("signs." + entry.getKey().getId(), array); + config.save(); + } + } + + public static void addSign(StatusSign sign) { + if(sign == null || sign.getLocation() == null) + return; + + if(!(sign.getLocation().getBlock().getState() instanceof Sign)) + return; + + if(signs.containsKey(sign.getAttraction())) { + signs.get(sign.getAttraction()).add(sign); + return; + } + + ArrayList array = new ArrayList<>(); + array.add(sign); + signs.put(sign.getAttraction(), array); + } + + public static boolean hasSigns(Attraction attraction) { + if(attraction == null) + return false; + + return signs.containsKey(attraction) && (signs.get(attraction).size() > 0); + } + + public static void update(Attraction attraction) { + if(attraction == null) + return; + + if(!hasSigns(attraction)) + return; + + for(StatusSign sign : signs.get(attraction)) + sign.update(); + } + + public static void remove(Attraction attraction) { + if(attraction == null || !signs.containsKey(attraction)) + return; + + for(StatusSign sign : signs.get(attraction)) + sign.getLocation().getBlock().setType(Material.AIR); + + signs.remove(attraction); + config.getConfig().set("signs." + attraction.getId(), null); + config.save(); + } + + public static void removeSign(StatusSign sign) { + if(sign == null || sign.getLocation() == null || sign.getAttraction() == null) + return; + + if(!hasSigns(sign.getAttraction())) + return; + + ArrayList array = signs.get(sign.getAttraction()); + for(StatusSign s : new ArrayList<>(array)) { + Location loc1 = sign.getLocation(); + Location loc2 = s.getLocation(); + + if(loc1 == null || loc2 == null) + return; + + if(LocationUtils.toString(loc1) == null || LocationUtils.toString(loc2) == null) + return; + + if(!LocationUtils.toString(loc1).equals(LocationUtils.toString(loc2))) + return; + + array.remove(s); + } + + if(array.isEmpty()) { + signs.remove(sign.getAttraction()); + config.getConfig().set("signs." + sign.getAttraction().getId(), null); + config.save(); + return; + } + + signs.put(sign.getAttraction(), array); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/attraction/sign/StatusSign.java b/src/main/java/me/paradoxpixel/themepark/attraction/sign/StatusSign.java new file mode 100644 index 0000000..ce86094 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/attraction/sign/StatusSign.java @@ -0,0 +1,36 @@ +package me.paradoxpixel.themepark.attraction.sign; + +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Location; +import org.bukkit.block.Sign; + +public class StatusSign { + + private Attraction attraction; + private Location location; + + public StatusSign(Attraction attraction, Location location) { + this.attraction = attraction; + this.location = location; + } + + public Attraction getAttraction() { + return attraction; + } + + public Location getLocation() { + return location; + } + + public void update() { + Status status = attraction.getStatus(); + + Sign sign = (Sign) location.getBlock().getState(); + sign.setLine(2, Utils.color(StatusManager.getName(status))); + sign.update(); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/attraction/status/StatusManager.java b/src/main/java/me/paradoxpixel/themepark/attraction/status/StatusManager.java new file mode 100644 index 0000000..d632502 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/attraction/status/StatusManager.java @@ -0,0 +1,76 @@ +package me.paradoxpixel.themepark.attraction.status; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.config.YamlConfig; +import org.bukkit.Material; +import java.util.HashMap; + +public class StatusManager { + + private static YamlConfig config = ThemeParkPlugin.getInstance().getSettings(); + private static HashMap names; + private static HashMap materials; + private static HashMap data; + private static HashMap teleport; + + public static void load() { + names = new HashMap<>(); + materials = new HashMap<>(); + data = new HashMap<>(); + teleport = new HashMap<>(); + + for(Status status : Status.values()) { + if(config.getConfig().contains(status.toString() + ".name")) { + names.put(status, config.getConfig().getString(status.toString() + ".name")); + } else { + names.put(status, "UNKNOWN"); + } + + if(config.getConfig().contains(status.toString() + ".material")) { + Material material = Material.getMaterial(config.getConfig().getString(status.toString() + ".material")); + if(material == null) + material = Material.STAINED_CLAY; + + materials.put(status, material); + } else { + materials.put(status, Material.STAINED_CLAY); + } + + if(config.getConfig().contains(status.toString() + ".data")) { + String string = config.getConfig().getString(status.toString() + ".data"); + if(string.isEmpty()) { + data.put(status, (short) 0); + continue; + } + + data.put(status, Short.parseShort(string)); + } else { + data.put(status, (short) 0); + } + + if(config.getConfig().contains(status.toString() + ".teleport")) { + teleport.put(status, config.getConfig().getBoolean(status.toString() + ".teleport")); + } else { + teleport.put(status, false); + } + } + } + + public static String getName(Status status) { + return names.get(status); + } + + public static Material getMaterial(Status status) { + return materials.get(status); + } + + public static short getData(Status status) { + return data.get(status); + } + + public static boolean canTeleport(Status status) { + return teleport.get(status); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/command/MenuCommand.java b/src/main/java/me/paradoxpixel/themepark/command/MenuCommand.java new file mode 100644 index 0000000..5978fdc --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/command/MenuCommand.java @@ -0,0 +1,25 @@ +package me.paradoxpixel.themepark.command; + +import me.paradoxpixel.themepark.attraction.AttractionMenu; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class MenuCommand implements CommandExecutor { + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { + if(cmd.getName().equalsIgnoreCase("status")) { + if(sender instanceof Player) { + AttractionMenu.openMenu((Player) sender); + return true; + } else { + sender.sendMessage(Utils.color("&6Themepark&f: &4Only players can use this command")); + } + } + return false; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/command/ThemeParkCommand.java b/src/main/java/me/paradoxpixel/themepark/command/ThemeParkCommand.java new file mode 100644 index 0000000..628004d --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/command/ThemeParkCommand.java @@ -0,0 +1,373 @@ +package me.paradoxpixel.themepark.command; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.api.API; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.Region; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.attraction.AttractionMenu; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.utils.ItemBuilder; +import me.paradoxpixel.themepark.utils.Message; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.command.CommandSender; +import org.bukkit.command.defaults.BukkitCommand; +import org.bukkit.entity.Minecart; +import org.bukkit.entity.Player; +import java.util.Scanner; +import java.util.UUID; + +public class ThemeParkCommand extends BukkitCommand { + + private String name; + + public ThemeParkCommand(String name) { + super(name); + + this.name = name; + } + + public boolean execute(CommandSender sender,String label, String[] args) { + if (args.length == 0 || args[0].equalsIgnoreCase("help")) { + sender.sendMessage(Utils.color("&f>==== &6ThemePark &f ====<")); + sender.sendMessage(Utils.color("&f/" + name + " help")); + sender.sendMessage(Utils.color("&f/" + name + " list")); + sender.sendMessage(Utils.color("&f/" + name + " warp [id]")); + if(sender.hasPermission("themepark.admin") || sender.hasPermission("themepark.item")) { + sender.sendMessage(Utils.color("&f/" + name + " toggleitem")); + sender.sendMessage(Utils.color("&f/" + name + " getitem")); + } + + if(sender.hasPermission("themepark.admin")) { + sender.sendMessage(Utils.color("&f/" + name + " reload")); + sender.sendMessage(Utils.color("&f/" + name + " regionname [id] [name]")); + sender.sendMessage(Utils.color("&f/" + name + " regionlore [id] [index] [lore]")); + sender.sendMessage(Utils.color("&f/" + name + " setlocation [id]")); + sender.sendMessage(Utils.color("&f/" + name + " attraction [id] [status]")); + sender.sendMessage(Utils.color("&f/" + name + " ridecount [id] [player]")); + } + + return true; + } + + if (args[0].equalsIgnoreCase("list")) { + sender.sendMessage(Utils.color("&f>==== &6ThemePark &f ====<")); + if (API.getAttractions().size() == 0) { + sender.sendMessage(Utils.color(Message.getMessage("attraction.notfound"))); + return true; + } + + for (Attraction attraction : API.getAttractions().values()) { + String message = Message.getMessage("attraction.list"); + message = message.replace("{id}", attraction.getId()); + message = message.replace("{name}", attraction.getName()); + message = message.replace("{region}", API.getRegion(attraction.getRegion_id()).getName()); + message = message.replace("{status}", StatusManager.getName(attraction.getStatus())); + sender.sendMessage(Utils.color(message)); + } + + return true; + } + + if(args[0].equalsIgnoreCase("warp")) { + if(args.length < 2) { + sender.sendMessage(Utils.color( "&6Themepark&f: &4/" + name + " warp [id]")); + return true; + } + + String id = args[1]; + if(!API.isAttraction(id)) { + String message = Message.getMessage("attraction.no"); + message = message.replace("{id}", id); + sender.sendMessage(Utils.color(message)); + return true; + } + + if(sender instanceof Player) { + Attraction attraction = API.getAttraction(id); + Player player = (Player) sender; + if(!StatusManager.canTeleport(attraction.getStatus())) { + String message = Message.getMessage("attraction.teleport.status"); + message = message.replace("{name}", attraction.getName()); + message = message.replace("{status}", StatusManager.getName(attraction.getStatus())); + player.sendMessage(Utils.color(message)); + return true; + } + + player.teleport(attraction.getLocation()); + if(player.isInsideVehicle()) + if(player.getVehicle() instanceof Minecart) + return true; + + player.sendMessage(Utils.color(Message.getMessage("attraction.teleport.success").replace("{name}", attraction.getName()))); + return true; + } else { + sender.sendMessage(Utils.color(Message.getMessage("onlyplayers"))); + return true; + } + } + + if(!sender.hasPermission("themepark.admin") && !sender.hasPermission("themepark.item")) { + sender.sendMessage(Utils.color(Message.getMessage("nopermission"))); + return true; + } + + if(args[0].equalsIgnoreCase("toggleitem")) { + if(!(sender instanceof Player)) { + sender.sendMessage(Utils.color(Message.getMessage("onlyplayers"))); + return true; + } + + Player player = (Player) sender; + UUID uuid = player.getUniqueId(); + + YamlConfig config = ThemeParkPlugin.getInstance().getData(); + boolean b = config.getConfig().getBoolean(uuid.toString() + ".item"); + b = !b; + + config.getConfig().set(uuid.toString() + ".item", b); + config.save(); + + String message = Message.getMessage("menu.item.toggle"); + message = message.replace("{status}", b ? Message.getMessage("enabled") : Message.getMessage("disabled")); + sender.sendMessage(Utils.color(message)); + return true; + } + + if(args[0].equalsIgnoreCase("getitem")) { + YamlConfig settings = ThemeParkPlugin.getInstance().getSettings(); + Material material = Material.getMaterial(settings.getConfig().getString("item.material")); + String name = Utils.color(settings.getConfig().getString("item.display-name")); + if(material == null || name.isEmpty()) + return true; + + Player player; + if(args.length >= 2) { + String string = args[1]; + if(Bukkit.getPlayerExact(string) == null) { + String message = Message.getMessage("noplayer"); + message = message.replace("{name}", string); + sender.sendMessage(Utils.color(message)); + return true; + } + + player = Bukkit.getPlayerExact(string); + } else { + if(!(sender instanceof Player)) { + sender.sendMessage(Utils.color(Message.getMessage("onlyplayers"))); + return true; + } + + player = (Player) sender; + } + + + ItemBuilder builder = new ItemBuilder(material); + builder.setName(name); + player.getInventory().addItem(builder.getItem()); + } + + if(!sender.hasPermission("themepark.admin")) { + sender.sendMessage(Utils.color(Message.getMessage("nopermission"))); + return true; + } + + if(args[0].equalsIgnoreCase("reload")) { + ThemeParkPlugin.getInstance().getData().reload(); + ThemeParkPlugin.getInstance().getAttraction().reload(); + ThemeParkPlugin.getInstance().getSigns().reload(); + ThemeParkPlugin.getInstance().getSettings().reload(); + ThemeParkPlugin.getInstance().getMessage().reload(); + + API.getRegions().clear(); + API.getAttractions().clear(); + + StatusManager.load(); + AttractionMenu.load(); + for(Region region : API.getRegions().values()) + if(region.getAttractions().isEmpty()) + API.removeRegion(region.getId()); + + sender.sendMessage(Utils.color(Message.getMessage("reloaded"))); + } + + if (args[0].equalsIgnoreCase("regionname")) { + if (args.length < 3) { + sender.sendMessage(Utils.color("&6Themepark&f: &4/" + name + " regionname [id] [name]")); + return true; + } + + String id = args[1]; + if (!API.isRegion(id)) { + String message = Message.getMessage("region.no"); + message = message.replace("{id}", id); + sender.sendMessage(Utils.color(message)); + return true; + } + + String name = args[2]; + name = name.replaceAll("_", " "); + + Region region = API.getRegion(id); + if(region.getName().equals(name)) + return true; + + region.setName(name); + + String message = Message.getMessage("region.changed.name"); + message = message.replace("{id}", id); + message = message.replace("{name}", name); + sender.sendMessage(Utils.color(message)); + return true; + } + + if (args[0].equalsIgnoreCase("regionlore")) { + if (args.length < 4) { + sender.sendMessage(Utils.color("&6Themepark&f: &4/" + name + " regionlore[id] [index] [lore]")); + return true; + } + + String id = args[1]; + if (!API.isRegion(id)) { + String message = Message.getMessage("region.no"); + message = message.replace("{id}", id); + sender.sendMessage(Utils.color(message)); + return true; + } + + String string = args[2]; + if(!isInteger(string)) { + sender.sendMessage(Message.getMessage("nonumber").replace("{number}", string)); + return true; + } + + int i = Integer.parseInt(string); + + String lore = args[3]; + lore = lore.replaceAll("_", " "); + + Region region = API.getRegion(id); + + if(region.getLore().size() > i && region.getLore().get(i).equals(lore)) + return true; + + region.setLore(i, lore); + + String message = Message.getMessage("region.changed.lore"); + message = message.replace("{id}", id); + message = message.replace("{index}", "" + i); + message = message.replace("{lore}", lore); + sender.sendMessage(Utils.color(message)); + return true; + } + + if (args[0].equalsIgnoreCase("setlocation")) { + if (args.length < 2 ) { + sender.sendMessage(Utils.color("&6Themepark&f: &4/" + name + " setlocation [id]")); + return true; + } + + String id = args[1]; + if(!API.isAttraction(id)) { + String message = Message.getMessage("attraction.no"); + message = message.replace("{id}", id); + sender.sendMessage(Utils.color(message)); + return true; + } + + if(!(sender instanceof Player)) { + sender.sendMessage(Utils.color(Message.getMessage("onlyplayers"))); + return true; + } + + Attraction attraction = API.getAttraction(id); + attraction.setLocation(((Player) sender).getLocation().clone()); + sender.sendMessage(Utils.color(Message.getMessage("attraction.location").replace("{name}", attraction.getName()))); + return true; + } + + if (args[0].equalsIgnoreCase("attraction")) { + if (args.length < 3 ) { + sender.sendMessage(Utils.color("&6Themepark&f: &4/" + name + " attraction [id] [status]")); + return true; + } + + String id = args[1]; + if (!API.isAttraction(id)) { + String message = Message.getMessage("attraction.no"); + message = message.replace("{id}", id); + sender.sendMessage(Utils.color(message)); + return true; + } + + Status status = Status.getStatus(args[2]); + if (status == null) { + String message = Message.getMessage("status.no"); + message = message.replace("{status}", args[2]); + sender.sendMessage(Utils.color(message)); + return true; + } + + Attraction attraction = API.getAttraction(id); + if(!attraction.getType().containsStatus(status)) { + String message = Message.getMessage("attraction.nostatus"); + message = message.replace("{name}", attraction.getName()); + message = message.replace("{status}", status.toString()); + sender.sendMessage(Utils.color(message)); + return true; + } + + if(attraction.getStatus() == status) + return true; + + Player player = (sender instanceof Player) ? (Player) sender : null; + + attraction.setStatus(status, player); + return true; + } + + if (args[0].equalsIgnoreCase("ridecount")) { + if (args.length < 3) { + sender.sendMessage(Utils.color("&6Themepark&f: &4/" + name + " ridecount [id] [player]")); + return true; + } + + String id = args[1]; + if (!API.isAttraction(id)) { + String message = Message.getMessage("attraction.no"); + message = message.replace("{id}", id); + sender.sendMessage(Utils.color(message)); + return true; + } + + Attraction attraction = API.getAttraction(id); + String string = args[2]; + if(Bukkit.getPlayerExact(string) == null) { + String message = Message.getMessage("noplayer"); + message = message.replace("{name}", string); + sender.sendMessage(Utils.color(message)); + return true; + } + + Player player = Bukkit.getPlayerExact(string); + + ThemeParkPlugin.getInstance().getDatabaseHandler().addCount(player.getUniqueId(), attraction); + //TODO MESSAGE + return true; + } + + return false; + } + + private boolean isInteger(String s) { + int radix = 10; + Scanner sc = new Scanner(s.trim()); + if(!sc.hasNextInt(radix)) return false; + sc.nextInt(radix); + return !sc.hasNext(); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/config/YamlConfig.java b/src/main/java/me/paradoxpixel/themepark/config/YamlConfig.java new file mode 100644 index 0000000..2fa00b5 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/config/YamlConfig.java @@ -0,0 +1,87 @@ +package me.paradoxpixel.themepark.config; + +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.plugin.Plugin; +import java.io.File; + +public class YamlConfig { + + private String name; + private File file; + private FileConfiguration config; + private Plugin plugin; + + public YamlConfig(String name, Plugin plugin) { + this.name = name.endsWith(".yml") ? name : name + ".yml"; + this.plugin = plugin; + + load(); + } + + public void load() { + if(!plugin.getDataFolder().exists()) + plugin.getDataFolder().mkdir(); + + file = new File(plugin.getDataFolder(), name); + if(!file.exists()) { + if(plugin.getResource(name) == null) { + try { + if(!file.createNewFile()) + System.out.print("Couldn't create config file: " + name); + } catch(Exception e) { + e.printStackTrace(); + return; + } + } else { + plugin.saveResource(name, true); + } + } + + config = YamlConfiguration.loadConfiguration(file); + } + + public FileConfiguration getConfig() { + return config; + } + + public void reload() { + if(file == null) { + load(); + return; + } + + config = YamlConfiguration.loadConfiguration(file); + } + + public void save() { + try { + config.save(file); + } catch(Exception e) { + e.printStackTrace(); + } + } + + public YamlConfig copy(String name) { + name = name.endsWith(".yml") ? name : name + ".yml"; + + File file = new File(plugin.getDataFolder(), name); + try { + config.save(file); + } catch(Exception e) { + e.printStackTrace(); + return null; + } + + return new YamlConfig(name, plugin); + } + + public void delete() { + try { + if(!file.delete()) + System.out.print("Couldn't delete config file: " + name); + } catch(Exception e) { + e.printStackTrace(); + } + } +} diff --git a/src/main/java/me/paradoxpixel/themepark/database/Database.java b/src/main/java/me/paradoxpixel/themepark/database/Database.java new file mode 100644 index 0000000..1ab6dc9 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/database/Database.java @@ -0,0 +1,187 @@ +package me.paradoxpixel.themepark.database; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.config.YamlConfig; +import org.bukkit.Bukkit; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.util.HashMap; +import java.util.Map; + +public class Database { + + public Database(YamlConfig config) { + if(config == null) { + enabled = false; + return; + } + + enabled = config.getConfig().getBoolean("mysql.enabled"); + host = config.getConfig().getString("mysql.host"); + port = config.getConfig().getInt("mysql.port"); + database = config.getConfig().getString("mysql.database"); + user = config.getConfig().getString("mysql.user"); + password = config.getConfig().getString("mysql.password"); + } + + private boolean enabled; + private String host; + private int port; + private String database; + private String user; + private String password; + + private Connection connection; + private int TaskID; + + public boolean isEnabled() { + return enabled; + } + + public void connect() { + try { + Class.forName("com.mysql.jdbc.Driver").newInstance(); + connection = DriverManager.getConnection("jdbc:mysql://" + host + ":" + port + "/" + database, user, password); + + startPool(); + } catch(Exception e) { + enabled = false; + e.printStackTrace(); + } + } + + public void disconnect() { + if(connection == null) + return; + + try { + connection.close(); + connection = null; + } catch(Exception e) { + e.printStackTrace(); + } + } + + private boolean connected() { + if(connection == null) + return false; + + try { + return !connection.isClosed(); + } catch(Exception e) { + e.printStackTrace(); + } + + return false; + } + + private void startPool() { + TaskID = Bukkit.getScheduler().runTaskLater(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + disconnect(); + TaskID = 0; + } + }, 1200L).getTaskId(); + } + + private void stopPool() { + if(TaskID == 0) + return; + + Bukkit.getScheduler().cancelTask(TaskID); + TaskID = 0; + } + + public boolean execute(String query, HashMap objects) { + if(query == null || query.isEmpty()) + return false; + + if(!enabled) + return false; + + if(!connected()) + connect(); + + stopPool(); + try { + PreparedStatement statement = connection.prepareStatement(query); + if(objects != null) + for(Map.Entry entry : objects.entrySet()) + statement.setObject(entry.getKey(), entry.getValue()); + + boolean b = statement.execute(); + statement.close(); + startPool(); + + return b; + } catch(Exception e) { + e.printStackTrace(); + } + + startPool(); + return false; + } + + public int executeUpdate(String query, HashMap objects) { + if(query == null || query.isEmpty()) + return 0; + + if(!enabled) + return 0; + + if(!connected()) + connect(); + + stopPool(); + try { + PreparedStatement statement = connection.prepareStatement(query); + for(Map.Entry entry : objects.entrySet()) + statement.setObject(entry.getKey(), entry.getValue()); + + int i = statement.executeUpdate(); + statement.close(); + startPool(); + + return i; + } catch(Exception e) { + e.printStackTrace(); + } + + startPool(); + return 0; + } + + public ResultSet executeQuery(String query, HashMap objects) { + if(query == null || query.isEmpty()) + return null; + + + if(!enabled) + return null; + + if(!connected()) + connect(); + + stopPool(); + try { + PreparedStatement statement = connection.prepareStatement(query); + for(Map.Entry entry : objects.entrySet()) + statement.setObject(entry.getKey(), entry.getValue()); + + ResultSet result = statement.executeQuery(); + statement.close(); + startPool(); + + return result; + } catch(Exception e) { + e.printStackTrace(); + } + + startPool(); + return null; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/database/DatabaseHandler.java b/src/main/java/me/paradoxpixel/themepark/database/DatabaseHandler.java new file mode 100644 index 0000000..b6a9f8f --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/database/DatabaseHandler.java @@ -0,0 +1,117 @@ +package me.paradoxpixel.themepark.database; + +import me.paradoxpixel.themepark.api.API; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.Region; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.config.YamlConfig; + +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.HashMap; +import java.util.UUID; + +public class DatabaseHandler { + + private Database database; + + public DatabaseHandler(YamlConfig config) { + database = new Database(config); + load(); + } + + private void load() { + database.execute("CREATE TABLE IF NOT EXISTS attraction (id VARCHAR(256) NOT NULL, name VARCHAR(256) NOT NULL, region_id VARCHAR(256) NOT NULL, type VARCHAR(256) NOT NULL, status VARCHAR(256) NOT NULL, PRIMARY KEY(id))", null); + database.execute("CREATE TABLE IF NOT EXISTS region (id VARCHAR(256) NOT NULL, name VARCHAR(256) NOT NULL, PRIMARY KEY(id))", null); + database.execute("CREATE TABLE IF NOT EXISTS status (statusId VARCHAR(256) NOT NULL, statusName VARCHAR(256) NOT NULL)", null); + database.execute("CREATE TABLE IF NOT EXISTS ridecount (uuid VARCHAR(256) NOT NULL, attractionId VARCHAR(256) NOT NULL, date VARCHAR(256), count INT(11) NOT NULL)", null); + + database.execute("TRUNCATE TABLE attraction", null); + database.execute("TRUNCATE TABLE region", null); + database.execute("TRUNCATE TABLE status", null); + + for(Attraction attraction : API.getAttractions().values()) + addAttraction(attraction); + + for(Region region : API.getRegions().values()) + addRegion(region); + + for(Status status : Status.values()) { + HashMap objects = new HashMap<>(); + objects.put(1, status.toString()); + objects.put(2, StatusManager.getName(status)); + database.execute("INSERT INTO status (statusId,statusName) VALUES(?,?)", objects); + } + } + + public void addAttraction(Attraction attraction) { + HashMap objects = new HashMap<>(); + objects.put(1, attraction.getId()); + objects.put(2, attraction.getName()); + objects.put(3, attraction.getRegion_id()); + objects.put(4, attraction.getType().toString()); + objects.put(5, attraction.getStatus().toString()); + + database.execute("INSERT IGNORE INTO attraction(id, name, region_id, type, status) VALUES (?,?,?,?,?)", objects); + } + + public void updateAttraction(Attraction attraction) { + HashMap objects = new HashMap<>(); + objects.put(1, attraction.getStatus().toString()); + objects.put(2, attraction.getId()); + + database.execute("UPDATE attraction SET status=? WHERE id=?", objects); + } + + public void removeAttraction(Attraction attraction) { + HashMap objects = new HashMap<>(); + objects.put(1, attraction.getId()); + + database.execute("DELETE FROM attraction WHERE id=?", objects); + database.execute("DELETE FROM ridecount WHERE attractionId=?", objects); + } + + public void addRegion(Region region) { + HashMap objects = new HashMap<>(); + objects.put(1, region.getId()); + objects.put(2, region.getName()); + + database.execute("INSERT IGNORE INTO region(id, name) VALUES (?,?)", objects); + } + + public void updateRegion(Region region) { + HashMap objects = new HashMap<>(); + objects.put(1, region.getName()); + objects.put(2, region.getId()); + + database.execute("UPDATE region SET name=? WHERE id=?", objects); + } + + public void removeRegion(Region region) { + HashMap objects = new HashMap<>(); + objects.put(1, region.getId()); + + database.execute("DELETE FROM region WHERE id=?", objects); + } + + public void addCount(UUID uuid, Attraction attraction) { + String pattern = "dd-MM-yyyy"; + SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern); + String date = simpleDateFormat.format(new Date()); + + HashMap objects = new HashMap<>(); + objects.put(1, uuid.toString()); + objects.put(2, attraction.getId()); + objects.put(3, date); + + if(database.executeUpdate("UPDATE ridecount SET count=count+1 WHERE uuid=? AND attractionId=? AND date=?", objects) < 1) { + database.execute("INSERT INTO ridecount(uuid,attractionId,date,count) VALUES (?,?,?,1)", objects); + } + } + + public void disconnect() { + database.disconnect(); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/gui/GUI.java b/src/main/java/me/paradoxpixel/themepark/gui/GUI.java new file mode 100644 index 0000000..6a1d572 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/gui/GUI.java @@ -0,0 +1,120 @@ +package me.paradoxpixel.themepark.gui; + +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.inventory.ClickType; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +public class GUI extends GUIHolder { + + private String title; + private int size; + private Inventory inventory; + private HashMap items = new HashMap<>(); + + public GUI(String title, int size) { + if(size > 54) + size = 54; + + this.title = title; + this.size = Utils.toSize(size, 9); + inventory = Bukkit.createInventory(this, this.size, Utils.color(title)); + } + + private void update() { + ArrayList toRemove = new ArrayList<>(); + for(Map.Entry entry : items.entrySet()) { + if(entry.getKey() >= getSize()) { + toRemove.add(entry.getKey()); + continue; + } + + inventory.setItem(entry.getKey(), entry.getValue().getItem()); + } + + for(int i : toRemove) + items.remove(i); + } + + public void setSize(int size) { + if(size > 54) + size = 54; + + this.size = Utils.toSize(size, 9); + inventory = Bukkit.createInventory(this, this.size, Utils.color(title)); + update(); + } + + public int getSize() { + return size; + } + + public void clear() { + inventory = Bukkit.createInventory(this, Utils.toSize(size, 9), Utils.color(title)); + items.clear(); + } + + public void addItems(HashMap items) { + for(Map.Entry entry : items.entrySet()) + addItem(entry.getKey(), entry.getValue()); + } + + public void addItem(int slot, GUIItem item) { + if(slot >= getSize() || slot < 0) + return; + + items.put(slot, item); + inventory.setItem(slot, item.getItem()); + } + + public void removeItem(int slot) { + items.remove(slot); + } + + public void switchSlot(int from, int to) { + if(!items.containsKey(from)) + return; + + GUIItem item = items.get(from); + items.put(to, item); + items.remove(from); + } + + public boolean hasItem(int slot) { + return items.containsKey(slot); + } + + @Override + public boolean execute(Player player, int slot, ClickType type) { + if(player == null || slot >= getSize() || slot < 0 || type == null) + return false; + + if(!items.containsKey(slot)) + return false; + + GUIItem item = items.get(slot); + if(type == ClickType.RIGHT) { + if(item.getActionRight() != null) + item.getActionRight().click(player); + + return item.hasCancelRight(); + } else { + if(item.getActionLeft() != null) + item.getActionLeft().click(player); + + return item.hasCancelLeft(); + } + } + + @Override + public Inventory getInventory() { + return inventory; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/gui/GUIAction.java b/src/main/java/me/paradoxpixel/themepark/gui/GUIAction.java new file mode 100644 index 0000000..539ef03 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/gui/GUIAction.java @@ -0,0 +1,9 @@ +package me.paradoxpixel.themepark.gui; + +import org.bukkit.entity.Player; + +public abstract class GUIAction { + + public abstract void click(Player player); + +} diff --git a/src/main/java/me/paradoxpixel/themepark/gui/GUIHolder.java b/src/main/java/me/paradoxpixel/themepark/gui/GUIHolder.java new file mode 100644 index 0000000..4477573 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/gui/GUIHolder.java @@ -0,0 +1,11 @@ +package me.paradoxpixel.themepark.gui; + +import org.bukkit.entity.Player; +import org.bukkit.event.inventory.ClickType; +import org.bukkit.inventory.InventoryHolder; + +public abstract class GUIHolder implements InventoryHolder { + + public abstract boolean execute(Player player, int slot, ClickType type); + +} diff --git a/src/main/java/me/paradoxpixel/themepark/gui/GUIItem.java b/src/main/java/me/paradoxpixel/themepark/gui/GUIItem.java new file mode 100644 index 0000000..62a8382 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/gui/GUIItem.java @@ -0,0 +1,45 @@ +package me.paradoxpixel.themepark.gui; + +import org.bukkit.inventory.ItemStack; + +public class GUIItem { + + private ItemStack item; + private GUIAction aleft, aright; + private boolean cleft, cright; + + public GUIItem(ItemStack item, GUIAction action, boolean cancel) { + this.item = item; + aleft = aright = action; + cleft = cright = cancel; + } + + public GUIItem(ItemStack item, GUIAction aleft, GUIAction aright, boolean cleft, boolean cright) { + this.item = item; + this.aleft = aleft; + this.aright = aright; + this.cleft = cleft; + this.cright = cright; + } + + public ItemStack getItem() { + return item; + } + + public boolean hasCancelLeft() { + return cleft; + } + + public boolean hasCancelRight() { + return cright; + } + + public GUIAction getActionLeft() { + return aleft; + } + + public GUIAction getActionRight() { + return aright; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/gui/GUIListener.java b/src/main/java/me/paradoxpixel/themepark/gui/GUIListener.java new file mode 100644 index 0000000..6c4a3d8 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/gui/GUIListener.java @@ -0,0 +1,29 @@ +package me.paradoxpixel.themepark.gui; + +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.ClickType; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; + +public class GUIListener implements Listener { + + @EventHandler + public void onClick(InventoryClickEvent e) { + if(e.getClickedInventory() == null) + return; + + Inventory inventory = e.getClickedInventory(); + if(!(inventory.getHolder() instanceof GUIHolder)) + return; + + Player player = (Player) e.getWhoClicked(); + int slot = e.getRawSlot(); + ClickType type = e.getClick(); + + GUI gui = (GUI) inventory.getHolder(); + e.setCancelled(gui.execute(player, slot, type)); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/listener/ChangeListener.java b/src/main/java/me/paradoxpixel/themepark/listener/ChangeListener.java new file mode 100644 index 0000000..fc37a15 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/listener/ChangeListener.java @@ -0,0 +1,115 @@ +package me.paradoxpixel.themepark.listener; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.api.attraction.component.Status; +import me.paradoxpixel.themepark.api.event.attraction.AddAttractionEvent; +import me.paradoxpixel.themepark.api.event.attraction.RemoveAttractionEvent; +import me.paradoxpixel.themepark.api.event.attraction.StatusChangeEvent; +import me.paradoxpixel.themepark.api.event.region.AddRegionEvent; +import me.paradoxpixel.themepark.api.event.region.ChangeRegionEvent; +import me.paradoxpixel.themepark.api.event.region.RemoveRegionEvent; +import me.paradoxpixel.themepark.attraction.AttractionMenu; +import me.paradoxpixel.themepark.attraction.sign.SignManager; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.utils.Message; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; + +public class ChangeListener implements Listener { + + @EventHandler + public void onChange(StatusChangeEvent e) { + AttractionMenu.reload(); + SignManager.update(e.getAttraction()); + + Attraction attraction = e.getAttraction(); + Status status = e.getStatusAfter(); + String message = Message.getMessage("attraction.changed.status." + status.toString()); + message = message.replace("{name}", attraction.getName()); + message = message.replace("{status}", StatusManager.getName(status)); + Bukkit.broadcastMessage(Utils.color(message)); + + Bukkit.getScheduler().runTaskAsynchronously(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + ThemeParkPlugin.getInstance().getDatabaseHandler().updateAttraction(e.getAttraction()); + } + }); + } + + @EventHandler + public void onChange(AddAttractionEvent e) { + AttractionMenu.reload(); + SignManager.loadSigns(e.getAttraction()); + + Bukkit.getScheduler().runTaskAsynchronously(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + ThemeParkPlugin.getInstance().getDatabaseHandler().addAttraction(e.getAttraction()); + } + }); + } + + @EventHandler + public void onChange(RemoveAttractionEvent e) { + AttractionMenu.reload(); + SignManager.remove(e.getAttraction()); + + YamlConfig config = ThemeParkPlugin.getInstance().getAttraction(); + config.getConfig().set("attraction." + e.getAttraction().getId(), null); + config.save(); + + Bukkit.getScheduler().runTaskAsynchronously(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + ThemeParkPlugin.getInstance().getDatabaseHandler().removeAttraction(e.getAttraction()); + } + }); + } + + @EventHandler + public void onChange(AddRegionEvent e) { + AttractionMenu.reload(); + + Bukkit.getScheduler().runTaskAsynchronously(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + ThemeParkPlugin.getInstance().getDatabaseHandler().addRegion(e.getRegion()); + } + }); + } + + @EventHandler + public void onChange(ChangeRegionEvent e) { + AttractionMenu.reload(); + + Bukkit.getScheduler().runTaskAsynchronously(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + ThemeParkPlugin.getInstance().getDatabaseHandler().updateRegion(e.getRegion()); + } + }); + } + + @EventHandler + public void onChange(RemoveRegionEvent e) { + AttractionMenu.reload(); + + YamlConfig config = ThemeParkPlugin.getInstance().getAttraction(); + config.getConfig().set("region." + e.getRegion().getId(), null); + config.save(); + + Bukkit.getScheduler().runTaskAsynchronously(ThemeParkPlugin.getInstance(), new Runnable() { + @Override + public void run() { + ThemeParkPlugin.getInstance().getDatabaseHandler().removeRegion(e.getRegion()); + } + }); + } + + +} diff --git a/src/main/java/me/paradoxpixel/themepark/listener/ClickListener.java b/src/main/java/me/paradoxpixel/themepark/listener/ClickListener.java new file mode 100644 index 0000000..27d7551 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/listener/ClickListener.java @@ -0,0 +1,45 @@ +package me.paradoxpixel.themepark.listener; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.attraction.AttractionMenu; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.inventory.ItemStack; + +public class ClickListener implements Listener { + + private YamlConfig config = ThemeParkPlugin.getInstance().getSettings(); + + @EventHandler + public void onInteract(PlayerInteractEvent e) { + Material material = Material.getMaterial(config.getConfig().getString("item.material")); + String name = Utils.color(config.getConfig().getString("item.display-name")); + if(e.getItem() == null) + return; + + ItemStack item = e.getItem(); + if(item.getType() != material) + return; + + if(!item.hasItemMeta()) + return; + + if(!item.getItemMeta().getDisplayName().equals(name)) + return; + + if(e.getAction() == Action.LEFT_CLICK_AIR || + e.getAction() == Action.LEFT_CLICK_BLOCK) + return; + + e.setCancelled(true); + Player player = e.getPlayer(); + AttractionMenu.openMenu(player); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/listener/PlayerListener.java b/src/main/java/me/paradoxpixel/themepark/listener/PlayerListener.java new file mode 100644 index 0000000..8d07c0e --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/listener/PlayerListener.java @@ -0,0 +1,68 @@ +package me.paradoxpixel.themepark.listener; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.database.DatabaseHandler; +import me.paradoxpixel.themepark.utils.ItemBuilder; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Material; +import org.bukkit.entity.Minecart; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerTeleportEvent; + +public class PlayerListener implements Listener { + + private YamlConfig config = ThemeParkPlugin.getInstance().getData(); + private YamlConfig settings = ThemeParkPlugin.getInstance().getSettings(); + + @EventHandler + public void onJoin(PlayerJoinEvent e) { + Material material = Material.getMaterial(settings.getConfig().getString("item.material")); + String name = Utils.color(settings.getConfig().getString("item.display-name")); + int slot = settings.getConfig().getInt("item.slot"); + if(material == null || name.isEmpty()) + return; + + Player player = e.getPlayer(); + + boolean b = true; + if(config.getConfig().contains(player.getUniqueId().toString() + ".item")) { + b = config.getConfig().getBoolean(player.getUniqueId().toString() + ".item"); + } else { + config.getConfig().set(player.getUniqueId().toString() + ".item", true); + config.save(); + } + + if(b) { + ItemBuilder builder = new ItemBuilder(material); + builder.setName(name); + if(settings.getConfig().getBoolean("inventory.clear")) + player.getInventory().clear(); + + player.getInventory().setItem(slot, builder.getItem()); + } + } + + @EventHandler + public void onTeleport(PlayerTeleportEvent e) { + Player player = e.getPlayer(); + if(e.getCause() != PlayerTeleportEvent.TeleportCause.PLUGIN) + return; + + if(!player.isInsideVehicle()) + return; + + if(player.getVehicle() == null) + return; + + if(!(player.getVehicle() instanceof Minecart)) + return; + + e.setCancelled(true); + player.sendMessage(Utils.color("&6ThemePark&f: &4You can't teleport while in a minecart")); + } + +} \ No newline at end of file diff --git a/src/main/java/me/paradoxpixel/themepark/listener/SignListener.java b/src/main/java/me/paradoxpixel/themepark/listener/SignListener.java new file mode 100644 index 0000000..c2b46dc --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/listener/SignListener.java @@ -0,0 +1,64 @@ +package me.paradoxpixel.themepark.listener; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.api.API; +import me.paradoxpixel.themepark.api.attraction.Attraction; +import me.paradoxpixel.themepark.attraction.sign.SignManager; +import me.paradoxpixel.themepark.attraction.sign.StatusSign; +import me.paradoxpixel.themepark.attraction.status.StatusManager; +import me.paradoxpixel.themepark.config.YamlConfig; +import me.paradoxpixel.themepark.utils.Utils; +import org.bukkit.Location; +import org.bukkit.block.Block; +import org.bukkit.block.Sign; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockBreakEvent; +import org.bukkit.event.block.SignChangeEvent; + +public class SignListener implements Listener { + + private YamlConfig config = ThemeParkPlugin.getInstance().getSettings(); + private String name = config.getConfig().getString("sign.name"); + private String title = config.getConfig().getString("sign.title"); + + @EventHandler + public void onPlace(SignChangeEvent e) { + if(!e.getLine(0).equalsIgnoreCase(name)) + return; + + String id = e.getLine(1); + if(id == null || id.isEmpty() || !API.isAttraction(id)) + return; + + Attraction attraction = API.getAttraction(id); + e.setLine(0, Utils.color(title)); + e.setLine(1, Utils.color(attraction.getName())); + e.setLine(2, Utils.color(StatusManager.getName(attraction.getStatus()))); + + Location location = e.getBlock().getLocation(); + StatusSign statusSign = new StatusSign(attraction, location); + SignManager.addSign(statusSign); + } + + @EventHandler + public void onBreak(BlockBreakEvent e) { + if(e.getBlock() == null) + return; + + Block block = e.getBlock(); + if(!(block.getState() instanceof Sign)) + return; + + Sign sign = (Sign) block.getState(); + if(!sign.getLine(0).equals(Utils.color(title))) + return; + + Attraction attraction = API.getAttractionFromName(sign.getLine(1)); + Location location = e.getBlock().getLocation(); + + StatusSign s = new StatusSign(attraction, location); + SignManager.removeSign(s); + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/utils/ItemBuilder.java b/src/main/java/me/paradoxpixel/themepark/utils/ItemBuilder.java new file mode 100644 index 0000000..d9d8009 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/utils/ItemBuilder.java @@ -0,0 +1,111 @@ +package me.paradoxpixel.themepark.utils; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.bukkit.Material; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; + +public class ItemBuilder { + + private ItemStack item; + + public ItemBuilder(ItemStack item) { + this.item = item; + } + + public ItemBuilder(Material material) { + item = new ItemStack(material, 1); + } + + public ItemBuilder(Material material, int amount) { + item = new ItemStack(material, amount); + } + + public ItemBuilder(Material material, int amount, short data) { + item = new ItemStack(material, amount, data); + } + + public ItemStack getItem() { + return item; + } + + public ItemBuilder setDurability(short durability) { + item.setDurability(durability); + return this; + } + + public ItemBuilder setName(String name) { + if(name == null) + return this; + + ItemMeta meta = item.getItemMeta(); + meta.setDisplayName(Utils.color(name)); + this.item.setItemMeta(meta); + return this; + } + + public ItemBuilder setLore(List lore) { + if(lore == null) + return this; + + ItemMeta meta = item.getItemMeta(); + for(String string : lore) + lore.set(lore.indexOf(string), Utils.color(string)); + + meta.setLore(lore); + item.setItemMeta(meta); + return this; + } + + public ItemBuilder setLore(String lore) { + List list = new ArrayList<>(); + list.add(lore); + setLore(list); + return this; + } + + public ItemBuilder addLore(String lore) { + List list = item.getItemMeta().getLore(); + list.add(lore); + setLore(list); + return this; + } + + public ItemBuilder setEnchantment(HashMap enchantments) { + ItemMeta meta = item.getItemMeta(); + if(!meta.getEnchants().isEmpty()) + meta.getEnchants().clear(); + + for(Map.Entry entry : enchantments.entrySet()) + meta.addEnchant(entry.getKey(), entry.getValue(), true); + + item.setItemMeta(meta); + return this; + } + + public ItemBuilder setEnchantment(Enchantment enchantment, int i) { + ItemMeta meta = item.getItemMeta(); + if (!meta.getEnchants().isEmpty()) + meta.getEnchants().clear(); + + meta.addEnchant(enchantment, i, true); + item.setItemMeta(meta); + return this; + } + + public ItemBuilder addEnchantment(Enchantment enchantment, int i) { + ItemMeta meta = item.getItemMeta(); + meta.addEnchant(enchantment, i, true); + item.setItemMeta(meta); + return this; + } + + public ItemBuilder clone() { + return new ItemBuilder(item); + } + +} \ No newline at end of file diff --git a/src/main/java/me/paradoxpixel/themepark/utils/LocationUtils.java b/src/main/java/me/paradoxpixel/themepark/utils/LocationUtils.java new file mode 100644 index 0000000..b7b391e --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/utils/LocationUtils.java @@ -0,0 +1,50 @@ +package me.paradoxpixel.themepark.utils; + +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.World; + +public class LocationUtils { + + public static String toString(Location location) { + if(location == null) + return null; + + World world = location.getWorld(); + double x = location.getX(); + double y = location.getY(); + double z = location.getZ(); + + String string = world.getName() + ":" + x + ":" + y + ":" + z; + if(location.getYaw() != 0 || location.getPitch() != 0) + string += ":" + location.getYaw() + ":" + location.getPitch(); + + return string; + } + + public static Location toLocation(String string) { + if(string == null) + return null; + + String[] args = string.split(":"); + if(args.length < 4) + return null; + + World world = Bukkit.getWorld(args[0]); + double x = Double.parseDouble(args[1]); + double y = Double.parseDouble(args[2]); + double z = Double.parseDouble(args[3]); + + Location location = new Location(world, x, y, z); + if(args.length < 6) + return location; + + float yaw = Float.parseFloat(args[4]); + float pitch = Float.parseFloat(args[5]); + location.setYaw(yaw); + location.setPitch(pitch); + + return location; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/utils/Message.java b/src/main/java/me/paradoxpixel/themepark/utils/Message.java new file mode 100644 index 0000000..204ada2 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/utils/Message.java @@ -0,0 +1,25 @@ +package me.paradoxpixel.themepark.utils; + +import me.paradoxpixel.themepark.ThemeParkPlugin; +import me.paradoxpixel.themepark.config.YamlConfig; + +public class Message { + + private static YamlConfig config = ThemeParkPlugin.getInstance().getMessage(); + + public static boolean isMessage(String string) { + return config.getConfig().contains(string); + } + + public static String getMessage(String string) { + if(!isMessage(string)) + return ""; + + String message = config.getConfig().getString(string); + if(isMessage("prefix")) + message = message.replace("{prefix}", config.getConfig().getString("prefix")); + + return message; + } + +} diff --git a/src/main/java/me/paradoxpixel/themepark/utils/Utils.java b/src/main/java/me/paradoxpixel/themepark/utils/Utils.java new file mode 100644 index 0000000..1116260 --- /dev/null +++ b/src/main/java/me/paradoxpixel/themepark/utils/Utils.java @@ -0,0 +1,15 @@ +package me.paradoxpixel.themepark.utils; + +import org.bukkit.ChatColor; + +public class Utils { + + public static String color(String string) { + return ChatColor.translateAlternateColorCodes('&', string); + } + + public static int toSize(int i, int size) { + return i % size == 0 ? i : i + (size - (i % size)); + } + +} diff --git a/src/main/resources/attraction.yml b/src/main/resources/attraction.yml new file mode 100644 index 0000000..1eb28e1 --- /dev/null +++ b/src/main/resources/attraction.yml @@ -0,0 +1,40 @@ +region: + global: + name: "&5Global" + lore: + - "&5Global Locations" + fantasy: + name: "&aFantasy" + lore: + - "&aFantasy Themed rides" + multiple: + name: "&fMultiple" + lore: + - "&fYou can have" + - "&fMultiple lines" + - "&fWith Lore" + +attraction: + ride1: + name: "&aRide #1" + region_id: "fantasy" + type: RIDE + status: CLOSED + location: "world:0:0:0" + show1: + name: "&aFirst Show" + region_id: "fantasy" + type: SHOW + status: INACTIVE + location: "world:0:0:0" + global1: + name: "&aFirst Global" + region_id: "global" + type: GLOBAL + location: "world:0:0:0" + random: + name: "&fRandom" + type: RIDE + status: CLOSED + region_id: multiple + location: "world:0:0:0" \ No newline at end of file diff --git a/src/main/resources/message.yml b/src/main/resources/message.yml new file mode 100644 index 0000000..2aa923e --- /dev/null +++ b/src/main/resources/message.yml @@ -0,0 +1,42 @@ +prefix: "&6Themepark&f:" + +onlyplayers: "{prefix} &4Only players can use this command" +nopermission: "{prefix} &4You don't have permission to use this command" +noplayer: "{prefix} &4No player found with name: {name}" +nonumber: "&6Themepark&f: &4{number} &4is not a valid number" + +reloaded: "{prefix} &aThe plugin has been reloaded" + +menu: + item: + enabled: "&aENABLED" + disabled: "&4DISABLED" + toggle: "{prefix} &aMenu item has been {status}" + +region: + no: "{prefix} &4There is no region with ID: {id}" + changed: + name: "{prefix} &aChanged the name tho: {name} &aFor region: {id}" + lore: "{prefix} &aChanged the lore with index &f{index} &ato: {lore} &afor region: &f{id}" + +status: + no: "{prefix} &4There is no status named: {status}" + +attraction: + notfound: "&4No attractions found" + list: "&6ID: &f{id} &6Name: &f{name} &6Region: &f{region} &6Status: &f{status}" + no: "{prefix} &4There is no attraction with ID: {id}" + nostatus: "{prefix} &4Attraction: {name} &4has no status named: {status}" + changed: + status: + CONSTRUCTION: "{prefix} &fAttraction: {name} &fis now &7Under Construction" + OPEN: "{prefix} &fAttraction: {name} &fhas been &aOpened" + CLOSED: "{prefix} &fAttraction: {name} &fhas been &4Closed" + MAINTENANCE: "{prefix} &fAttraction: {name} &fis now in &6Maintenance" + MALFUNCTION: "{prefix} &fAttraction: {name} &fhas been closed due to a &5Malfunction" + ACTIVE: "{prefix} &fShow: {name} &fis now &aActive" + INACTIVE: "{prefix} &fShow: {name} &fis now &4In Active" + location: "&6ThemePark&f: &aChanged locatation of attraction: {name} &ato your current location" + teleport: + status: "{prefix} &4It's not possible to teleport to {name} &4because it's {status}" + success: "{prefix} &ayou have been teleported to the attraction: {name}" \ No newline at end of file diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..2a30d0d --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,6 @@ +name: ThemePark +version: 1.1 +main: me.paradoxpixel.themepark.ThemeParkPlugin +author: ParadoxPixel +commands: + status: \ No newline at end of file diff --git a/src/main/resources/settings.yml b/src/main/resources/settings.yml new file mode 100644 index 0000000..ac29cbc --- /dev/null +++ b/src/main/resources/settings.yml @@ -0,0 +1,72 @@ +command: 'themepark' + +sign: + name: "[ThemePark]" + title: "&f[&6ThemePark&f]" + +menu: + title: "&6StatusMenu" + +inventory: + clear: true + +item: + material: NETHER_STAR + display-name: 'Themepark' + slot: 4 + +mysql: + enabled: false + host: 'localhost' + port: 3306 + database: 'database' + user: 'username' + password: 'password' + +CONSTRUCTION: + name: "&7Under Construction" + material: STAINED_CLAY + data: 1 + teleport: false + +OPEN: + name: "&aOpen" + material: STAINED_CLAY + data: 5 + teleport: true + +CLOSED: + name: "&4Closed" + material: STAINED_CLAY + data: 14 + teleport: true + +MAINTENANCE: + name: "&6Maintenance" + material: STAINED_CLAY + data: 4 + teleport: true + +MALFUNCTION: + name: "&5Malfunction" + material: STAINED_CLAY + data: 10 + teleport: true + +ACTIVE: + name: "&aActive" + material: STAINED_CLAY + data: 5 + teleport: true + +INACTIVE: + name: "&4In Active" + material: STAINED_CLAY + data: 14 + teleport: true + +GLOBAL: + name: "&bGlobal" + material: STAINED_CLAY + data: 11 + teleport: true \ No newline at end of file