Upstream/FabledSkyBlock
1
0
Fork 0
mirror of https://github.com/songoda/FabledSkyBlock.git synced 2024-10-04 09:27:33 +02:00
Code Issues Projects Releases Wiki Activity

API

Browse Source
This commit is contained in:
Unknown 2018-12-07 20:25:10 +00:00
parent e864fbc257
commit e6703dff76
51 changed files with 1222 additions and 698 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
pom.xml
View File

@ -15,28 +15,6 @@
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<version>3.0.1</version>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<configuration>
<reportOutputDirectory>${basedir}</reportOutputDirectory>
<destDir>apidocs</destDir>
<source>39</source>
<show>public</show>
<doctitle>SkyBlock API</doctitle>
<title>SkyBlock API</title>
<sourcepath>${basedir}/src/main/java/me/goodandevil/skyblock/api</sourcepath>
</configuration>
<executions>
<execution>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<repositories>

266
src/main/java/me/goodandevil/skyblock/api/SkyBlockAPI.java
View File

@ -1,9 +1,25 @@
package me.goodandevil.skyblock.api;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.block.Biome;
import org.bukkit.entity.Player;
import com.google.common.base.Preconditions;
import me.goodandevil.skyblock.SkyBlock;
import me.goodandevil.skyblock.api.island.Island;
import me.goodandevil.skyblock.api.island.IslandRole;
import me.goodandevil.skyblock.api.structure.Structure;
import me.goodandevil.skyblock.api.utils.APIUtil;
import me.goodandevil.skyblock.island.IslandManager;
import me.goodandevil.skyblock.playerdata.PlayerData;
import me.goodandevil.skyblock.playerdata.PlayerDataManager;
public class SkyBlockAPI {
@ -27,10 +43,258 @@ public class SkyBlockAPI {
return implementation;
}
/**
* Set the Biome of an Island
*/
public static void setBiome(Island island, Biome biome) {
Preconditions.checkArgument(island != null, "Cannot set biome to null island");
Preconditions.checkArgument(biome != null, "Cannot set biome to null biome");
implementation.getBiomeManager().setBiome(island.getIsland(), biome);
}
/**
* Calculates the points of an Island to determine what the Island level is
*/
public static void calculatePoints(Island island) {
Preconditions.checkArgument(island != null, "Cannot calculate points to null island");
implementation.getLevellingManager().calculatePoints(null, island.getIsland());
}
/**
* @return The Structure for an Island
*/
public static Structure getStructure(String structure) {
return implementation.getStructureManager().getStructure(structure);
}
/**
* @return true of conditions met, false otherwise
*/
public static boolean hasStructure(String structure) {
return implementation.getStructureManager().containsStructure(structure);
}
/**
* @return A List of Structures for an Island
*/
public static List<Structure> getStructures() {
List<Structure> structures = new ArrayList<>();
for (Structure structureList : implementation.getStructureManager().getStructures()) {
structures.add(structureList);
}
return structures;
}
/**
* Gives Island ownership to a player of their Island
*/
public static void giveOwnership(Player player) {
Preconditions.checkArgument(player != null, "Cannot give ownership to null player");
Island island = getIsland(player);
if (island != null && island.getRole(player) != IslandRole.OWNER) {
implementation.getIslandManager().giveIslandOwnership(player.getUniqueId());
}
}
/**
* @return The Visitors occupying an Island
*/
public static Set<UUID> getVisitorsAtIsland(Island island) {
Preconditions.checkArgument(island != null, "Cannot get visitors at island to null island");
return implementation.getIslandManager().getVisitorsAtIsland(island.getIsland());
}
/**
* Makes a player a Visitor of an Island
*/
public static void visitIsland(Player player, Island island) {
Preconditions.checkArgument(player != null, "Cannot visit island to null player");
Preconditions.checkArgument(island != null, "Cannot visit island to null island");
implementation.getIslandManager().visitIsland(player, island.getIsland());
}
/**
* Closes an Island from Visitors
*/
public static void closeIsland(Island island) {
Preconditions.checkArgument(island != null, "Cannot closed island to null island");
implementation.getIslandManager().closeIsland(island.getIsland());
}
/**
* Checks if a player has permission at an Island for a Setting
*
* @return true of conditions met, false otherwise
*/
public static boolean hasPermission(Player player, String setting) {
Preconditions.checkArgument(player != null, "Cannot check permission to null player");
return implementation.getIslandManager().hasPermission(player, setting);
}
/**
* Checks the permission of a Setting for a Role at a Location
*
* @return true of conditions met, false otherwise
*/
public static boolean hasSetting(Location location, IslandRole role, String setting) {
Preconditions.checkArgument(location != null, "Cannot check setting to null location");
Preconditions.checkArgument(role != null, "Cannot check setting to null role");
return implementation.getIslandManager().hasSetting(location, APIUtil.toImplementation(role), setting);
}
/**
* @return A Set of Members of an Island that are online
*/
public static Set<UUID> getMembersOnline(Island island) {
Preconditions.checkArgument(island != null, "Cannot get online members to null island");
return implementation.getIslandManager().getMembersOnline(island.getIsland());
}
/**
* @return A Set of Players at an Island
*/
public static Set<UUID> getPlayersAtIsland(Island island) {
Preconditions.checkArgument(island != null, "Cannot get players at island to null island");
return implementation.getIslandManager().getPlayersAtIsland(island.getIsland());
}
/**
* Gives the Island Upgrades to a player
*/
public static void giveUgrades(Player player, Island island) {
Preconditions.checkArgument(player != null, "Cannot give upgrades to null player");
Preconditions.checkArgument(island != null, "Cannot give upgrades to null island");
implementation.getIslandManager().giveUpgrades(player, island.getIsland());
}
/**
* Removes the Island Upgrades from a player
*/
public static void removeUpgrades(Player player) {
Preconditions.checkArgument(player != null, "Cannot remove upgrades to null player");
implementation.getIslandManager().removeUpgrades(player);
}
/**
* @return A Set of Cooped Players at an Island
*/
public static Set<UUID> getCoopPlayersAtIsland(Island island) {
Preconditions.checkArgument(island != null, "Cannot get coop players to null island");
return implementation.getIslandManager().getCoopPlayersAtIsland(island.getIsland());
}
/**
* Creates an Island for a player from a Structure
*
* @return true of conditions met, false otherwise
*/
public static boolean createIsland(Player player, Structure structure) {
Preconditions.checkArgument(player != null, "Cannot create island to null player");
Preconditions.checkArgument(structure != null, "Cannot create island to null structure");
if (!hasIsland(player)) {
return implementation.getIslandManager().createIsland(player,
(me.goodandevil.skyblock.structure.Structure) structure);
}
return false;
}
/**
* Deletes an Island permanently
*/
public static void deleteIsland(Island island) {
Preconditions.checkArgument(island != null, "Cannot delete island to null island");
implementation.getIslandManager().deleteIsland(island.getIsland());
}
/**
* @return The Island of a player
*/
public static Island getIsland(Player player) {
return implementation.getIslandManager().getIsland(player.getUniqueId()).getAPIWrapper();
Preconditions.checkArgument(player != null, "Cannot get island to null player");
PlayerDataManager playerDataManager = implementation.getPlayerDataManager();
if (playerDataManager.hasPlayerData(player)) {
PlayerData playerData = playerDataManager.getPlayerData(player);
if (playerData.getOwner() != null) {
return implementation.getIslandManager().getIsland(playerData.getOwner()).getAPIWrapper();
}
}
return null;
}
/**
* @return true of conditions met, false otherwise
*/
public static boolean hasIsland(OfflinePlayer player) {
Preconditions.checkArgument(player != null, "Cannot check island to null player");
return new me.goodandevil.skyblock.utils.OfflinePlayer(player.getUniqueId()).getOwner() != null;
}
/**
* @return true of conditions met, false otherwise
*/
public static boolean isPlayerAtAnIsland(Player player) {
Preconditions.checkArgument(player != null, "Cannot check to null player");
PlayerDataManager playerDataManager = implementation.getPlayerDataManager();
if (playerDataManager.hasPlayerData(player)) {
PlayerData playerData = playerDataManager.getPlayerData(player);
if (playerData.getIsland() != null) {
return true;
}
}
return false;
}
/**
* Check if a player is occupying an Island
*
* @return true of conditions met, false otherwise
*/
public static boolean isPlayerAtIsland(Player player, Island island) {
Preconditions.checkArgument(player != null, "Cannot check to null player");
Preconditions.checkArgument(island != null, "Cannot check to null island");
PlayerDataManager playerDataManager = implementation.getPlayerDataManager();
if (playerDataManager.hasPlayerData(player)) {
PlayerData playerData = playerDataManager.getPlayerData(player);
if (playerData.getIsland() != null && playerData.getIsland().equals(island.getOwnerUUID())) {
return true;
}
}
return false;
}
/**
* @return The Island the player is occupying
*/
public static Island getIslandPlayerAt(Player player) {
Preconditions.checkArgument(player != null, "Cannot get Island to null player");
PlayerDataManager playerDataManager = implementation.getPlayerDataManager();
IslandManager islandManager = implementation.getIslandManager();
if (playerDataManager.hasPlayerData(player)) {
PlayerData playerData = playerDataManager.getPlayerData(player);
if (playerData.getIsland() != null && islandManager.hasIsland(playerData.getIsland())) {
return islandManager.getIsland(playerData.getIsland()).getAPIWrapper();
}
}
return null;
}
}

21
src/main/java/me/goodandevil/skyblock/api/ban/Ban.java
View File

@ -3,6 +3,8 @@ package me.goodandevil.skyblock.api.ban;
import java.util.Set;
import java.util.UUID;
import com.google.common.base.Preconditions;
import me.goodandevil.skyblock.api.island.Island;
public class Ban {
@ -13,19 +15,34 @@ public class Ban {
this.handle = handle;
}
/**
* @return true of conditions met, false otherwise
*/
public boolean isBanned(UUID uuid) {
Preconditions.checkArgument(uuid != null, "Cannot return condition to null uuid");
return getBans().contains(uuid);
}
/**
* @return A Set of players that have banned from the Island
*/
public Set<UUID> getBans() {
return handle.getIsland().getBan().getBans();
}
public void addBan(UUID uuid) {
handle.getIsland().getBan().addBan(uuid);
/**
* Add a player to the banned players for the Island
*/
public void addBan(UUID issuer, UUID banned) {
Preconditions.checkArgument(banned != null, "Cannot add ban to null banned uuid");
handle.getIsland().getBan().addBan(issuer, banned);
}
/**
* Remove a player from the banned players for the Island
*/
public void removeBan(UUID uuid) {
Preconditions.checkArgument(uuid != null, "Cannot remove ban to null uuid");
handle.getIsland().getBan().removeBan(uuid);
}

48
src/main/java/me/goodandevil/skyblock/api/event/island/IslandBanEvent.java Normal file
View File

@ -0,0 +1,48 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.OfflinePlayer;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandBanEvent extends IslandEvent implements Cancellable {
private static final HandlerList HANDLERS = new HandlerList();
private boolean cancelled = false;
private final OfflinePlayer issuer, banned;
public IslandBanEvent(Island island, OfflinePlayer issuer, OfflinePlayer banned) {
super(island);
this.issuer = issuer;
this.banned = banned;
}
public OfflinePlayer getIssuer() {
return issuer;
}
public OfflinePlayer getBanned() {
return banned;
}
@Override
public void setCancelled(boolean cancel) {
this.cancelled = cancel;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

35
src/main/java/me/goodandevil/skyblock/api/event/island/IslandBiomeChangeEvent.java Normal file
View File

@ -0,0 +1,35 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.block.Biome;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandBiomeChangeEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private Biome biome;
public IslandBiomeChangeEvent(Island island, Biome biome) {
super(island);
this.biome = biome;
}
public Biome getBiome() {
return biome;
}
public void setBiome(Biome biome) {
this.biome = biome;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

31
src/main/java/me/goodandevil/skyblock/api/event/island/IslandCreateEvent.java Normal file
View File

@ -0,0 +1,31 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandCreateEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private final Player player;
public IslandCreateEvent(Island island, Player player) {
super(island);
this.player = player;
}
public Player getPlayer() {
return player;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

23
src/main/java/me/goodandevil/skyblock/api/event/island/IslandDeleteEvent.java Normal file
View File

@ -0,0 +1,23 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandDeleteEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
public IslandDeleteEvent(Island island) {
super(island);
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

18
src/main/java/me/goodandevil/skyblock/api/event/island/IslandEvent.java Normal file
View File

@ -0,0 +1,18 @@
package me.goodandevil.skyblock.api.event.island;
import me.goodandevil.skyblock.api.island.Island;
import org.bukkit.event.Event;
public abstract class IslandEvent extends Event {
private final Island island;
protected IslandEvent(Island island) {
this.island = island;
}
public Island getIsland() {
return island;
}
}

31
src/main/java/me/goodandevil/skyblock/api/event/island/IslandLevelChangeEvent.java Normal file
View File

@ -0,0 +1,31 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
import me.goodandevil.skyblock.api.level.Level;
public class IslandLevelChangeEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private final Level level;
public IslandLevelChangeEvent(Island island, Level level) {
super(island);
this.level = level;
}
public Level getLevelData() {
return level;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

23
src/main/java/me/goodandevil/skyblock/api/event/island/IslandLoadEvent.java Normal file
View File

@ -0,0 +1,23 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandLoadEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
public IslandLoadEvent(Island island) {
super(island);
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

31
src/main/java/me/goodandevil/skyblock/api/event/island/IslandLocationChangeEvent.java Normal file
View File

@ -0,0 +1,31 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
import me.goodandevil.skyblock.api.island.IslandLocation;
public class IslandLocationChangeEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private final IslandLocation location;
public IslandLocationChangeEvent(Island island, IslandLocation location) {
super(island);
this.location = location;
}
public IslandLocation getLocation() {
return location;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

65
src/main/java/me/goodandevil/skyblock/api/event/island/IslandMessageChangeEvent.java Normal file
View File

@ -0,0 +1,65 @@
package me.goodandevil.skyblock.api.event.island;
import java.util.List;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
import me.goodandevil.skyblock.api.island.IslandMessage;
public class IslandMessageChangeEvent extends IslandEvent implements Cancellable {
private static final HandlerList HANDLERS = new HandlerList();
private boolean cancelled = false;
private final IslandMessage message;
private List<String> lines;
private String author;
public IslandMessageChangeEvent(Island island, IslandMessage message, List<String> lines, String author) {
super(island);
this.message = message;
this.lines = lines;
this.author = author;
}
public IslandMessage getMessage() {
return message;
}
public List<String> getLines() {
return lines;
}
public void setLines(List<String> lines) {
this.lines = lines;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancel) {
this.cancelled = cancel;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

42
src/main/java/me/goodandevil/skyblock/api/event/island/IslandOpenEvent.java Normal file
View File

@ -0,0 +1,42 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandOpenEvent extends IslandEvent implements Cancellable {
private static final HandlerList HANDLERS = new HandlerList();
private boolean cancelled = false;
private final boolean open;
public IslandOpenEvent(Island island, boolean open) {
super(island);
this.open = open;
}
public boolean isOpen() {
return open;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public HandlerList getHandlerList() {
return HANDLERS;
}
}

31
src/main/java/me/goodandevil/skyblock/api/event/island/IslandOwnershipTransferEvent.java Normal file
View File

@ -0,0 +1,31 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.OfflinePlayer;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandOwnershipTransferEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private final OfflinePlayer owner;
public IslandOwnershipTransferEvent(Island island, OfflinePlayer owner) {
super(island);
this.owner = owner;
}
public OfflinePlayer getOwner() {
return owner;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

34
src/main/java/me/goodandevil/skyblock/api/event/island/IslandPasswordChangeEvent.java Normal file
View File

@ -0,0 +1,34 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandPasswordChangeEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private String password;
public IslandPasswordChangeEvent(Island island, String password) {
super(island);
this.password = password;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

38
src/main/java/me/goodandevil/skyblock/api/event/island/IslandRoleChangeEvent.java Normal file
View File

@ -0,0 +1,38 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.OfflinePlayer;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
import me.goodandevil.skyblock.api.island.IslandRole;
public class IslandRoleChangeEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private final OfflinePlayer player;
private final IslandRole role;
public IslandRoleChangeEvent(Island island, OfflinePlayer player, IslandRole role) {
super(island);
this.player = player;
this.role = role;
}
public OfflinePlayer getPlayer() {
return player;
}
public IslandRole getRole() {
return role;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

31
src/main/java/me/goodandevil/skyblock/api/event/island/IslandUnbanEvent.java Normal file
View File

@ -0,0 +1,31 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.OfflinePlayer;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandUnbanEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private final OfflinePlayer unbanned;
public IslandUnbanEvent(Island island, OfflinePlayer unbanned) {
super(island);
this.unbanned = unbanned;
}
public OfflinePlayer getUnbanned() {
return unbanned;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

23
src/main/java/me/goodandevil/skyblock/api/event/island/IslandUnloadEvent.java Normal file
View File

@ -0,0 +1,23 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandUnloadEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
public IslandUnloadEvent(Island island) {
super(island);
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

44
src/main/java/me/goodandevil/skyblock/api/event/island/IslandWeatherChangeEvent.java Normal file
View File

@ -0,0 +1,44 @@
package me.goodandevil.skyblock.api.event.island;
import org.bukkit.WeatherType;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.api.island.Island;
public class IslandWeatherChangeEvent extends IslandEvent {
private static final HandlerList HANDLERS = new HandlerList();
private WeatherType weather;
private int time;
private final boolean sync;
public IslandWeatherChangeEvent(Island island, WeatherType weather, int time, boolean sync) {
super(island);
this.weather = weather;
this.time = time;
this.sync = sync;
}
public WeatherType getWeather() {
return weather;
}
public int getTime() {
return time;
}
public boolean isSync() {
return sync;
}
@Override
public HandlerList getHandlers() {
return HANDLERS;
}
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

8
src/main/java/me/goodandevil/skyblock/api/island/Island.java
View File

@ -6,6 +6,7 @@ import java.util.Set;
import java.util.UUID;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.WeatherType;
import org.bukkit.World;
import org.bukkit.block.Biome;
@ -17,7 +18,6 @@ import me.goodandevil.skyblock.api.level.Level;
import me.goodandevil.skyblock.api.setting.Setting;
import me.goodandevil.skyblock.api.utils.APIUtil;
import me.goodandevil.skyblock.api.visit.Visit;
import me.goodandevil.skyblock.utils.OfflinePlayer;
public class Island {
@ -122,14 +122,14 @@ public class Island {
/**
* @return true of conditions met, false otherwise
*/
public boolean isWeatherSynchronized() {
public boolean isDayCycleSynchronizedSynchronized() {
return this.handle.isWeatherSynchronized();
}
/**
* Set the weather of the Island to be Synchronized with the World time
* Set the Day Cycle of the Island to be Synchronized with the World cycle
*/
public void setWeatherSynchronzied(boolean sync) {
public void setDayCycleSynchronzied(boolean sync) {
this.handle.setWeatherSynchronized(sync);
}

45
src/main/java/me/goodandevil/skyblock/api/island/IslandLocation.java Normal file
View File

@ -0,0 +1,45 @@
package me.goodandevil.skyblock.api.island;
import org.bukkit.Location;
import org.bukkit.World;
public class IslandLocation {
private IslandEnvironment environment;
private IslandWorld world;
private Location location;
public IslandLocation(IslandEnvironment environment, IslandWorld world, Location location) {
this.environment = environment;
this.world = world;
this.location = location;
}
public IslandEnvironment getEnvironment() {
return environment;
}
public IslandWorld getWorld() {
return world;
}
public Location getLocation() {
return location;
}
public World getBukkitWorld() {
return location.getWorld();
}
public int getX() {
return location.getBlockX();
}
public int getY() {
return location.getBlockY();
}
public int getZ() {
return location.getBlockZ();
}
}

99
src/main/java/me/goodandevil/skyblock/api/level/Level.java
View File

@ -1,6 +1,11 @@
package me.goodandevil.skyblock.api.level;
import org.bukkit.Material;
import com.google.common.base.Preconditions;
import me.goodandevil.skyblock.api.island.Island;
import me.goodandevil.skyblock.utils.version.Materials;
public class Level {
@ -10,6 +15,100 @@ public class Level {
this.handle = handle;
}
/**
* @return Points of the Island from gathered materials
*/
public int getPoints() {
return this.handle.getLevel().getPoints();
}
/**
* @return Level of the Island from points
*/
public int getLevel() {
return this.handle.getLevel().getLevel();
}
/**
* @return Last calculated points of the Island
*/
public int getLastCalculatedPoints() {
return this.handle.getLevel().getLastCalculatedPoints();
}
/**
* @return Last calculated level of the Island
*/
public int getLastCalculatedLevel() {
return this.handle.getLevel().getLastCalculatedLevel();
}
/**
* Set the amount of a Material for the Island
*/
public void setMaterialAmount(Material material, int amount) {
Preconditions.checkArgument(material != null, "Cannot set material amount to null material");
this.handle.getIsland().getLevel().setMaterialAmount(Materials.fromString(material.name()).name(), amount);
}
/**
* Set the amount of a Material for the Island
*/
public void setMaterialAmount(Material material, byte data, int amount) {
Preconditions.checkArgument(material != null, "Cannot set material amount to null material");
this.handle.getIsland().getLevel().setMaterialAmount(Materials.requestMaterials(material.name(), data).name(),
amount);
}
/**
* @return The amount of a Material from the Island
*/
public int getMaterialAmount(Material material) {
Preconditions.checkArgument(material != null, "Cannot get material amount to null material");
Materials materials = Materials.fromString(material.name());
me.goodandevil.skyblock.island.Level level = this.handle.getIsland().getLevel();
if (level.getMaterials().containsKey(materials.name())) {
return level.getMaterials().get(materials.name());
}
return 0;
}
/**
* @return The amount of a Material from the Island
*/
public int getMaterialAmount(Material material, byte data) {
Preconditions.checkArgument(material != null, "Cannot get material amount to null material");
Materials materials = Materials.requestMaterials(material.name(), data);
me.goodandevil.skyblock.island.Level level = this.handle.getIsland().getLevel();
if (level.getMaterials().containsKey(materials.name())) {
return level.getMaterials().get(materials.name());
}
return 0;
}
/**
* @return The points earned for a Material from the Island
*/
public int getMaterialPoints(Material material) {
Preconditions.checkArgument(material != null, "Cannot get material points to null material");
return this.handle.getIsland().getLevel().getMaterialPoints(Materials.fromString(material.name()).name());
}
/**
* @return The points earned for a Material from the Island
*/
public int getMaterialPoints(Material material, byte data) {
Preconditions.checkArgument(material != null, "Cannot get material points to null material");
return this.handle.getIsland().getLevel()
.getMaterialPoints(Materials.requestMaterials(material.name(), data).name());
}
/**
* @return Implementation for the Island
*/

34
src/main/java/me/goodandevil/skyblock/api/structure/Structure.java Normal file
View File

@ -0,0 +1,34 @@
package me.goodandevil.skyblock.api.structure;
import java.util.List;
import me.goodandevil.skyblock.utils.version.Materials;
public interface Structure {
public String getName();
public Materials getMaterials();
public void setMaterials(Materials materials);
public String getFile();
public void setFile(String file);
public String getDisplayname();
public void setDisplayname(String displayName);
public boolean isPermission();
public String getPermission();
public void setPermission(boolean permission);
public List<String> getDescription();
public void addLine(String line);
public void removeLine(int index);
}

46
src/main/java/me/goodandevil/skyblock/api/utils/APIUtil.java
View File

@ -7,7 +7,6 @@ import me.goodandevil.skyblock.api.island.IslandUpgrade;
import me.goodandevil.skyblock.api.island.IslandWorld;
import me.goodandevil.skyblock.island.Location.Environment;
import me.goodandevil.skyblock.island.Location.World;
import me.goodandevil.skyblock.island.Message;
import me.goodandevil.skyblock.upgrade.Upgrade;
public final class APIUtil {
@ -23,6 +22,17 @@ public final class APIUtil {
return null;
}
public static IslandWorld fromImplementation(World world) {
switch (world) {
case Nether:
return IslandWorld.NETHER;
case Normal:
return IslandWorld.OVERWORLD;
}
return null;
}
public static Environment toImplementation(IslandEnvironment environment) {
switch (environment) {
case ISLAND:
@ -36,6 +46,19 @@ public final class APIUtil {
return null;
}
public static IslandEnvironment fromImplementation(Environment environment) {
switch (environment) {
case Island:
return IslandEnvironment.ISLAND;
case Main:
return IslandEnvironment.MAIN;
case Visitor:
return IslandEnvironment.VISITOR;
}
return null;
}
public static me.goodandevil.skyblock.island.IslandRole toImplementation(IslandRole role) {
switch (role) {
case VISITOR:
@ -91,14 +114,27 @@ public final class APIUtil {
return null;
}
public static Message toImplementation(IslandMessage message) {
public static me.goodandevil.skyblock.island.IslandMessage toImplementation(IslandMessage message) {
switch (message) {
case SIGN:
return Message.Sign;
return me.goodandevil.skyblock.island.IslandMessage.Sign;
case SIGNATURE:
return Message.Signature;
return me.goodandevil.skyblock.island.IslandMessage.Signature;
case WELCOME:
return Message.Welcome;
return me.goodandevil.skyblock.island.IslandMessage.Welcome;
}
return null;
}
public static IslandMessage fromImplementation(me.goodandevil.skyblock.island.IslandMessage message) {
switch (message) {
case Sign:
return IslandMessage.SIGN;
case Signature:
return IslandMessage.SIGNATURE;
case Welcome:
return IslandMessage.WELCOME;
}
return null;

39
src/main/java/me/goodandevil/skyblock/ban/Ban.java
View File

@ -12,9 +12,9 @@ import org.bukkit.Bukkit;
import org.bukkit.configuration.file.FileConfiguration;
import me.goodandevil.skyblock.SkyBlock;
import me.goodandevil.skyblock.api.event.island.IslandBanEvent;
import me.goodandevil.skyblock.api.event.island.IslandUnbanEvent;
import me.goodandevil.skyblock.config.FileManager.Config;
import me.goodandevil.skyblock.events.IslandBanEvent;
import me.goodandevil.skyblock.events.IslandUnbanEvent;
public class Ban {
@ -51,23 +51,28 @@ public class Ban {
return islandBans;
}
public void addBan(UUID uuid) {
public void addBan(UUID issuer, UUID banned) {
SkyBlock skyblock = SkyBlock.getInstance();
List<String> islandBans = new ArrayList<>();
FileConfiguration configLoad = skyblock.getFileManager()
.getConfig(new File(new File(skyblock.getDataFolder().toString() + "/ban-data"),
islandOwnerUUID.toString() + ".yml"))
.getFileConfiguration();
IslandBanEvent islandBanEvent = new IslandBanEvent(
skyblock.getIslandManager().getIsland(islandOwnerUUID).getAPIWrapper(),
Bukkit.getServer().getOfflinePlayer(issuer), Bukkit.getServer().getOfflinePlayer(banned));
Bukkit.getServer().getPluginManager().callEvent(islandBanEvent);
for (String islandBanList : configLoad.getStringList("Bans")) {
islandBans.add(islandBanList);
if (!islandBanEvent.isCancelled()) {
List<String> islandBans = new ArrayList<>();
FileConfiguration configLoad = skyblock.getFileManager()
.getConfig(new File(new File(skyblock.getDataFolder().toString() + "/ban-data"),
islandOwnerUUID.toString() + ".yml"))
.getFileConfiguration();
for (String islandBanList : configLoad.getStringList("Bans")) {
islandBans.add(islandBanList);
}
islandBans.add(banned.toString());
configLoad.set("Bans", islandBans);
}
islandBans.add(uuid.toString());
configLoad.set("Bans", islandBans);
Bukkit.getServer().getPluginManager().callEvent(new IslandBanEvent(uuid, this));
}
public void removeBan(UUID uuid) {
@ -87,7 +92,9 @@ public class Ban {
configLoad.set("Bans", islandBans);
Bukkit.getServer().getPluginManager().callEvent(new IslandUnbanEvent(uuid, this));
Bukkit.getServer().getPluginManager()
.callEvent(new IslandUnbanEvent(skyblock.getIslandManager().getIsland(islandOwnerUUID).getAPIWrapper(),
Bukkit.getServer().getOfflinePlayer(uuid)));
}
public void save() {

2
src/main/java/me/goodandevil/skyblock/command/commands/BanCommand.java
View File

@ -98,7 +98,7 @@ public class BanCommand extends SubCommand {
}
Ban ban = island.getBan();
ban.addBan(targetPlayerUUID);
ban.addBan(player.getUniqueId(), targetPlayerUUID);
ban.save();
if (targetPlayer != null) {

3
src/main/java/me/goodandevil/skyblock/command/commands/KickCommand.java
View File

@ -2,7 +2,6 @@ package me.goodandevil.skyblock.command.commands;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Set;
import java.util.UUID;
@ -196,7 +195,7 @@ public class KickCommand extends SubCommand {
island.save();
List<UUID> islandMembersOnline = islandManager.getMembersOnline(island);
Set<UUID> islandMembersOnline = islandManager.getMembersOnline(island);
if (islandMembersOnline.size() == 1) {
for (UUID islandMembersOnlineList : islandMembersOnline) {

4
src/main/java/me/goodandevil/skyblock/command/commands/LeaveCommand.java
View File

@ -1,7 +1,7 @@
package me.goodandevil.skyblock.command.commands;
import java.io.File;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.bukkit.Bukkit;
@ -85,7 +85,7 @@ public class LeaveCommand extends SubCommand {
playerData.setChat(false);
playerData.save();
List<UUID> islandMembersOnline = islandManager.getMembersOnline(island);
Set<UUID> islandMembersOnline = islandManager.getMembersOnline(island);
if (islandMembersOnline.size() == 1) {
for (UUID islandMembersOnlineList : islandMembersOnline) {

37
src/main/java/me/goodandevil/skyblock/events/IslandBanEvent.java
View File

@ -1,37 +0,0 @@
package me.goodandevil.skyblock.events;
import java.util.UUID;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.ban.Ban;
public class IslandBanEvent extends Event {
private Ban ban;
private UUID uuid;
public IslandBanEvent(UUID uuid, Ban ban) {
this.uuid = uuid;
this.ban = ban;
}
public UUID getUniqueId() {
return uuid;
}
public UUID getUUID() {
return uuid;
}
public Ban getBan() {
return ban;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

37
src/main/java/me/goodandevil/skyblock/events/IslandBiomeChangeEvent.java
View File

@ -1,37 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.block.Biome;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandBiomeChangeEvent extends Event {
private Biome oldBiome, newBiome;
private Island island;
public IslandBiomeChangeEvent(Island island, Biome oldBiome, Biome newBiome) {
this.island = island;
this.oldBiome = oldBiome;
this.newBiome = newBiome;
}
public Biome getOldBiome() {
return oldBiome;
}
public Biome getNewBiome() {
return newBiome;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

32
src/main/java/me/goodandevil/skyblock/events/IslandCreateEvent.java
View File

@ -1,32 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandCreateEvent extends Event {
private Player player;
private Island island;
public IslandCreateEvent(Player player, Island island) {
this.player = player;
this.island = island;
}
public Player getPlayer() {
return player;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

25
src/main/java/me/goodandevil/skyblock/events/IslandDeleteEvent.java
View File

@ -1,25 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandDeleteEvent extends Event {
private Island island;
public IslandDeleteEvent(Island island) {
this.island = island;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

32
src/main/java/me/goodandevil/skyblock/events/IslandLevelChangeEvent.java
View File

@ -1,32 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
import me.goodandevil.skyblock.island.Level;
public class IslandLevelChangeEvent extends Event {
private Island island;
private Level level;
public IslandLevelChangeEvent(Island island, Level level) {
this.island = island;
this.level = level;
}
public Island getIsland() {
return island;
}
public Level getLevel() {
return level;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

25
src/main/java/me/goodandevil/skyblock/events/IslandLoadEvent.java
View File

@ -1,25 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandLoadEvent extends Event {
private Island island;
public IslandLoadEvent(Island island) {
this.island = island;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

37
src/main/java/me/goodandevil/skyblock/events/IslandLocationChangeEvent.java
View File

@ -1,37 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
import me.goodandevil.skyblock.island.Location;
public class IslandLocationChangeEvent extends Event {
private Location oldLocation, newLocation;
private Island island;
public IslandLocationChangeEvent(Island island, Location oldLocation, Location newLocation) {
this.island = island;
this.oldLocation = oldLocation;
this.newLocation = newLocation;
}
public Location getOldLocation() {
return oldLocation;
}
public Location getNewLocation() {
return newLocation;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

55
src/main/java/me/goodandevil/skyblock/events/IslandMessageChangeEvent.java
View File

@ -1,55 +0,0 @@
package me.goodandevil.skyblock.events;
import java.util.List;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
import me.goodandevil.skyblock.island.Message;
public class IslandMessageChangeEvent extends Event {
private Island island;
private Message message;
private List<String> lines;
private String author;
private boolean cancel = false;
public IslandMessageChangeEvent(Island island, Message message, List<String> lines, String author) {
this.island = island;
this.message = message;
this.lines = lines;
this.author = author;
}
public Island getIsland() {
return island;
}
public Message getMessage() {
return message;
}
public List<String> getLines() {
return lines;
}
public String getAuthor() {
return author;
}
public boolean isCancelled() {
return cancel;
}
public void setCancelled(boolean cancel) {
this.cancel = cancel;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

39
src/main/java/me/goodandevil/skyblock/events/IslandOpenEvent.java
View File

@ -1,39 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandOpenEvent extends Event {
private Island island;
private boolean open, cancel = false;
public IslandOpenEvent(Island island, boolean open) {
this.island = island;
this.open = open;
}
public Island getIsland() {
return island;
}
public boolean isOpen() {
return open;
}
public boolean isCancelled() {
return cancel;
}
public void setCancelled(boolean cancel) {
this.cancel = cancel;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

38
src/main/java/me/goodandevil/skyblock/events/IslandOwnershipTransferEvent.java
View File

@ -1,38 +0,0 @@
package me.goodandevil.skyblock.events;
import java.util.UUID;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandOwnershipTransferEvent extends Event {
private UUID oldOwnerUUID, newOwnerUUID;
private Island island;
public IslandOwnershipTransferEvent(Island island, UUID oldOwnerUUID, UUID newOwnerUUID) {
this.island = island;
this.oldOwnerUUID = oldOwnerUUID;
this.newOwnerUUID = newOwnerUUID;
}
public UUID getOldOwnerUUID() {
return oldOwnerUUID;
}
public UUID getNewOwnerUUID() {
return newOwnerUUID;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

45
src/main/java/me/goodandevil/skyblock/events/IslandPasswordChangeEvent.java
View File

@ -1,45 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandPasswordChangeEvent extends Event {
private String oldPassword, newPassword;
private boolean cancel = false;
private Island island;
public IslandPasswordChangeEvent(Island island, String oldPassword, String newPassword) {
this.island = island;
this.oldPassword = oldPassword;
this.newPassword = newPassword;
}
public String getOldPassword() {
return oldPassword;
}
public String getNewPassword() {
return newPassword;
}
public Island getIsland() {
return island;
}
public boolean isCancelled() {
return cancel;
}
public void setCancelled(boolean cancel) {
this.cancel = cancel;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

49
src/main/java/me/goodandevil/skyblock/events/IslandRoleChangeEvent.java
View File

@ -1,49 +0,0 @@
package me.goodandevil.skyblock.events;
import java.util.UUID;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
import me.goodandevil.skyblock.island.IslandRole;
public class IslandRoleChangeEvent extends Event {
private UUID uuid;
private Island island;
private IslandRole oldRole, newRole;
public IslandRoleChangeEvent(UUID uuid, Island island, IslandRole oldRole, IslandRole newRole) {
this.uuid = uuid;
this.island = island;
this.oldRole = oldRole;
this.newRole = newRole;
}
public UUID getUUID() {
return uuid;
}
public UUID getUniqueId() {
return uuid;
}
public IslandRole getOldRole() {
return oldRole;
}
public IslandRole getNewRole() {
return newRole;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

37
src/main/java/me/goodandevil/skyblock/events/IslandUnbanEvent.java
View File

@ -1,37 +0,0 @@
package me.goodandevil.skyblock.events;
import java.util.UUID;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.ban.Ban;
public class IslandUnbanEvent extends Event {
private Ban ban;
private UUID uuid;
public IslandUnbanEvent(UUID uuid, Ban ban) {
this.uuid = uuid;
this.ban = ban;
}
public UUID getUniqueId() {
return uuid;
}
public UUID getUUID() {
return uuid;
}
public Ban getBan() {
return ban;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

25
src/main/java/me/goodandevil/skyblock/events/IslandUnloadEvent.java
View File

@ -1,25 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandUnloadEvent extends Event {
private Island island;
public IslandUnloadEvent(Island island) {
this.island = island;
}
public Island getIsland() {
return island;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

44
src/main/java/me/goodandevil/skyblock/events/IslandWeatherChangeEvent.java
View File

@ -1,44 +0,0 @@
package me.goodandevil.skyblock.events;
import org.bukkit.WeatherType;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import me.goodandevil.skyblock.island.Island;
public class IslandWeatherChangeEvent extends Event {
private Island island;
private WeatherType weather;
private int time;
private boolean synchronised;
public IslandWeatherChangeEvent(Island island, WeatherType weather, int time, boolean synchronised) {
this.island = island;
this.weather = weather;
this.time = time;
this.synchronised = synchronised;
}
public Island getIsland() {
return island;
}
public WeatherType getWeather() {
return weather;
}
public int getTime() {
return time;
}
public boolean isSynchornised() {
return synchronised;
}
private static final HandlerList handlers = new HandlerList();
public HandlerList getHandlers() {
return handlers;
}
}

95
src/main/java/me/goodandevil/skyblock/island/Island.java
View File

@ -20,17 +20,18 @@ import org.bukkit.block.Biome;
import org.bukkit.configuration.file.FileConfiguration;
import me.goodandevil.skyblock.SkyBlock;
import me.goodandevil.skyblock.api.event.island.IslandBiomeChangeEvent;
import me.goodandevil.skyblock.api.event.island.IslandLocationChangeEvent;
import me.goodandevil.skyblock.api.event.island.IslandMessageChangeEvent;
import me.goodandevil.skyblock.api.event.island.IslandOpenEvent;
import me.goodandevil.skyblock.api.event.island.IslandPasswordChangeEvent;
import me.goodandevil.skyblock.api.event.island.IslandRoleChangeEvent;
import me.goodandevil.skyblock.api.event.island.IslandWeatherChangeEvent;
import me.goodandevil.skyblock.api.utils.APIUtil;
import me.goodandevil.skyblock.ban.Ban;
import me.goodandevil.skyblock.ban.BanManager;
import me.goodandevil.skyblock.config.FileManager;
import me.goodandevil.skyblock.config.FileManager.Config;
import me.goodandevil.skyblock.events.IslandBiomeChangeEvent;
import me.goodandevil.skyblock.events.IslandLocationChangeEvent;
import me.goodandevil.skyblock.events.IslandMessageChangeEvent;
import me.goodandevil.skyblock.events.IslandOpenEvent;
import me.goodandevil.skyblock.events.IslandPasswordChangeEvent;
import me.goodandevil.skyblock.events.IslandRoleChangeEvent;
import me.goodandevil.skyblock.events.IslandWeatherChangeEvent;
import me.goodandevil.skyblock.playerdata.PlayerData;
import me.goodandevil.skyblock.upgrade.Upgrade;
import me.goodandevil.skyblock.utils.StringUtil;
@ -41,7 +42,7 @@ import me.goodandevil.skyblock.world.WorldManager;
public class Island {
private final SkyBlock skyblock;
public final me.goodandevil.skyblock.api.island.Island apiWrapper;
private final me.goodandevil.skyblock.api.island.Island apiWrapper;
private Map<IslandRole, List<Setting>> islandSettings = new HashMap<>();
private List<Location> islandLocations = new ArrayList<>();
@ -215,7 +216,7 @@ public class Island {
new org.bukkit.Location[] { getLocation(Location.World.Normal, Location.Environment.Island),
getLocation(Location.World.Nether, Location.Environment.Island) },
size, getRole(IslandRole.Member).size() + getRole(IslandRole.Operator).size() + 1,
visitManager.getIslandSafeLevel(uuid), level, getMessage(Message.Signature), isOpen());
visitManager.getIslandSafeLevel(uuid), level, getMessage(IslandMessage.Signature), isOpen());
}
BanManager banManager = skyblock.getBanManager();
@ -277,15 +278,13 @@ public class Island {
}
public void setPassword(String password) {
IslandPasswordChangeEvent islandPasswordChangeEvent = new IslandPasswordChangeEvent(this, getPassword(),
password);
IslandPasswordChangeEvent islandPasswordChangeEvent = new IslandPasswordChangeEvent(getAPIWrapper(), password);
Bukkit.getServer().getPluginManager().callEvent(islandPasswordChangeEvent);
if (!islandPasswordChangeEvent.isCancelled()) {
skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"))
.getFileConfiguration().set("Ownership.Password", password);
}
skyblock.getFileManager()
.getConfig(new File(new File(skyblock.getDataFolder().toString() + "/island-data"),
uuid.toString() + ".yml"))
.getFileConfiguration().set("Ownership.Password", islandPasswordChangeEvent.getPassword());
}
public org.bukkit.Location getLocation(Location.World world, Location.Environment environment) {
@ -301,8 +300,11 @@ public class Island {
public void setLocation(Location.World world, Location.Environment environment, org.bukkit.Location location) {
for (Location islandLocationList : islandLocations) {
if (islandLocationList.getWorld() == world && islandLocationList.getEnvironment() == environment) {
Bukkit.getServer().getPluginManager().callEvent(new IslandLocationChangeEvent(this, islandLocationList,
new Location(world, environment, location)));
Bukkit.getServer().getPluginManager()
.callEvent(new IslandLocationChangeEvent(getAPIWrapper(),
new me.goodandevil.skyblock.api.island.IslandLocation(
APIUtil.fromImplementation(environment), APIUtil.fromImplementation(world),
location)));
FileManager fileManager = skyblock.getFileManager();
fileManager.setLocation(
@ -329,10 +331,13 @@ public class Island {
}
public void setBiome(Biome biome) {
Bukkit.getServer().getPluginManager().callEvent(new IslandBiomeChangeEvent(this, getBiome(), biome));
skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"))
.getFileConfiguration().set("Biome.Type", biome.name());
IslandBiomeChangeEvent islandBiomeChangeEvent = new IslandBiomeChangeEvent(getAPIWrapper(), biome);
Bukkit.getServer().getPluginManager().callEvent(islandBiomeChangeEvent);
skyblock.getFileManager()
.getConfig(new File(new File(skyblock.getDataFolder().toString() + "/island-data"),
uuid.toString() + ".yml"))
.getFileConfiguration().set("Biome.Type", islandBiomeChangeEvent.getBiome().name());
}
public boolean isWeatherSynchronized() {
@ -342,8 +347,10 @@ public class Island {
}
public void setWeatherSynchronized(boolean sync) {
Bukkit.getServer().getPluginManager()
.callEvent(new IslandWeatherChangeEvent(this, getWeather(), getTime(), sync));
IslandWeatherChangeEvent islandWeatherChangeEvent = new IslandWeatherChangeEvent(getAPIWrapper(), getWeather(),
getTime(), sync);
Bukkit.getServer().getPluginManager().callEvent(islandWeatherChangeEvent);
skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"))
.getFileConfiguration().set("Weather.Synchronised", sync);
@ -360,8 +367,10 @@ public class Island {
}
public void setWeather(WeatherType weatherType) {
Bukkit.getServer().getPluginManager()
.callEvent(new IslandWeatherChangeEvent(this, weatherType, getTime(), isWeatherSynchronized()));
IslandWeatherChangeEvent islandWeatherChangeEvent = new IslandWeatherChangeEvent(getAPIWrapper(), weatherType,
getTime(), isWeatherSynchronized());
Bukkit.getServer().getPluginManager().callEvent(islandWeatherChangeEvent);
skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"))
.getFileConfiguration().set("Weather.Weather", weatherType.name());
@ -374,8 +383,10 @@ public class Island {
}
public void setTime(int time) {
Bukkit.getServer().getPluginManager()
.callEvent(new IslandWeatherChangeEvent(this, getWeather(), time, isWeatherSynchronized()));
IslandWeatherChangeEvent islandWeatherChangeEvent = new IslandWeatherChangeEvent(getAPIWrapper(), getWeather(),
time, isWeatherSynchronized());
Bukkit.getServer().getPluginManager().callEvent(islandWeatherChangeEvent);
skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"))
.getFileConfiguration().set("Weather.Time", time);
@ -422,14 +433,14 @@ public class Island {
if (!hasRole(role, uuid)) {
if (role == IslandRole.Member) {
if (hasRole(IslandRole.Operator, uuid)) {
Bukkit.getServer().getPluginManager()
.callEvent(new IslandRoleChangeEvent(uuid, this, IslandRole.Operator, role));
Bukkit.getServer().getPluginManager().callEvent(new IslandRoleChangeEvent(getAPIWrapper(),
Bukkit.getServer().getOfflinePlayer(uuid), APIUtil.fromImplementation(role)));
removeRole(IslandRole.Operator, uuid);
}
} else if (role == IslandRole.Operator) {
if (hasRole(IslandRole.Member, uuid)) {
Bukkit.getServer().getPluginManager()
.callEvent(new IslandRoleChangeEvent(uuid, this, IslandRole.Member, role));
Bukkit.getServer().getPluginManager().callEvent(new IslandRoleChangeEvent(getAPIWrapper(),
Bukkit.getServer().getOfflinePlayer(uuid), APIUtil.fromImplementation(role)));
removeRole(IslandRole.Member, uuid);
}
}
@ -544,7 +555,7 @@ public class Island {
}
public void setOpen(boolean open) {
IslandOpenEvent islandOpenEvent = new IslandOpenEvent(this, open);
IslandOpenEvent islandOpenEvent = new IslandOpenEvent(getAPIWrapper(), open);
Bukkit.getServer().getPluginManager().callEvent(islandOpenEvent);
if (!islandOpenEvent.isCancelled()) {
@ -561,7 +572,7 @@ public class Island {
.getFileConfiguration().getBoolean("Visitor.Open");
}
public List<String> getMessage(Message message) {
public List<String> getMessage(IslandMessage message) {
List<String> islandMessage = new ArrayList<>();
Config config = skyblock.getFileManager().getConfig(
@ -575,7 +586,7 @@ public class Island {
return islandMessage;
}
public String getMessageAuthor(Message message) {
public String getMessageAuthor(IslandMessage message) {
Config config = skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"));
FileConfiguration configLoad = config.getFileConfiguration();
@ -587,20 +598,20 @@ public class Island {
return "";
}
public void setMessage(Message message, String author, List<String> islandMessage) {
IslandMessageChangeEvent islandMessageChangeEvent = new IslandMessageChangeEvent(this, message, islandMessage,
author);
public void setMessage(IslandMessage message, String author, List<String> lines) {
IslandMessageChangeEvent islandMessageChangeEvent = new IslandMessageChangeEvent(getAPIWrapper(),
APIUtil.fromImplementation(message), lines, author);
Bukkit.getServer().getPluginManager().callEvent(islandMessageChangeEvent);
if (!islandMessageChangeEvent.isCancelled()) {
Config config = skyblock.getFileManager().getConfig(
new File(new File(skyblock.getDataFolder().toString() + "/island-data"), uuid.toString() + ".yml"));
FileConfiguration configLoad = config.getFileConfiguration();
configLoad.set("Visitor." + message.name() + ".Message", islandMessage);
configLoad.set("Visitor." + message.name() + ".Author", author);
configLoad.set("Visitor." + message.name() + ".Message", islandMessageChangeEvent.getLines());
configLoad.set("Visitor." + message.name() + ".Author", islandMessageChangeEvent.getAuthor());
if (message == Message.Signature) {
getVisit().setSignature(islandMessage);
if (message == IslandMessage.Signature) {
getVisit().setSignature(lines);
}
}
}

36
src/main/java/me/goodandevil/skyblock/island/IslandManager.java
View File

@ -24,14 +24,14 @@ import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import me.goodandevil.skyblock.SkyBlock;
import me.goodandevil.skyblock.api.event.island.IslandCreateEvent;
import me.goodandevil.skyblock.api.event.island.IslandDeleteEvent;
import me.goodandevil.skyblock.api.event.island.IslandLoadEvent;
import me.goodandevil.skyblock.api.event.island.IslandOwnershipTransferEvent;
import me.goodandevil.skyblock.api.event.island.IslandUnloadEvent;
import me.goodandevil.skyblock.ban.BanManager;
import me.goodandevil.skyblock.config.FileManager;
import me.goodandevil.skyblock.config.FileManager.Config;
import me.goodandevil.skyblock.events.IslandCreateEvent;
import me.goodandevil.skyblock.events.IslandDeleteEvent;
import me.goodandevil.skyblock.events.IslandLoadEvent;
import me.goodandevil.skyblock.events.IslandOwnershipTransferEvent;
import me.goodandevil.skyblock.events.IslandUnloadEvent;
import me.goodandevil.skyblock.invite.Invite;
import me.goodandevil.skyblock.invite.InviteManager;
import me.goodandevil.skyblock.island.Location.World;
@ -208,7 +208,7 @@ public class IslandManager {
skyblock.getCreationManager().createPlayer(player, configLoad.getInt("Island.Creation.Cooldown.Time"));
}
Bukkit.getServer().getPluginManager().callEvent(new IslandCreateEvent(player, island));
Bukkit.getServer().getPluginManager().callEvent(new IslandCreateEvent(island.getAPIWrapper(), player));
for (Location.World worldList : Location.World.values()) {
setNextAvailableLocation(worldList, island.getLocation(worldList, Location.Environment.Island));
@ -352,8 +352,8 @@ public class IslandManager {
removeIsland(islandOwnerUUID);
islandStorage.put(uuid, island);
Bukkit.getServer().getPluginManager()
.callEvent(new IslandOwnershipTransferEvent(island, islandOwnerUUID, uuid));
Bukkit.getServer().getPluginManager().callEvent(new IslandOwnershipTransferEvent(island.getAPIWrapper(),
Bukkit.getServer().getOfflinePlayer(uuid)));
ArrayList<UUID> islandMembers = new ArrayList<>();
islandMembers.addAll(island.getRole(IslandRole.Member));
@ -425,7 +425,7 @@ public class IslandManager {
fileManager.deleteConfig(new File(new File(skyblock.getDataFolder().toString() + "/island-data"),
island.getOwnerUUID().toString() + ".yml"));
Bukkit.getServer().getPluginManager().callEvent(new IslandDeleteEvent(island));
Bukkit.getServer().getPluginManager().callEvent(new IslandDeleteEvent(island.getAPIWrapper()));
islandStorage.remove(island.getOwnerUUID());
}
@ -471,7 +471,7 @@ public class IslandManager {
islandNetherLocation.getBlockZ()));
islandStorage.put(islandOwnerUUID, island);
Bukkit.getServer().getPluginManager().callEvent(new IslandLoadEvent(island));
Bukkit.getServer().getPluginManager().callEvent(new IslandLoadEvent(island.getAPIWrapper()));
}
}
@ -564,7 +564,7 @@ public class IslandManager {
islandStorage.remove(island.getOwnerUUID());
Bukkit.getServer().getPluginManager().callEvent(new IslandUnloadEvent(island));
Bukkit.getServer().getPluginManager().callEvent(new IslandUnloadEvent(island.getAPIWrapper()));
}
public Set<UUID> getVisitorsAtIsland(Island island) {
@ -648,7 +648,7 @@ public class IslandManager {
}
});
List<String> islandWelcomeMessage = island.getMessage(Message.Welcome);
List<String> islandWelcomeMessage = island.getMessage(IslandMessage.Welcome);
if (skyblock.getFileManager().getConfig(new File(skyblock.getDataFolder(), "config.yml"))
.getFileConfiguration().getBoolean("Island.Visitor.Welcome.Enable")
@ -810,8 +810,8 @@ public class IslandManager {
location.clone().add(0.0D, 1.0D, 0.0D).getBlock().setType(Material.AIR);
}
public List<UUID> getMembersOnline(Island island) {
List<UUID> membersOnline = new ArrayList<>();
public Set<UUID> getMembersOnline(Island island) {
Set<UUID> membersOnline = new HashSet<>();
for (Player all : Bukkit.getOnlinePlayers()) {
if (island.hasRole(IslandRole.Member, all.getUniqueId())
@ -824,8 +824,8 @@ public class IslandManager {
return membersOnline;
}
public List<UUID> getPlayersAtIsland(Island island) {
List<UUID> playersAtIsland = new ArrayList<>();
public Set<UUID> getPlayersAtIsland(Island island) {
Set<UUID> playersAtIsland = new HashSet<>();
if (island != null) {
for (Player all : Bukkit.getOnlinePlayers()) {
@ -959,8 +959,8 @@ public class IslandManager {
}
}
public List<UUID> getCoopPlayersAtIsland(Island island) {
List<UUID> coopPlayersAtIsland = new ArrayList<>();
public Set<UUID> getCoopPlayersAtIsland(Island island) {
Set<UUID> coopPlayersAtIsland = new HashSet<>();
if (island != null) {
for (Player all : Bukkit.getOnlinePlayers()) {

2
src/main/java/me/goodandevil/skyblock/island/Message.java → src/main/java/me/goodandevil/skyblock/island/IslandMessage.java
View File

@ -1,6 +1,6 @@
package me.goodandevil.skyblock.island;
public enum Message {
public enum IslandMessage {
Welcome, Signature, Sign;

38
src/main/java/me/goodandevil/skyblock/island/Level.java
View File

@ -68,6 +68,27 @@ public class Level {
return pointsEarned;
}
public int getMaterialPoints(String material) {
Config config = skyblock.getFileManager().getConfig(new File(skyblock.getDataFolder(), "levelling.yml"));
FileConfiguration configLoad = config.getFileConfiguration();
int pointsEarned = 0;
if (materials.containsKey(material)) {
int materialAmount = materials.get(material);
if (configLoad.getString("Materials." + materials + ".Points") != null) {
int pointsRequired = config.getFileConfiguration().getInt("Materials." + materials + ".Points");
if (pointsRequired != 0) {
pointsEarned = materialAmount * pointsRequired;
}
}
}
return pointsEarned;
}
public int getLevel() {
int division = skyblock.getFileManager().getConfig(new File(skyblock.getDataFolder(), "config.yml"))
.getFileConfiguration().getInt("Island.Levelling.Division");
@ -79,6 +100,23 @@ public class Level {
return getPoints() / division;
}
public void setMaterialAmount(String material, int amount) {
Config config = skyblock.getFileManager().getConfig(new File(
new File(skyblock.getDataFolder().toString() + "/island-data"), ownerUUID.toString() + ".yml"));
File configFile = config.getFile();
FileConfiguration configLoad = config.getFileConfiguration();
configLoad.set("Levelling.Materials." + material + ".Amount", amount);
try {
configLoad.save(configFile);
} catch (IOException e) {
e.printStackTrace();
}
this.materials.put(material, amount);
}
public void setMaterials(Map<String, Integer> materials) {
Config config = skyblock.getFileManager().getConfig(new File(
new File(skyblock.getDataFolder().toString() + "/island-data"), ownerUUID.toString() + ".yml"));

15
src/main/java/me/goodandevil/skyblock/levelling/LevellingManager.java
View File

@ -19,6 +19,7 @@ import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
import me.goodandevil.skyblock.SkyBlock;
import me.goodandevil.skyblock.api.event.island.IslandLevelChangeEvent;
import me.goodandevil.skyblock.config.FileManager.Config;
import me.goodandevil.skyblock.island.Island;
import me.goodandevil.skyblock.island.IslandManager;
@ -170,17 +171,21 @@ public class LevellingManager {
}
if (materials.size() == 0) {
skyblock.getMessageManager()
.sendMessage(player, skyblock.getFileManager()
.getConfig(new File(skyblock.getDataFolder(), "language.yml"))
.getFileConfiguration().getString("Command.Island.Level.Materials.Message"));
skyblock.getSoundManager().playSound(player, Sounds.VILLAGER_NO.bukkitSound(), 1.0F, 1.0F);
if (player != null) {
skyblock.getMessageManager().sendMessage(player, skyblock.getFileManager()
.getConfig(new File(skyblock.getDataFolder(), "language.yml"))
.getFileConfiguration().getString("Command.Island.Level.Materials.Message"));
skyblock.getSoundManager().playSound(player, Sounds.VILLAGER_NO.bukkitSound(), 1.0F, 1.0F);
}
} else {
me.goodandevil.skyblock.island.Level level = island.getLevel();
level.setLastCalculatedPoints(level.getPoints());
level.setLastCalculatedLevel(level.getLevel());
level.setMaterials(materials);
Bukkit.getServer().getPluginManager().callEvent(
new IslandLevelChangeEvent(island.getAPIWrapper(), island.getAPIWrapper().getLevel()));
if (player != null) {
me.goodandevil.skyblock.menus.Levelling.getInstance().open(player);
}

4
src/main/java/me/goodandevil/skyblock/listeners/Quit.java
View File

@ -3,7 +3,7 @@ package me.goodandevil.skyblock.listeners;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.bukkit.Bukkit;
@ -51,7 +51,7 @@ public class Quit implements Listener {
if (islandManager.hasIsland(player)) {
Island island = islandManager.getIsland(playerData.getOwner());
List<UUID> islandMembersOnline = islandManager.getMembersOnline(island);
Set<UUID> islandMembersOnline = islandManager.getMembersOnline(island);
if (islandMembersOnline.size() == 1) {
LevellingManager levellingManager = skyblock.getLevellingManager();

34
src/main/java/me/goodandevil/skyblock/menus/Settings.java
View File

@ -19,7 +19,7 @@ import me.goodandevil.skyblock.config.FileManager;
import me.goodandevil.skyblock.config.FileManager.Config;
import me.goodandevil.skyblock.island.Island;
import me.goodandevil.skyblock.island.IslandManager;
import me.goodandevil.skyblock.island.Message;
import me.goodandevil.skyblock.island.IslandMessage;
import me.goodandevil.skyblock.island.IslandRole;
import me.goodandevil.skyblock.island.Setting;
import me.goodandevil.skyblock.message.MessageManager;
@ -847,7 +847,7 @@ public class Settings {
.getDisplayName()
.equals(ChatColor.translateAlternateColorCodes('&', configLoad.getString(
"Menu.Settings.Visitor.Panel.Welcome.Item.Line.Add.Displayname"))))) {
if (island.getMessage(Message.Welcome).size() >= skyblock.getFileManager()
if (island.getMessage(IslandMessage.Welcome).size() >= skyblock.getFileManager()
.getConfig(new File(skyblock.getDataFolder(), "config.yml"))
.getFileConfiguration().getInt("Island.Visitor.Welcome.Lines")) {
soundManager.playSound(player, Sounds.ANVIL_LAND.bukkitSound(), 1.0F, 1.0F);
@ -924,7 +924,7 @@ public class Settings {
FileConfiguration configLoad1 = config1
.getFileConfiguration();
if (island1.getMessage(Message.Welcome)
if (island1.getMessage(IslandMessage.Welcome)
.size() > configLoad1
.getInt("Island.Visitor.Welcome.Lines")
|| event1.getName().length() > configLoad1
@ -934,9 +934,9 @@ public class Settings {
1.0F);
} else {
List<String> welcomeMessage = island1
.getMessage(Message.Welcome);
.getMessage(IslandMessage.Welcome);
welcomeMessage.add(event1.getName());
island1.setMessage(Message.Welcome,
island1.setMessage(IslandMessage.Welcome,
player.getName(), welcomeMessage);
soundManager.playSound(player,
Sounds.NOTE_PLING.bukkitSound(), 1.0F,
@ -978,7 +978,7 @@ public class Settings {
.getDisplayName()
.equals(ChatColor.translateAlternateColorCodes('&', configLoad.getString(
"Menu.Settings.Visitor.Panel.Welcome.Item.Line.Remove.Displayname"))))) {
List<String> welcomeMessage = island.getMessage(Message.Welcome);
List<String> welcomeMessage = island.getMessage(IslandMessage.Welcome);
if (welcomeMessage.size() == 0) {
soundManager.playSound(player, Sounds.ANVIL_LAND.bukkitSound(), 1.0F, 1.0F);
@ -987,8 +987,8 @@ public class Settings {
event.setWillDestroy(false);
} else {
welcomeMessage.remove(welcomeMessage.size() - 1);
island.setMessage(Message.Welcome, island.getMessageAuthor(Message.Welcome),
welcomeMessage);
island.setMessage(IslandMessage.Welcome,
island.getMessageAuthor(IslandMessage.Welcome), welcomeMessage);
soundManager.playSound(player, Sounds.EXPLODE.bukkitSound(), 1.0F, 1.0F);
Bukkit.getServer().getScheduler().runTaskLaterAsynchronously(skyblock,
@ -1004,7 +1004,7 @@ public class Settings {
}
});
List<String> welcomeMessage = island.getMessage(Message.Welcome);
List<String> welcomeMessage = island.getMessage(IslandMessage.Welcome);
if (welcomeMessage.size() == mainConfig.getFileConfiguration()
.getInt("Island.Visitor.Welcome.Lines")) {
@ -1141,7 +1141,7 @@ public class Settings {
.getDisplayName()
.equals(ChatColor.translateAlternateColorCodes('&', configLoad.getString(
"Menu.Settings.Visitor.Panel.Signature.Item.Line.Add.Displayname"))))) {
if (island.getMessage(Message.Signature).size() >= skyblock.getFileManager()
if (island.getMessage(IslandMessage.Signature).size() >= skyblock.getFileManager()
.getConfig(new File(skyblock.getDataFolder(), "config.yml"))
.getFileConfiguration().getInt("Island.Visitor.Signature.Lines")) {
soundManager.playSound(player, Sounds.ANVIL_LAND.bukkitSound(), 1.0F, 1.0F);
@ -1218,7 +1218,7 @@ public class Settings {
FileConfiguration configLoad1 = config1
.getFileConfiguration();
if (island1.getMessage(Message.Signature)
if (island1.getMessage(IslandMessage.Signature)
.size() > configLoad1.getInt(
"Island.Visitor.Signature.Lines")
|| event1.getName().length() > configLoad1
@ -1228,9 +1228,9 @@ public class Settings {
1.0F);
} else {
List<String> signatureMessage = island1
.getMessage(Message.Signature);
.getMessage(IslandMessage.Signature);
signatureMessage.add(event1.getName());
island1.setMessage(Message.Signature,
island1.setMessage(IslandMessage.Signature,
player.getName(), signatureMessage);
soundManager.playSound(player,
Sounds.NOTE_PLING.bukkitSound(), 1.0F,
@ -1272,7 +1272,7 @@ public class Settings {
.getDisplayName()
.equals(ChatColor.translateAlternateColorCodes('&', configLoad.getString(
"Menu.Settings.Visitor.Panel.Signature.Item.Line.Remove.Displayname"))))) {
List<String> signatureMessage = island.getMessage(Message.Signature);
List<String> signatureMessage = island.getMessage(IslandMessage.Signature);
if (signatureMessage.size() == 0) {
soundManager.playSound(player, Sounds.ANVIL_LAND.bukkitSound(), 1.0F, 1.0F);
@ -1281,8 +1281,8 @@ public class Settings {
event.setWillDestroy(false);
} else {
signatureMessage.remove(signatureMessage.size() - 1);
island.setMessage(Message.Signature, island.getMessageAuthor(Message.Signature),
signatureMessage);
island.setMessage(IslandMessage.Signature,
island.getMessageAuthor(IslandMessage.Signature), signatureMessage);
soundManager.playSound(player, Sounds.EXPLODE.bukkitSound(), 1.0F, 1.0F);
Bukkit.getServer().getScheduler().runTaskLaterAsynchronously(skyblock,
@ -1299,7 +1299,7 @@ public class Settings {
}
});
List<String> signatureMessage = island.getMessage(Message.Signature);
List<String> signatureMessage = island.getMessage(IslandMessage.Signature);
if (signatureMessage.size() == mainConfig.getFileConfiguration()
.getInt("Island.Visitor.Signature.Lines")) {

2
src/main/java/me/goodandevil/skyblock/structure/Structure.java
View File

@ -5,7 +5,7 @@ import java.util.List;
import me.goodandevil.skyblock.utils.version.Materials;
public class Structure {
public class Structure implements me.goodandevil.skyblock.api.structure.Structure {
private Materials materials;