├── .github └── ISSUE_TEMPLATE │ ├── bug_report.md │ ├── custom.md │ └── feature_request.md ├── .gitignore ├── LICENSE ├── README.md ├── pom.xml └── src └── main ├── java └── me │ └── ryanhamshire │ └── GPFlags │ ├── CommandList.java │ ├── CustomizableMessage.java │ ├── Flag.java │ ├── FlagManager.java │ ├── FlagsDataStore.java │ ├── FlightManager.java │ ├── GPFlags.java │ ├── GPFlagsConfig.java │ ├── MessageSpecifier.java │ ├── Messages.java │ ├── SetFlagResult.java │ ├── TextMode.java │ ├── UpdateChecker.java │ ├── VaultHook.java │ ├── WorldSettings.java │ ├── WorldSettingsManager.java │ ├── commands │ ├── CommandAllFlags.java │ ├── CommandBulkSetFlag.java │ ├── CommandBulkUnsetFlag.java │ ├── CommandBuyAccessTrust.java │ ├── CommandBuyBuildTrust.java │ ├── CommandBuyContainerTrust.java │ ├── CommandBuySubclaim.java │ ├── CommandGPFlags.java │ ├── CommandListClaimFlags.java │ ├── CommandSetClaimFlag.java │ ├── CommandSetClaimFlagPlayer.java │ ├── CommandSetDefaultClaimFlag.java │ ├── CommandSetServerFlag.java │ ├── CommandSetWorldFlag.java │ ├── CommandUnsetClaimFlag.java │ ├── CommandUnsetClaimFlagPlayer.java │ ├── CommandUnsetDefaultClaimFlag.java │ ├── CommandUnsetServerFlag.java │ └── CommandUnsetWorldFlag.java │ ├── event │ ├── PlayerPostClaimBorderEvent.java │ └── PlayerPreClaimBorderEvent.java │ ├── flags │ ├── CommandListFlagDefinition.java │ ├── FlagDef_AllowBlockExplosions.java │ ├── FlagDef_AllowInfest.java │ ├── FlagDef_AllowPvP.java │ ├── FlagDef_AllowVillagerTrading.java │ ├── FlagDef_AllowWitherDamage.java │ ├── FlagDef_BuyAccessTrust.java │ ├── FlagDef_BuyBuildTrust.java │ ├── FlagDef_BuyContainerTrust.java │ ├── FlagDef_BuySubclaim.java │ ├── FlagDef_ChangeBiome.java │ ├── FlagDef_CommandBlackList.java │ ├── FlagDef_CommandWhiteList.java │ ├── FlagDef_EnterActionbar.java │ ├── FlagDef_EnterCommand.java │ ├── FlagDef_EnterCommand_Members.java │ ├── FlagDef_EnterCommand_Owner.java │ ├── FlagDef_EnterMessage.java │ ├── FlagDef_EnterPlayerCommand.java │ ├── FlagDef_ExitActionbar.java │ ├── FlagDef_ExitCommand.java │ ├── FlagDef_ExitCommand_Members.java │ ├── FlagDef_ExitCommand_Owner.java │ ├── FlagDef_ExitMessage.java │ ├── FlagDef_ExitPlayerCommand.java │ ├── FlagDef_HealthRegen.java │ ├── FlagDef_InfiniteArrows.java │ ├── FlagDef_KeepInventory.java │ ├── FlagDef_KeepLevel.java │ ├── FlagDef_KeepLoaded.java │ ├── FlagDef_NetherPortalConsoleCommand.java │ ├── FlagDef_NetherPortalPlayerCommand.java │ ├── FlagDef_NoAnvilDamage.java │ ├── FlagDef_NoBlockFade.java │ ├── FlagDef_NoBlockForm.java │ ├── FlagDef_NoBlockGravity.java │ ├── FlagDef_NoBlockSpread.java │ ├── FlagDef_NoChorusFruit.java │ ├── FlagDef_NoCombatLoot.java │ ├── FlagDef_NoCoralDeath.java │ ├── FlagDef_NoCropTrampling.java │ ├── FlagDef_NoDripstoneSpread.java │ ├── FlagDef_NoEliteMobSpawns.java │ ├── FlagDef_NoElytra.java │ ├── FlagDef_NoEnderPearl.java │ ├── FlagDef_NoEnter.java │ ├── FlagDef_NoEnterPlayer.java │ ├── FlagDef_NoExpiration.java │ ├── FlagDef_NoExplosionDamage.java │ ├── FlagDef_NoFallDamage.java │ ├── FlagDef_NoFireDamage.java │ ├── FlagDef_NoFireSpread.java │ ├── FlagDef_NoFlight.java │ ├── FlagDef_NoFluidFlow.java │ ├── FlagDef_NoGrowth.java │ ├── FlagDef_NoHunger.java │ ├── FlagDef_NoIceForm.java │ ├── FlagDef_NoItemDamage.java │ ├── FlagDef_NoItemDrop.java │ ├── FlagDef_NoItemPickup.java │ ├── FlagDef_NoLeafDecay.java │ ├── FlagDef_NoLootProtection.java │ ├── FlagDef_NoMapMaking.java │ ├── FlagDef_NoMcMMODeathPenalty.java │ ├── FlagDef_NoMcMMOSkills.java │ ├── FlagDef_NoMcMMOXP.java │ ├── FlagDef_NoMobDamage.java │ ├── FlagDef_NoMobSpawns.java │ ├── FlagDef_NoMobSpawnsType.java │ ├── FlagDef_NoMonsterSpawns.java │ ├── FlagDef_NoMonsters.java │ ├── FlagDef_NoOpenDoors.java │ ├── FlagDef_NoPetDamage.java │ ├── FlagDef_NoPlayerDamage.java │ ├── FlagDef_NoPlayerDamageByMonster.java │ ├── FlagDef_NoPotionEffects.java │ ├── FlagDef_NoSnowForm.java │ ├── FlagDef_NoStructureGrowth.java │ ├── FlagDef_NoVehicle.java │ ├── FlagDef_NoVineGrowth.java │ ├── FlagDef_NoWeatherChange.java │ ├── FlagDef_NotifyEnter.java │ ├── FlagDef_NotifyExit.java │ ├── FlagDef_OwnerFly.java │ ├── FlagDef_OwnerMemberFly.java │ ├── FlagDef_PermissionFly.java │ ├── FlagDef_PlayerGamemode.java │ ├── FlagDef_PlayerTime.java │ ├── FlagDef_PlayerWeather.java │ ├── FlagDef_ProtectNamedMobs.java │ ├── FlagDef_RaidMemberOnly.java │ ├── FlagDef_ReadLecterns.java │ ├── FlagDef_RespawnLocation.java │ ├── FlagDef_RestoreGrazedGrass.java │ ├── FlagDef_SpawnReasonWhitelist.java │ ├── FlagDef_SpleefArena.java │ ├── FlagDef_TrappedDestination.java │ ├── FlagDef_ViewContainers.java │ ├── FlagDefinition.java │ ├── PlayerMovementFlagDefinition.java │ └── TimedPlayerFlagDefinition.java │ ├── hooks │ ├── MythicMobsHook.java │ └── PlaceholderApiHook.java │ ├── listener │ ├── ClaimCreatedListener.java │ ├── ClaimModifiedListener.java │ ├── ClaimResizeListener.java │ ├── ClaimTransferListener.java │ ├── EntityMoveListener.java │ └── PlayerListener.java │ ├── metrics │ └── Metrics.java │ └── util │ ├── MessagingUtil.java │ └── Util.java └── resources └── plugin.yml /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: bug 6 | assignees: '' 7 | 8 | --- 9 | 10 | #### Describe the bug 11 | A clear and concise description of what the bug is. 12 | 13 | #### To reproduce 14 | Steps to reproduce the behavior: 15 | 1. Use the command ... 16 | 2. Go to ... 17 | 3. See the error that says ... 18 | 19 | #### Expected behavior 20 | A description of what you expected to happen if the plugin was working. 21 | 22 | #### Screenshots, videos, or logs 23 | If applicable, add screenshots, videos, or console logs to show the issue. You can add console logs at [binflop](https://bin.birdflop.com) and send the link here 24 | 25 | #### Configs and console errors 26 | If you think it might help, paste configs into [binflop](https://bin.birdflop.com) and send the links here 27 | - GriefPrevention config 28 | - GPFlags config 29 | 30 | #### Versions 31 | Show the output of /gpflags debug 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/custom.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Custom issue template 3 | about: Describe this issue template's purpose here. 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | 11 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: enhancement 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /GriefPreventionFlags.iml 2 | /.idea/ 3 | /target/ 4 | /dependency-reduced-pom.xml 5 | /.classpath 6 | /.project 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | See the readme on [Modrinth](https://modrinth.com/plugin/gpflags/). 2 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/CommandList.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | import org.bukkit.Bukkit; 4 | import org.bukkit.command.Command; 5 | import org.bukkit.plugin.Plugin; 6 | import org.bukkit.plugin.java.JavaPlugin; 7 | 8 | import java.util.ArrayList; 9 | import java.util.HashSet; 10 | import java.util.concurrent.ConcurrentHashMap; 11 | 12 | public class CommandList { 13 | 14 | private final ConcurrentHashMap seenCommands = new ConcurrentHashMap<>(); 15 | private final ArrayList commandsFromConfig = new ArrayList<>(); 16 | 17 | public CommandList(String commandNamesList) { 18 | String[] commandNames = commandNamesList.split(";"); 19 | for (int i = 0; i < commandNames.length; i++) { 20 | String commandName = commandNames[i].trim().toLowerCase(); 21 | if (commandName.startsWith("/")) commandName = commandName.substring(1); 22 | commandsFromConfig.add(commandName); 23 | } 24 | } 25 | 26 | public boolean Contains(String commandName) { 27 | commandName = commandName.toLowerCase().trim(); 28 | if (commandName.startsWith("/")) commandName = commandName.substring(1); 29 | 30 | Boolean result = this.seenCommands.get(commandName); 31 | if (result != null) return result; 32 | 33 | //otherwise build a list of all the aliases of this command across all installed plugins 34 | HashSet aliases = new HashSet(); 35 | aliases.add(commandName); 36 | aliases.add("minecraft:" + commandName); 37 | for (Plugin plugin : Bukkit.getServer().getPluginManager().getPlugins()) { 38 | JavaPlugin javaPlugin = (JavaPlugin) plugin; 39 | Command command = javaPlugin.getCommand(commandName); 40 | if (command != null) { 41 | aliases.add(command.getName().toLowerCase()); 42 | aliases.add(plugin.getName().toLowerCase() + ":" + command.getName().toLowerCase()); 43 | for (String alias : command.getAliases()) { 44 | aliases.add(alias.toLowerCase()); 45 | aliases.add(plugin.getName().toLowerCase() + ":" + alias.toLowerCase()); 46 | } 47 | } 48 | } 49 | 50 | //also consider vanilla commands 51 | Command command = Bukkit.getServer().getPluginCommand(commandName); 52 | if (command != null) { 53 | for (String alias : command.getAliases()) { 54 | aliases.add(alias.toLowerCase()); 55 | aliases.add("minecraft:" + alias.toLowerCase()); 56 | } 57 | } 58 | 59 | //if any of those aliases are in the explicit list from the config, then all the aliases are considered in the list 60 | result = false; 61 | for (String alias : aliases) { 62 | if (this.commandsFromConfig.contains(alias)) { 63 | result = true; 64 | break; 65 | } 66 | } 67 | 68 | //remember the result for later 69 | for (String alias : aliases) { 70 | this.seenCommands.put(alias, result); 71 | } 72 | 73 | return result; 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/CustomizableMessage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | public class CustomizableMessage { 4 | 5 | public Messages id; 6 | public String text; 7 | public String notes; 8 | 9 | public CustomizableMessage(Messages id, String text, String notes) { 10 | this.id = id; 11 | this.text = text; 12 | this.notes = notes; 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/Flag.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.OfflinePlayer; 6 | 7 | import java.util.UUID; 8 | 9 | /** 10 | * Main flag object 11 | */ 12 | public class Flag { 13 | 14 | FlagDefinition flagDefinition; 15 | public String parameters; 16 | private String[] parametersArray; 17 | private boolean set = true; 18 | 19 | Flag(FlagDefinition definition, String parameters) { 20 | this.flagDefinition = definition; 21 | this.parameters = parameters; 22 | this.parameters = this.parameters.replace('&', (char) 0x00A7); 23 | } 24 | 25 | /** 26 | * Get parameters for this flag 27 | * 28 | * @return Parameters for this flag 29 | */ 30 | public String[] getParametersArray() { 31 | if (this.parametersArray != null) return this.parametersArray; 32 | this.parametersArray = this.parameters.split(" "); 33 | return this.parametersArray; 34 | } 35 | 36 | public String getFriendlyParameters() { 37 | StringBuilder builder = new StringBuilder(); 38 | if (flagDefinition.getName().equals("NoEnterPlayer")) { 39 | for (String idOrName : getParametersArray()) { 40 | if (idOrName.length() > 30) { 41 | // if long, try parsing it as a uuid 42 | try { 43 | OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(UUID.fromString(idOrName)); 44 | if (offlinePlayer.getName() != null) { 45 | idOrName = offlinePlayer.getName(); 46 | } 47 | } catch (Exception ignored) { 48 | } 49 | } 50 | builder.append(idOrName).append(" "); 51 | } 52 | return builder.toString().trim(); 53 | } 54 | return parameters; 55 | } 56 | 57 | public String getParameters() { 58 | return parameters; 59 | } 60 | 61 | /** 62 | * Gets if this flag is currently active 63 | * 64 | * @return Activity of flag 65 | */ 66 | public boolean getSet() { 67 | return this.set; 68 | } 69 | 70 | /** 71 | * Sets if this flag is currently active 72 | * 73 | * @param value if the flag is active 74 | */ 75 | public void setSet(boolean value) { 76 | this.set = value; 77 | } 78 | 79 | /** 80 | * Get the flag definition of this flag 81 | * 82 | * @return Flag definition of this flag 83 | */ 84 | public FlagDefinition getFlagDefinition() { 85 | return flagDefinition; 86 | } 87 | 88 | } 89 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/MessageSpecifier.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | public class MessageSpecifier { 4 | 5 | Messages messageID; 6 | String[] messageParams; 7 | 8 | public MessageSpecifier(Messages messageID, String... messageParams) { 9 | this.messageID = messageID; 10 | this.messageParams = messageParams; 11 | } 12 | 13 | public Messages getMessageID() { 14 | return messageID; 15 | } 16 | 17 | public String[] getMessageParams() { 18 | return messageParams; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/SetFlagResult.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | public class SetFlagResult { 4 | 5 | boolean success; 6 | MessageSpecifier message; 7 | 8 | public SetFlagResult(boolean success, MessageSpecifier message) { 9 | this.success = success; 10 | this.message = message; 11 | } 12 | 13 | SetFlagResult(boolean success, Messages messageID, String... args) { 14 | this.success = success; 15 | this.message = new MessageSpecifier(messageID, args); 16 | } 17 | 18 | public boolean isSuccess() { 19 | return success; 20 | } 21 | 22 | public MessageSpecifier getMessage() { 23 | return message; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/TextMode.java: -------------------------------------------------------------------------------- 1 | /* 2 | GriefPrevention Server Plugin for Minecraft 3 | Copyright (C) 2012 Ryan Hamshire 4 | 5 | This program is free software: you can redistribute it and/or modify 6 | it under the terms of the GNU General Public License as published by 7 | the Free Software Foundation, either version 3 of the License, or 8 | (at your option) any later version. 9 | 10 | This program is distributed in the hope that it will be useful, 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | GNU General Public License for more details. 14 | 15 | You should have received a copy of the GNU General Public License 16 | along with this program. If not, see . 17 | */ 18 | 19 | package me.ryanhamshire.GPFlags; 20 | 21 | ; 22 | 23 | /** 24 | * Text color modifiers 25 | */ 26 | //just a few constants for chat color codes 27 | public class TextMode { 28 | 29 | public final static String Info = ""; 30 | public final static String Instr = ""; 31 | public final static String Warn = ""; 32 | public final static String Err = ""; 33 | public final static String Success = ""; 34 | 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/VaultHook.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | import net.milkbowl.vault.economy.Economy; 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.plugin.RegisteredServiceProvider; 7 | 8 | import java.util.UUID; 9 | 10 | public class VaultHook { 11 | 12 | public static void giveMoney(UUID uuid, double amount) { 13 | Economy econ = getEconomy(); 14 | if (econ == null) return; 15 | econ.depositPlayer(Bukkit.getOfflinePlayer(uuid), amount); 16 | } 17 | 18 | public static boolean takeMoney(Player player, double amount) { 19 | Economy econ = getEconomy(); 20 | if (econ == null) return false; 21 | if (econ.getBalance(player) < amount) return false; 22 | econ.withdrawPlayer(player, amount); 23 | return true; 24 | } 25 | 26 | public static Economy getEconomy() { 27 | RegisteredServiceProvider rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class); 28 | if (rsp == null) return null; 29 | return rsp.getProvider(); 30 | } 31 | } -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/WorldSettings.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | public class WorldSettings { 4 | 5 | public boolean pvpRequiresClaimFlag = false; 6 | public String pvpDeniedMessage = null; 7 | public boolean pvpEnterClaimMessageEnabled = false; 8 | public String pvpEnterClaimMessage = null; 9 | public boolean pvpExitClaimMessageEnabled = false; 10 | public String pvpExitClaimMessage = null; 11 | public String worldGamemodeDefault = null; 12 | public boolean noMonsterSpawnIgnoreSpawners = false; 13 | public boolean noMobSpawnIgnoreSpawners = false; 14 | public boolean clearFlagsOnTransferClaim = false; 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/WorldSettingsManager.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags; 2 | 3 | import org.bukkit.World; 4 | 5 | import java.util.concurrent.ConcurrentHashMap; 6 | 7 | /** 8 | * Manager for world settings 9 | */ 10 | public class WorldSettingsManager { 11 | 12 | private ConcurrentHashMap nameToSettingsMap = new ConcurrentHashMap(); 13 | private final String OtherWorldsKey = "Other Worlds"; 14 | 15 | WorldSettingsManager() { 16 | this.nameToSettingsMap.put(this.OtherWorldsKey, new WorldSettings()); 17 | } 18 | 19 | void set(World world, WorldSettings settings) { 20 | this.set(world.getName(), settings); 21 | } 22 | 23 | public void set(String key, WorldSettings settings) { 24 | this.nameToSettingsMap.put(key, settings); 25 | } 26 | 27 | public WorldSettings get(World world) { 28 | return this.get(world.getName()); 29 | } 30 | 31 | WorldSettings get(String key) { 32 | WorldSettings settings = this.nameToSettingsMap.get(key); 33 | if (settings != null) return settings; 34 | return this.nameToSettingsMap.get(this.OtherWorldsKey); 35 | } 36 | 37 | public WorldSettings create(String worldName) { 38 | WorldSettings settings = new WorldSettings(); 39 | this.nameToSettingsMap.remove(worldName); 40 | this.nameToSettingsMap.put(worldName, settings); 41 | return settings; 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/commands/CommandAllFlags.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.commands; 2 | 3 | import me.ryanhamshire.GPFlags.GPFlags; 4 | import me.ryanhamshire.GPFlags.Messages; 5 | import me.ryanhamshire.GPFlags.TextMode; 6 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 7 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 8 | import org.bukkit.command.Command; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.command.TabExecutor; 11 | import org.jetbrains.annotations.NotNull; 12 | import org.jetbrains.annotations.Nullable; 13 | 14 | import java.util.List; 15 | 16 | public class CommandAllFlags implements TabExecutor { 17 | @Override 18 | public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) { 19 | if (!commandSender.hasPermission("gpflags.command.allflags")) { 20 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoCommandPermission, command.toString()); 21 | return true; 22 | } 23 | for (FlagDefinition flag : GPFlags.getInstance().getFlagManager().getFlagDefinitions()) { 24 | if (commandSender.hasPermission("gpflags.flag." + flag.getName())) { 25 | MessagingUtil.sendMessage(commandSender, flag.getName() + " " + flag.getFlagType()); 26 | } 27 | } 28 | return true; 29 | } 30 | 31 | @Override 32 | public @Nullable List onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) { 33 | return null; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/commands/CommandSetDefaultClaimFlag.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.commands; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 5 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 6 | import me.ryanhamshire.GPFlags.util.Util; 7 | import org.bukkit.command.Command; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.command.TabExecutor; 10 | import org.jetbrains.annotations.NotNull; 11 | import org.jetbrains.annotations.Nullable; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | public class CommandSetDefaultClaimFlag implements TabExecutor { 17 | @Override 18 | public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 19 | if (!commandSender.hasPermission("gpflags.command.setdefaultclaimflag")) { 20 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoCommandPermission, command.toString()); 21 | return true; 22 | } 23 | if (args.length < 1) return false; 24 | 25 | String flagName = args[0]; 26 | 27 | GPFlags gpFlags = GPFlags.getInstance(); 28 | FlagDefinition def = gpFlags.getFlagManager().getFlagDefinitionByName(flagName); 29 | if (def == null) { 30 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.InvalidFlagDefName, Util.getAvailableFlags(commandSender)); 31 | return true; 32 | } 33 | 34 | if (!commandSender.hasPermission("gpflags.flag." + def.getName())) { 35 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoFlagPermission, def.getName()); 36 | return true; 37 | } 38 | 39 | if (!def.getFlagType().contains(FlagDefinition.FlagType.DEFAULT)) { 40 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoFlagInDefault); 41 | return true; 42 | } 43 | 44 | String[] params = new String[args.length - 1]; 45 | System.arraycopy(args, 1, params, 0, args.length - 1); 46 | 47 | SetFlagResult result = gpFlags.getFlagManager().setFlag(FlagManager.DEFAULT_FLAG_ID, def, true, commandSender, params); 48 | String color = result.isSuccess() ? TextMode.Success : TextMode.Err; 49 | if (result.isSuccess()) { 50 | MessagingUtil.sendMessage(commandSender, color, Messages.DefaultFlagSet); 51 | gpFlags.getFlagManager().save(); 52 | } else { 53 | MessagingUtil.sendMessage(commandSender, color, result.getMessage().getMessageID(), result.getMessage().getMessageParams()); 54 | } 55 | 56 | return true; 57 | } 58 | 59 | @Override 60 | public @Nullable List onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 61 | if (args.length == 1) { 62 | return Util.flagTab(commandSender, args[0]); 63 | } else if (args.length == 2) { 64 | return Util.paramTab(commandSender, args); 65 | } 66 | return Collections.emptyList(); 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/commands/CommandSetServerFlag.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.commands; 2 | 3 | import me.ryanhamshire.GPFlags.GPFlags; 4 | import me.ryanhamshire.GPFlags.Messages; 5 | import me.ryanhamshire.GPFlags.SetFlagResult; 6 | import me.ryanhamshire.GPFlags.TextMode; 7 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 8 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 9 | import me.ryanhamshire.GPFlags.util.Util; 10 | import org.bukkit.command.Command; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.command.TabExecutor; 13 | import org.jetbrains.annotations.NotNull; 14 | import org.jetbrains.annotations.Nullable; 15 | 16 | import java.util.Collections; 17 | import java.util.List; 18 | 19 | public class CommandSetServerFlag implements TabExecutor { 20 | @Override 21 | public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 22 | if (!commandSender.hasPermission("gpflags.command.setserverflag")) { 23 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoCommandPermission, command.toString()); 24 | return true; 25 | } 26 | if (args.length < 1) return false; 27 | 28 | GPFlags plugin = GPFlags.getInstance(); 29 | String flagName = args[0]; 30 | FlagDefinition def = plugin.getFlagManager().getFlagDefinitionByName(flagName); 31 | if (def == null) { 32 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.InvalidFlagDefName, Util.getAvailableFlags(commandSender)); 33 | return true; 34 | } 35 | 36 | if (!commandSender.hasPermission("gpflags.flag." + def.getName())) { 37 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoFlagPermission, def.getName()); 38 | return true; 39 | } 40 | 41 | if (!def.getFlagType().contains(FlagDefinition.FlagType.SERVER)) { 42 | MessagingUtil.sendMessage(commandSender, TextMode.Err, Messages.NoFlagInServer); 43 | return true; 44 | } 45 | 46 | String[] params = new String[args.length - 1]; 47 | System.arraycopy(args, 1, params, 0, args.length - 1); 48 | 49 | SetFlagResult result = plugin.getFlagManager().setFlag("everywhere", def, true, commandSender, params); 50 | String color = result.isSuccess() ? TextMode.Success : TextMode.Err; 51 | if (result.isSuccess()) { 52 | MessagingUtil.sendMessage(commandSender, color, Messages.ServerFlagSet); 53 | plugin.getFlagManager().save(); 54 | } else { 55 | MessagingUtil.sendMessage(commandSender, color, result.getMessage().getMessageID(), result.getMessage().getMessageParams()); 56 | } 57 | 58 | return true; 59 | } 60 | 61 | @Override 62 | public @Nullable List onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 63 | if (args.length == 1) { 64 | return Util.flagTab(commandSender, args[0]); 65 | } else if (args.length == 2) { 66 | return Util.paramTab(commandSender, args); 67 | } 68 | return Collections.emptyList(); 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/commands/CommandUnsetDefaultClaimFlag.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.commands; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 5 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 6 | import me.ryanhamshire.GPFlags.util.Util; 7 | import org.bukkit.command.Command; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.command.TabExecutor; 10 | import org.jetbrains.annotations.NotNull; 11 | import org.jetbrains.annotations.Nullable; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | public class CommandUnsetDefaultClaimFlag implements TabExecutor { 17 | @Override 18 | public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 19 | if (!sender.hasPermission("gpflags.command.unsetdefaultclaimflag")) { 20 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.NoCommandPermission, command.toString()); 21 | return true; 22 | } 23 | if (args.length < 1) return false; 24 | 25 | String flagName = args[0]; 26 | GPFlags gpflags = GPFlags.getInstance(); 27 | FlagDefinition def = gpflags.getFlagManager().getFlagDefinitionByName(flagName); 28 | if (def == null) { 29 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.InvalidFlagDefName, Util.getAvailableFlags(sender)); 30 | return true; 31 | } 32 | 33 | if (!sender.hasPermission("gpflags.flag." + def.getName())) { 34 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.NoFlagPermission, def.getName()); 35 | return true; 36 | } 37 | 38 | SetFlagResult result = gpflags.getFlagManager().unSetFlag(FlagManager.DEFAULT_FLAG_ID, def); 39 | String color = result.isSuccess() ? TextMode.Success : TextMode.Err; 40 | if (result.isSuccess()) { 41 | MessagingUtil.sendMessage(sender, color, Messages.DefaultFlagUnSet); 42 | gpflags.getFlagManager().save(); 43 | } else { 44 | MessagingUtil.sendMessage(sender, color, result.getMessage().getMessageID(), result.getMessage().getMessageParams()); 45 | } 46 | 47 | return true; 48 | } 49 | 50 | @Override 51 | public @Nullable List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 52 | if (args.length == 1) { 53 | return Util.flagTab(sender, args[0]); 54 | } 55 | return Collections.emptyList(); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/commands/CommandUnsetServerFlag.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.commands; 2 | 3 | import me.ryanhamshire.GPFlags.GPFlags; 4 | import me.ryanhamshire.GPFlags.Messages; 5 | import me.ryanhamshire.GPFlags.SetFlagResult; 6 | import me.ryanhamshire.GPFlags.TextMode; 7 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 8 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 9 | import me.ryanhamshire.GPFlags.util.Util; 10 | import org.bukkit.command.Command; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.command.TabExecutor; 13 | import org.jetbrains.annotations.NotNull; 14 | import org.jetbrains.annotations.Nullable; 15 | 16 | import java.util.Collections; 17 | import java.util.List; 18 | 19 | public class CommandUnsetServerFlag implements TabExecutor { 20 | @Override 21 | public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 22 | if (!sender.hasPermission("gpflags.command.unsetserverflag")) { 23 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.NoCommandPermission, command.toString()); 24 | return true; 25 | } 26 | if (args.length < 1) return false; 27 | 28 | String flagName = args[0]; 29 | GPFlags plugin = GPFlags.getInstance(); 30 | FlagDefinition def = plugin.getFlagManager().getFlagDefinitionByName(flagName); 31 | if (def == null) { 32 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.InvalidFlagDefName, Util.getAvailableFlags(sender)); 33 | return true; 34 | } 35 | 36 | if (!sender.hasPermission("gpflags.flag." + def.getName())) { 37 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.NoFlagPermission, def.getName()); 38 | return true; 39 | } 40 | 41 | SetFlagResult result = plugin.getFlagManager().unSetFlag("everywhere", def); 42 | String color = result.isSuccess() ? TextMode.Success : TextMode.Err; 43 | if (result.isSuccess()) { 44 | MessagingUtil.sendMessage(sender, color, Messages.ServerFlagUnSet); 45 | plugin.getFlagManager().save(); 46 | } else { 47 | MessagingUtil.sendMessage(sender, color, result.getMessage().getMessageID(), result.getMessage().getMessageParams()); 48 | } 49 | return true; 50 | } 51 | 52 | @Override 53 | public @Nullable List onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 54 | if (args.length == 1) { 55 | return Util.flagTab(commandSender, args[0]); 56 | } 57 | return Collections.emptyList(); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/commands/CommandUnsetWorldFlag.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.commands; 2 | 3 | import me.ryanhamshire.GPFlags.GPFlags; 4 | import me.ryanhamshire.GPFlags.Messages; 5 | import me.ryanhamshire.GPFlags.SetFlagResult; 6 | import me.ryanhamshire.GPFlags.TextMode; 7 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 8 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 9 | import me.ryanhamshire.GPFlags.util.Util; 10 | import org.bukkit.command.Command; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.command.TabExecutor; 13 | import org.bukkit.entity.Player; 14 | import org.jetbrains.annotations.NotNull; 15 | import org.jetbrains.annotations.Nullable; 16 | 17 | import java.util.Collections; 18 | import java.util.List; 19 | 20 | public class CommandUnsetWorldFlag implements TabExecutor { 21 | @Override 22 | public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 23 | if (!sender.hasPermission("gpflags.command.unsetworldflag")) { 24 | MessagingUtil.sendMessage(sender, TextMode.Err, Messages.NoCommandPermission, command.toString()); 25 | return true; 26 | } 27 | if (args.length < 1) return false; 28 | 29 | Player player = ((Player) sender); 30 | String flagName = args[0]; 31 | GPFlags plugin = GPFlags.getInstance(); 32 | FlagDefinition def = plugin.getFlagManager().getFlagDefinitionByName(flagName); 33 | if (def == null) { 34 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.InvalidFlagDefName, Util.getAvailableFlags(player)); 35 | return true; 36 | } 37 | 38 | if (!sender.hasPermission("gpflags.flag." + def.getName())) { 39 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.NoFlagPermission, def.getName()); 40 | return true; 41 | } 42 | 43 | SetFlagResult result = plugin.getFlagManager().unSetFlag(player.getWorld().getName(), def); 44 | String color = result.isSuccess() ? TextMode.Success : TextMode.Err; 45 | if (result.isSuccess()) { 46 | MessagingUtil.sendMessage(player, color, Messages.WorldFlagUnSet); 47 | plugin.getFlagManager().save(); 48 | } else { 49 | MessagingUtil.sendMessage(player, color, result.getMessage().getMessageID(), result.getMessage().getMessageParams()); 50 | } 51 | 52 | return true; 53 | } 54 | 55 | @Override 56 | public @Nullable List onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) { 57 | if (args.length == 1) { 58 | return Util.flagTab(commandSender, args[0]); 59 | } 60 | return Collections.emptyList(); 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/event/PlayerPostClaimBorderEvent.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.event; 2 | 3 | import me.ryanhamshire.GriefPrevention.Claim; 4 | import org.bukkit.Location; 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.HandlerList; 7 | import org.bukkit.event.player.PlayerEvent; 8 | import org.jetbrains.annotations.Nullable; 9 | 10 | /** 11 | * Called when a player enters/exits a claim 12 | * Calls onChangeClaim on every movement flag 13 | */ 14 | public class PlayerPostClaimBorderEvent extends PlayerEvent { 15 | 16 | private static HandlerList handlerList = new HandlerList(); 17 | private Claim claimFrom, claimTo; 18 | private Location locFrom, locTo; 19 | 20 | public PlayerPostClaimBorderEvent(Player who, Claim claimFrom, Claim claimTo, Location from, Location to) { 21 | super(who); 22 | this.claimFrom = claimFrom; 23 | this.claimTo = claimTo; 24 | this.locFrom = from; 25 | this.locTo = to; 26 | } 27 | 28 | public PlayerPostClaimBorderEvent(PlayerPreClaimBorderEvent playerPreClaimBorderEvent) { 29 | super(playerPreClaimBorderEvent.getPlayer()); 30 | this.claimFrom = playerPreClaimBorderEvent.getClaimFrom(); 31 | this.claimTo = playerPreClaimBorderEvent.getClaimTo(); 32 | this.locFrom = playerPreClaimBorderEvent.getLocFrom(); 33 | this.locTo = playerPreClaimBorderEvent.getLocTo(); 34 | } 35 | 36 | /** 37 | * Get the claim the player exited 38 | * 39 | * @return Claim the player exited 40 | */ 41 | public @Nullable Claim getClaimFrom() { 42 | return claimFrom; 43 | } 44 | 45 | /** 46 | * Get the claim the player entered 47 | * 48 | * @return Claim the player entered 49 | */ 50 | public @Nullable Claim getClaimTo() { 51 | return claimTo; 52 | } 53 | 54 | /** 55 | * Get the location the player moved from 56 | * 57 | * @return Location the player moved from 58 | */ 59 | public Location getLocFrom() { 60 | return locFrom; 61 | } 62 | 63 | /** 64 | * Get the location the player moved to 65 | * 66 | * @return Location the player moved to 67 | */ 68 | public Location getLocTo() { 69 | return locTo; 70 | } 71 | 72 | @Override 73 | public HandlerList getHandlers() { 74 | return handlerList; 75 | } 76 | 77 | public static HandlerList getHandlerList() { 78 | return handlerList; 79 | } 80 | 81 | } 82 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/event/PlayerPreClaimBorderEvent.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.event; 2 | 3 | import me.ryanhamshire.GriefPrevention.Claim; 4 | import org.bukkit.Location; 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.Cancellable; 7 | import org.bukkit.event.HandlerList; 8 | import org.bukkit.event.player.PlayerEvent; 9 | 10 | /** 11 | * Called when a player tries to change regions. 12 | * It's expected that the same code that calls this event will also handle what happens when this gets cancelled 13 | */ 14 | @SuppressWarnings("unused") 15 | public class PlayerPreClaimBorderEvent extends PlayerEvent implements Cancellable { 16 | 17 | private static HandlerList handlerList = new HandlerList(); 18 | private Claim claimFrom, claimTo; 19 | private Location locFrom, locTo; 20 | private boolean cancelled = false; 21 | 22 | public PlayerPreClaimBorderEvent(Player who, Claim claimFrom, Claim claimTo, Location from, Location to) { 23 | super(who); 24 | this.claimFrom = claimFrom; 25 | this.claimTo = claimTo; 26 | this.locFrom = from; 27 | this.locTo = to; 28 | } 29 | 30 | /** 31 | * Get the claim the player exited 32 | * Null if there is no claim at the location 33 | * @return Claim the player exited (can be null) 34 | */ 35 | public Claim getClaimFrom() { 36 | return claimFrom; 37 | } 38 | 39 | /** 40 | * Get the claim the player entered 41 | * Null if there is no claim at the location 42 | * @return Claim the player entered 43 | */ 44 | public Claim getClaimTo() { 45 | return claimTo; 46 | } 47 | 48 | /** 49 | * Get the location the player moved from 50 | * This is adjusted to be within world height 51 | * @return Location the player moved from 52 | */ 53 | public Location getLocFrom() { 54 | return locFrom; 55 | } 56 | 57 | /** 58 | * Get the location the player moved to 59 | * This is adjusted to be within world height 60 | * @return Location the player moved to 61 | */ 62 | public Location getLocTo() { 63 | return locTo; 64 | } 65 | 66 | @Override 67 | public boolean isCancelled() { 68 | return this.cancelled; 69 | } 70 | 71 | @Override 72 | public void setCancelled(boolean cancelled) { 73 | this.cancelled = cancelled; 74 | } 75 | 76 | @Override 77 | public HandlerList getHandlers() { 78 | return handlerList; 79 | } 80 | 81 | public static HandlerList getHandlerList() { 82 | return handlerList; 83 | } 84 | 85 | } 86 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/CommandListFlagDefinition.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.CommandList; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import org.bukkit.command.CommandSender; 10 | 11 | import java.util.concurrent.ConcurrentHashMap; 12 | 13 | public abstract class CommandListFlagDefinition extends FlagDefinition { 14 | public CommandListFlagDefinition(FlagManager manager, GPFlags plugin) { 15 | super(manager, plugin); 16 | } 17 | 18 | private static final ConcurrentHashMap commandListMap = new ConcurrentHashMap<>(); 19 | 20 | protected boolean commandInList(String flagParameters, String commandLine) { 21 | CommandList list = commandListMap.get(flagParameters); 22 | if (list == null) { 23 | list = new CommandList(flagParameters); 24 | commandListMap.put(flagParameters, list); 25 | } 26 | 27 | String command = commandLine.split(" ")[0]; 28 | return list.Contains(command); 29 | } 30 | 31 | @Override 32 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 33 | if (parameters.isEmpty()) { 34 | return new SetFlagResult(false, new MessageSpecifier(Messages.CommandListRequired)); 35 | } 36 | 37 | return new SetFlagResult(true, this.getSetMessage(parameters)); 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_AllowBlockExplosions.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GriefPrevention.Claim; 5 | 6 | import java.util.Arrays; 7 | import java.util.List; 8 | 9 | public class FlagDef_AllowBlockExplosions extends FlagDefinition { 10 | 11 | public FlagDef_AllowBlockExplosions(FlagManager manager, GPFlags plugin) { 12 | super(manager, plugin); 13 | } 14 | 15 | public void onFlagSet(Claim claim, String string) { 16 | claim.areExplosivesAllowed = true; 17 | } 18 | 19 | public void onFlagUnset(Claim claim) { 20 | claim.areExplosivesAllowed = false; 21 | } 22 | 23 | @Override 24 | public String getName() { 25 | return "AllowBlockExplosions"; 26 | } 27 | 28 | @Override 29 | public MessageSpecifier getSetMessage(String parameters) { 30 | return new MessageSpecifier(Messages.EnabledAllowBlockExplosions); 31 | } 32 | 33 | @Override 34 | public MessageSpecifier getUnSetMessage() { 35 | return new MessageSpecifier(Messages.DisabledAllowBlockExplosions); 36 | } 37 | 38 | @Override 39 | public List getFlagType() { 40 | return Arrays.asList(FlagType.CLAIM); 41 | } 42 | 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_AllowInfest.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.entity.EntityType; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.entity.EntityChangeBlockEvent; 7 | 8 | public class FlagDef_AllowInfest extends FlagDefinition { 9 | 10 | public FlagDef_AllowInfest(FlagManager manager, GPFlags plugin) { 11 | super(manager, plugin); 12 | } 13 | 14 | @Override 15 | public String getName() { 16 | return "AllowInfest"; 17 | } 18 | 19 | @Override 20 | public MessageSpecifier getSetMessage(String parameters) { 21 | return new MessageSpecifier(Messages.EnabledAllowInfest); 22 | } 23 | 24 | @EventHandler 25 | public void onInfest(EntityChangeBlockEvent event) { 26 | Flag flag = this.getFlagInstanceAtLocation(event.getBlock().getLocation(), null); 27 | if (flag == null) return; 28 | if (event.getEntity().getType() == EntityType.SILVERFISH) { 29 | event.setCancelled(false); 30 | } 31 | } 32 | 33 | @Override 34 | public MessageSpecifier getUnSetMessage() { 35 | return new MessageSpecifier(Messages.DisabledAllowInfest); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_AllowVillagerTrading.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GriefPrevention.events.ClaimPermissionCheckEvent; 9 | import org.bukkit.entity.Villager; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.player.PlayerInteractEntityEvent; 12 | 13 | public class FlagDef_AllowVillagerTrading extends FlagDefinition { 14 | 15 | public FlagDef_AllowVillagerTrading(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @Override 20 | public String getName() { 21 | return "AllowVillagerTrading"; 22 | } 23 | 24 | @Override 25 | public MessageSpecifier getSetMessage(String parameters) { 26 | return new MessageSpecifier(Messages.EnabledAllowVillagerTrading); 27 | } 28 | 29 | @Override 30 | public MessageSpecifier getUnSetMessage() { 31 | return new MessageSpecifier(Messages.DisabledAllowVillagerTrading); 32 | } 33 | 34 | @EventHandler 35 | public void onGPVillagerTrade(ClaimPermissionCheckEvent event) { 36 | 37 | if(event.getCheckedPlayer() == null) return; 38 | 39 | // only looking for PlayerInteractEntityEvent (the event that GP cancels for trading with villagers) 40 | if(!(event.getTriggeringEvent() instanceof PlayerInteractEntityEvent)) return; 41 | final PlayerInteractEntityEvent clickMobEvent = (PlayerInteractEntityEvent) event.getTriggeringEvent(); 42 | 43 | // only check if the player right-clicked a villager 44 | if(!(clickMobEvent.getRightClicked() instanceof Villager)) return; 45 | final Villager villager = (Villager) clickMobEvent.getRightClicked(); 46 | 47 | // check if the current flag (AllowVillagerTrading) is set at the villager's location 48 | final Flag flag = this.getFlagInstanceAtLocation(villager.getLocation(), clickMobEvent.getPlayer()); 49 | if(flag == null) return; 50 | 51 | // allow the player to trade (in GP, a null denial reason basically tells GP the player has permission) 52 | event.setDenialReason(null); 53 | } 54 | } -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_AllowWitherDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.damage.DamageSource; 6 | import org.bukkit.entity.Entity; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.entity.Wither; 9 | import org.bukkit.entity.WitherSkull; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.entity.EntityDamageByEntityEvent; 13 | import org.bukkit.event.entity.EntityDamageEvent; 14 | 15 | import java.util.Arrays; 16 | import java.util.List; 17 | import java.util.logging.Level; 18 | 19 | public class FlagDef_AllowWitherDamage extends FlagDefinition { 20 | 21 | public FlagDef_AllowWitherDamage(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler(priority = EventPriority.HIGH) 26 | public void onEntityDamage(EntityDamageByEntityEvent event) { 27 | if (!isFromWither(event)) return; 28 | Entity attacked = event.getEntity(); 29 | if (attacked.getType() == EntityType.PLAYER) return; 30 | 31 | Flag flag = this.getFlagInstanceAtLocation(attacked.getLocation(), null); 32 | if (flag == null) return; 33 | 34 | event.setCancelled(false); 35 | } 36 | 37 | public boolean isFromWither(EntityDamageByEntityEvent event) { 38 | if (event.getDamager() instanceof WitherSkull) return true; 39 | if (event.getDamager() instanceof Wither) return true; 40 | if (event.getCause() == EntityDamageEvent.DamageCause.WITHER) return true; 41 | return false; 42 | } 43 | 44 | @Override 45 | public String getName() { 46 | return "AllowWitherDamage"; 47 | } 48 | 49 | @Override 50 | public MessageSpecifier getSetMessage(String parameters) { 51 | return new MessageSpecifier(Messages.EnabledAllowWitherDamage); 52 | } 53 | 54 | @Override 55 | public MessageSpecifier getUnSetMessage() { 56 | return new MessageSpecifier(Messages.DisabledAllowWitherDamage); 57 | } 58 | 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_BuyAccessTrust.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.ClaimPermission; 7 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.player.PlayerJoinEvent; 13 | import org.jetbrains.annotations.Nullable; 14 | 15 | import java.util.Collections; 16 | import java.util.List; 17 | 18 | public class FlagDef_BuyAccessTrust extends PlayerMovementFlagDefinition { 19 | 20 | public FlagDef_BuyAccessTrust(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @Override 25 | public String getName() { 26 | return "BuyAccessTrust"; 27 | } 28 | 29 | @Override 30 | public MessageSpecifier getSetMessage(String parameters) { 31 | return new MessageSpecifier(Messages.EnableBuyAccessTrust, parameters); 32 | } 33 | 34 | @Override 35 | public MessageSpecifier getUnSetMessage() { 36 | return new MessageSpecifier(Messages.DisableBuyAccessTrust); 37 | } 38 | 39 | @Override 40 | public List getFlagType() { 41 | return Collections.singletonList(FlagType.CLAIM); 42 | } 43 | 44 | @Override 45 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 46 | if (parameters.isEmpty()) 47 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 48 | 49 | try { 50 | double cost = Double.parseDouble(parameters); 51 | if (cost < 0) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 53 | } 54 | } catch (NumberFormatException e) { 55 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 56 | } 57 | 58 | return new SetFlagResult(true, this.getSetMessage(parameters)); 59 | } 60 | 61 | @Override 62 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 63 | if (flagTo == null) return; 64 | 65 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Access) return; 66 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Build) return; 67 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Inventory) return; 68 | if (player.getUniqueId().equals(claimTo.getOwnerID())) return; 69 | MessagingUtil.sendMessage(player, TextMode.Info, Messages.AccessTrustPrice, flagTo.parameters); 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_BuyBuildTrust.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.ClaimPermission; 7 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.player.PlayerJoinEvent; 13 | import org.jetbrains.annotations.Nullable; 14 | 15 | import java.util.Collections; 16 | import java.util.List; 17 | 18 | public class FlagDef_BuyBuildTrust extends PlayerMovementFlagDefinition { 19 | 20 | public FlagDef_BuyBuildTrust(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @Override 25 | public String getName() { 26 | return "BuyBuildTrust"; 27 | } 28 | 29 | @Override 30 | public MessageSpecifier getSetMessage(String parameters) { 31 | return new MessageSpecifier(Messages.EnableBuyBuildTrust, parameters); 32 | } 33 | 34 | @Override 35 | public MessageSpecifier getUnSetMessage() { 36 | return new MessageSpecifier(Messages.DisableBuyBuildTrust); 37 | } 38 | 39 | @Override 40 | public List getFlagType() { 41 | return Collections.singletonList(FlagType.CLAIM); 42 | } 43 | 44 | @Override 45 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 46 | if (parameters.isEmpty()) 47 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 48 | 49 | try { 50 | double cost = Double.parseDouble(parameters); 51 | if (cost < 0) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 53 | } 54 | } catch (NumberFormatException e) { 55 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 56 | } 57 | 58 | return new SetFlagResult(true, this.getSetMessage(parameters)); 59 | } 60 | 61 | @Override 62 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 63 | if (flagTo == null) return; 64 | 65 | if (claimTo == null) return; 66 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Build) return; 67 | MessagingUtil.sendMessage(player, TextMode.Info, Messages.BuildTrustPrice, flagTo.parameters); 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_BuyContainerTrust.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.ClaimPermission; 7 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.player.PlayerJoinEvent; 13 | import org.jetbrains.annotations.Nullable; 14 | 15 | import java.util.Collections; 16 | import java.util.List; 17 | 18 | public class FlagDef_BuyContainerTrust extends PlayerMovementFlagDefinition { 19 | 20 | public FlagDef_BuyContainerTrust(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @Override 25 | public String getName() { 26 | return "BuyContainerTrust"; 27 | } 28 | 29 | @Override 30 | public MessageSpecifier getSetMessage(String parameters) { 31 | return new MessageSpecifier(Messages.EnableBuyContainerTrust, parameters); 32 | } 33 | 34 | @Override 35 | public MessageSpecifier getUnSetMessage() { 36 | return new MessageSpecifier(Messages.DisableBuyContainerTrust); 37 | } 38 | 39 | @Override 40 | public List getFlagType() { 41 | return Collections.singletonList(FlagType.CLAIM); 42 | } 43 | 44 | @Override 45 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 46 | if (parameters.isEmpty()) 47 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 48 | 49 | try { 50 | double cost = Double.parseDouble(parameters); 51 | if (cost < 0) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 53 | } 54 | } catch (NumberFormatException e) { 55 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 56 | } 57 | 58 | return new SetFlagResult(true, this.getSetMessage(parameters)); 59 | } 60 | 61 | @Override 62 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 63 | if (flagTo == null) return; 64 | 65 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Inventory) return; 66 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Build) return; 67 | if (player.getUniqueId().equals(claimTo.getOwnerID())) return; 68 | MessagingUtil.sendMessage(player, TextMode.Info, Messages.ContainerTrustPrice, flagTo.parameters); 69 | } 70 | 71 | } 72 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_BuySubclaim.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.ClaimPermission; 7 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.player.PlayerJoinEvent; 13 | import org.jetbrains.annotations.Nullable; 14 | 15 | import java.util.Collections; 16 | import java.util.List; 17 | 18 | public class FlagDef_BuySubclaim extends PlayerMovementFlagDefinition { 19 | 20 | public FlagDef_BuySubclaim(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @Override 25 | public String getName() { 26 | return "BuySubclaim"; 27 | } 28 | 29 | @Override 30 | public MessageSpecifier getSetMessage(String parameters) { 31 | return new MessageSpecifier(Messages.EnableBuySubclaim, parameters); 32 | } 33 | 34 | @Override 35 | public MessageSpecifier getUnSetMessage() { 36 | return new MessageSpecifier(Messages.DisableBuySubclaim); 37 | } 38 | 39 | @Override 40 | public List getFlagType() { 41 | return Collections.singletonList(FlagType.CLAIM); 42 | } 43 | 44 | @Override 45 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 46 | if (parameters.isEmpty()) 47 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 48 | 49 | try { 50 | double cost = Double.parseDouble(parameters); 51 | if (cost < 0) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 53 | } 54 | } catch (NumberFormatException e) { 55 | return new SetFlagResult(false, new MessageSpecifier(Messages.CostRequired)); 56 | } 57 | 58 | return new SetFlagResult(true, this.getSetMessage(parameters)); 59 | } 60 | 61 | @Override 62 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 63 | if (flagTo == null) return; 64 | 65 | if (claimTo == null) return; 66 | if (claimTo.parent == null) return; 67 | if (claimTo.getPermission(player.getUniqueId().toString()) == ClaimPermission.Build) return; 68 | if (player.getUniqueId().equals(claimTo.getOwnerID())) return; 69 | 70 | MessagingUtil.sendMessage(player, TextMode.Info, Messages.SubclaimPrice, flagTo.parameters); 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_CommandBlackList.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.TextMode; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GPFlags.util.Util; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 13 | import org.bukkit.entity.Player; 14 | import org.bukkit.event.EventHandler; 15 | import org.bukkit.event.EventPriority; 16 | import org.bukkit.event.player.PlayerCommandPreprocessEvent; 17 | 18 | import java.util.Arrays; 19 | import java.util.List; 20 | 21 | public class FlagDef_CommandBlackList extends CommandListFlagDefinition { 22 | 23 | public FlagDef_CommandBlackList(FlagManager manager, GPFlags plugin) { 24 | super(manager, plugin); 25 | } 26 | 27 | @EventHandler(priority = EventPriority.LOWEST) 28 | public void onPlayerCommand(PlayerCommandPreprocessEvent event) { 29 | Player player = event.getPlayer(); 30 | 31 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 32 | if (flag == null) return; 33 | 34 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 35 | if (Util.shouldBypass(player, claim, flag)) return; 36 | 37 | if (this.commandInList(flag.parameters, event.getMessage())) { 38 | event.setCancelled(true); 39 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.CommandBlockedHere); 40 | } 41 | } 42 | 43 | @Override 44 | public String getName() { 45 | return "CommandBlackList"; 46 | } 47 | 48 | @Override 49 | public MessageSpecifier getSetMessage(String parameters) { 50 | return new MessageSpecifier(Messages.EnableCommandBlackList); 51 | } 52 | 53 | @Override 54 | public MessageSpecifier getUnSetMessage() { 55 | return new MessageSpecifier(Messages.DisableCommandBlackList); 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_CommandWhiteList.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.TextMode; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GPFlags.util.Util; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 13 | import org.bukkit.entity.Player; 14 | import org.bukkit.event.EventHandler; 15 | import org.bukkit.event.EventPriority; 16 | import org.bukkit.event.player.PlayerCommandPreprocessEvent; 17 | 18 | import java.util.Arrays; 19 | import java.util.List; 20 | 21 | public class FlagDef_CommandWhiteList extends CommandListFlagDefinition { 22 | 23 | public FlagDef_CommandWhiteList(FlagManager manager, GPFlags plugin) { 24 | super(manager, plugin); 25 | } 26 | 27 | @EventHandler(priority = EventPriority.LOWEST) 28 | public void onPlayerCommand(PlayerCommandPreprocessEvent event) { 29 | Player player = event.getPlayer(); 30 | 31 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 32 | if (flag == null) return; 33 | 34 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 35 | if (Util.shouldBypass(player, claim, flag)) return; 36 | 37 | if (!this.commandInList(flag.parameters, event.getMessage())) { 38 | event.setCancelled(true); 39 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.CommandBlockedHere); 40 | } 41 | } 42 | 43 | @Override 44 | public String getName() { 45 | return "CommandWhiteList"; 46 | } 47 | 48 | @Override 49 | public MessageSpecifier getSetMessage(String parameters) { 50 | return new MessageSpecifier(Messages.EnableCommandWhiteList); 51 | } 52 | 53 | @Override 54 | public MessageSpecifier getUnSetMessage() { 55 | return new MessageSpecifier(Messages.DisableCommandWhiteList); 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_EnterActionbar.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 7 | import me.ryanhamshire.GriefPrevention.PlayerData; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.player.PlayerJoinEvent; 13 | import org.jetbrains.annotations.NotNull; 14 | import org.jetbrains.annotations.Nullable; 15 | 16 | 17 | public class FlagDef_EnterActionbar extends PlayerMovementFlagDefinition { 18 | 19 | public FlagDef_EnterActionbar(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @Override 24 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 25 | if (flagTo == null) return; 26 | // moving to different claim with the same params 27 | if (flagFrom != null && flagFrom.parameters.equals(flagTo.parameters)) return; 28 | 29 | sendActionbar(flagTo, player, claimTo); 30 | } 31 | 32 | public void sendActionbar(@NotNull Flag flag, @NotNull Player player, @Nullable Claim claim) { 33 | String message = flag.parameters; 34 | if (claim != null) { 35 | String owner = claim.getOwnerName(); 36 | if (owner != null) { 37 | message = message.replace("%owner%", owner); 38 | } 39 | } 40 | message = message.replace("%name%", player.getName()); 41 | MessagingUtil.sendActionbar(player, message); 42 | } 43 | 44 | @Override 45 | public String getName() { 46 | return "EnterActionbar"; 47 | } 48 | 49 | @Override 50 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 51 | if (parameters.isEmpty()) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.ActionbarRequired)); 53 | } 54 | return new SetFlagResult(true, this.getSetMessage(parameters)); 55 | } 56 | 57 | @Override 58 | public MessageSpecifier getSetMessage(String parameters) { 59 | return new MessageSpecifier(Messages.AddedEnterActionbar, parameters); 60 | } 61 | 62 | @Override 63 | public MessageSpecifier getUnSetMessage() { 64 | return new MessageSpecifier(Messages.RemovedEnterActionbar); 65 | } 66 | 67 | } 68 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_EnterCommand.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GriefPrevention.Claim; 11 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 12 | import me.ryanhamshire.GriefPrevention.PlayerData; 13 | import org.bukkit.Bukkit; 14 | import org.bukkit.Location; 15 | import org.bukkit.command.CommandSender; 16 | import org.bukkit.entity.Player; 17 | import org.bukkit.event.EventHandler; 18 | import org.bukkit.event.player.PlayerJoinEvent; 19 | import org.jetbrains.annotations.Nullable; 20 | 21 | 22 | public class FlagDef_EnterCommand extends PlayerMovementFlagDefinition { 23 | 24 | public FlagDef_EnterCommand(FlagManager manager, GPFlags plugin) { 25 | super(manager, plugin); 26 | } 27 | 28 | @Override 29 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 30 | if (flagTo == null) return; 31 | // moving to different claim with the same params 32 | if (flagFrom != null && flagFrom.parameters.equals(flagTo.parameters)) return; 33 | 34 | if (player.hasPermission("gpflags.bypass.entercommand")) return; 35 | 36 | executeFlagCommandsFromConsole(flagTo, player, claimTo); 37 | } 38 | 39 | public void executeFlagCommandsFromConsole(Flag flag, Player player, @Nullable Claim claim) { 40 | String commandLinesString = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()); 41 | if (claim != null) { 42 | String ownerName = claim.getOwnerName(); 43 | if (ownerName != null) { 44 | commandLinesString = commandLinesString.replace("%owner%", ownerName); 45 | } 46 | } 47 | String[] commandLines = commandLinesString.split(";"); 48 | for (String commandLine : commandLines) { 49 | MessagingUtil.logFlagCommands("Entrance command: " + commandLine); 50 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 51 | } 52 | } 53 | 54 | @Override 55 | public String getName() { 56 | return "EnterCommand"; 57 | } 58 | 59 | @Override 60 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 61 | if (parameters.isEmpty()) { 62 | return new SetFlagResult(false, new MessageSpecifier(Messages.ConsoleCommandRequired)); 63 | } 64 | 65 | return new SetFlagResult(true, this.getSetMessage(parameters)); 66 | } 67 | 68 | @Override 69 | public MessageSpecifier getSetMessage(String parameters) { 70 | return new MessageSpecifier(Messages.AddedEnterCommand, parameters); 71 | } 72 | 73 | @Override 74 | public MessageSpecifier getUnSetMessage() { 75 | return new MessageSpecifier(Messages.RemovedEnterCommand); 76 | } 77 | 78 | } 79 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_EnterMessage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.TextMode; 10 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import org.bukkit.Location; 13 | import org.bukkit.command.CommandSender; 14 | import org.bukkit.entity.Player; 15 | import org.jetbrains.annotations.Nullable; 16 | 17 | public class FlagDef_EnterMessage extends PlayerMovementFlagDefinition { 18 | 19 | private final String prefix; 20 | 21 | public FlagDef_EnterMessage(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | this.prefix = plugin.getFlagsDataStore().getMessage(Messages.EnterExitPrefix); 24 | } 25 | 26 | @Override 27 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 28 | if (flagTo == null) return; 29 | // moving to different claim with the same params 30 | if (flagFrom != null && flagFrom.parameters.equals(flagTo.parameters)) return; 31 | 32 | sendMessage(flagTo, player, claimTo); 33 | 34 | } 35 | 36 | public void sendMessage(Flag flag, Player player, Claim claim) { 37 | String message = flag.parameters; 38 | if (claim != null) { 39 | String ownerName = claim.getOwnerName(); 40 | if (ownerName != null) { 41 | message = message.replace("%owner%", ownerName); 42 | } 43 | } 44 | message = message.replace("%name%", player.getName()); 45 | MessagingUtil.sendMessage(player, TextMode.Info + prefix + message); 46 | } 47 | 48 | @Override 49 | public String getName() { 50 | return "EnterMessage"; 51 | } 52 | 53 | @Override 54 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 55 | if (parameters.isEmpty()) { 56 | return new SetFlagResult(false, new MessageSpecifier(Messages.MessageRequired)); 57 | } 58 | 59 | return new SetFlagResult(true, this.getSetMessage(parameters)); 60 | } 61 | 62 | @Override 63 | public MessageSpecifier getSetMessage(String parameters) { 64 | return new MessageSpecifier(Messages.AddedEnterMessage, parameters); 65 | } 66 | 67 | @Override 68 | public MessageSpecifier getUnSetMessage() { 69 | return new MessageSpecifier(Messages.RemovedEnterMessage); 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_EnterPlayerCommand.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GriefPrevention.Claim; 11 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 12 | import me.ryanhamshire.GriefPrevention.PlayerData; 13 | import org.bukkit.Bukkit; 14 | import org.bukkit.Location; 15 | import org.bukkit.command.CommandSender; 16 | import org.bukkit.entity.Player; 17 | import org.bukkit.event.EventHandler; 18 | import org.bukkit.event.player.PlayerJoinEvent; 19 | import org.jetbrains.annotations.Nullable; 20 | 21 | 22 | public class FlagDef_EnterPlayerCommand extends PlayerMovementFlagDefinition { 23 | 24 | public FlagDef_EnterPlayerCommand(FlagManager manager, GPFlags plugin) { 25 | super(manager, plugin); 26 | } 27 | 28 | @Override 29 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 30 | if (flagTo == null) return; 31 | // moving to different claim with the same params 32 | if (flagFrom != null && flagFrom.parameters.equals(flagTo.parameters)) return; 33 | 34 | executeFlagCommands(flagTo, player, claimTo); 35 | } 36 | 37 | public void executeFlagCommands(Flag flag, Player player, Claim claim) { 38 | String commandLinesString = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()); 39 | if (claim != null) { 40 | String ownerName = claim.getOwnerName(); 41 | if (ownerName != null) { 42 | commandLinesString = commandLinesString.replace("%owner%", ownerName); 43 | } 44 | } 45 | String[] commandLines = commandLinesString.split(";"); 46 | for (String commandLine : commandLines) { 47 | MessagingUtil.logFlagCommands("Entrance command: " + commandLine); 48 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 49 | } 50 | } 51 | 52 | @Override 53 | public String getName() { 54 | return "EnterPlayerCommand"; 55 | } 56 | 57 | @Override 58 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 59 | if (parameters.isEmpty()) { 60 | return new SetFlagResult(false, new MessageSpecifier(Messages.PlayerCommandRequired)); 61 | } 62 | 63 | return new SetFlagResult(true, this.getSetMessage(parameters)); 64 | } 65 | 66 | @Override 67 | public MessageSpecifier getSetMessage(String parameters) { 68 | return new MessageSpecifier(Messages.AddedEnterCommand, parameters); 69 | } 70 | 71 | @Override 72 | public MessageSpecifier getUnSetMessage() { 73 | return new MessageSpecifier(Messages.RemovedEnterCommand); 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ExitActionbar.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.Location; 8 | import org.bukkit.command.CommandSender; 9 | import org.bukkit.entity.Player; 10 | import org.jetbrains.annotations.Nullable; 11 | 12 | public class FlagDef_ExitActionbar extends PlayerMovementFlagDefinition { 13 | 14 | public FlagDef_ExitActionbar(FlagManager manager, GPFlags plugin) { 15 | super(manager, plugin); 16 | } 17 | 18 | @Override 19 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 20 | if (flagFrom == null) return; 21 | // moving to different claim with the same message 22 | if (flagTo != null && flagTo.parameters.equals(flagFrom.parameters)) return; 23 | 24 | sendActionbar(flagFrom, player, claimFrom); 25 | } 26 | 27 | public void sendActionbar(Flag flag, Player player, Claim claim) { 28 | String message = flag.parameters; 29 | if (claim != null) { 30 | String owner = claim.getOwnerName(); 31 | if (owner != null) { 32 | message = message.replace("%owner%", owner); 33 | } 34 | } 35 | message = message.replace("%name%", player.getName()); 36 | MessagingUtil.sendActionbar(player, message); 37 | } 38 | 39 | @Override 40 | public String getName() { 41 | return "ExitActionbar"; 42 | } 43 | 44 | @Override 45 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 46 | if (parameters.isEmpty()) { 47 | return new SetFlagResult(false, new MessageSpecifier(Messages.ActionbarRequired)); 48 | } 49 | 50 | return new SetFlagResult(true, this.getSetMessage(parameters)); 51 | } 52 | 53 | @Override 54 | public MessageSpecifier getSetMessage(String parameters) { 55 | return new MessageSpecifier(Messages.AddedExitActionbar, parameters); 56 | } 57 | 58 | @Override 59 | public MessageSpecifier getUnSetMessage() { 60 | return new MessageSpecifier(Messages.RemovedExitActionbar); 61 | } 62 | 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ExitCommand.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 7 | import me.ryanhamshire.GriefPrevention.PlayerData; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.Location; 10 | import org.bukkit.command.CommandSender; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.Nullable; 13 | 14 | public class FlagDef_ExitCommand extends PlayerMovementFlagDefinition { 15 | 16 | public FlagDef_ExitCommand(FlagManager manager, GPFlags plugin) { 17 | super(manager, plugin); 18 | } 19 | 20 | @Override 21 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 22 | if (flagFrom == null) return; 23 | 24 | // moving to different claim with the same params 25 | if (flagTo != null && flagTo.parameters.equals(flagFrom.parameters)) return; 26 | 27 | if (player.hasPermission("gpflags.bypass.exitcommand")) return; 28 | 29 | executeFlagCommandsFromConsole(flagFrom, player, claimFrom); 30 | } 31 | 32 | public void executeFlagCommandsFromConsole(Flag flag, Player player, Claim claim) { 33 | String commandLinesString = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()); 34 | if (claim != null) { 35 | String ownerName = claim.getOwnerName(); 36 | if (ownerName != null) { 37 | commandLinesString = commandLinesString.replace("%owner%", ownerName); 38 | } 39 | } 40 | String[] commandLines = commandLinesString.split(";"); 41 | for (String commandLine : commandLines) { 42 | MessagingUtil.logFlagCommands("Exit command: " + commandLine); 43 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 44 | } 45 | } 46 | 47 | 48 | @Override 49 | public String getName() { 50 | return "ExitCommand"; 51 | } 52 | 53 | @Override 54 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 55 | if (parameters.isEmpty()) { 56 | return new SetFlagResult(false, new MessageSpecifier(Messages.ConsoleCommandRequired)); 57 | } 58 | 59 | return new SetFlagResult(true, this.getSetMessage(parameters)); 60 | } 61 | 62 | @Override 63 | public MessageSpecifier getSetMessage(String parameters) { 64 | return new MessageSpecifier(Messages.AddedExitCommand, parameters); 65 | } 66 | 67 | @Override 68 | public MessageSpecifier getUnSetMessage() { 69 | return new MessageSpecifier(Messages.RemovedExitCommand); 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ExitCommand_Members.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GPFlags.util.Util; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import org.bukkit.Bukkit; 13 | import org.bukkit.Location; 14 | import org.bukkit.command.CommandSender; 15 | import org.bukkit.entity.Player; 16 | import org.jetbrains.annotations.Nullable; 17 | 18 | public class FlagDef_ExitCommand_Members extends PlayerMovementFlagDefinition { 19 | 20 | public FlagDef_ExitCommand_Members(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @Override 25 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 26 | if (flagFrom == null) return; 27 | 28 | // moving to different claim with the same params 29 | if (flagTo != null && flagTo.parameters.equals(flagFrom.parameters)) return; 30 | 31 | if (player.hasPermission("gpflags.bypass.exitcommand")) return; 32 | if (!Util.canAccess(claimTo, player)) return; 33 | executeFlagCommandsFromConsole(flagFrom, player, claimFrom); 34 | } 35 | 36 | public void executeFlagCommandsFromConsole(Flag flag, Player player, Claim claim) { 37 | String commandLinesString = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()); 38 | if (claim != null) { 39 | String ownerName = claim.getOwnerName(); 40 | if (ownerName != null) { 41 | commandLinesString = commandLinesString.replace("%owner%", ownerName); 42 | } 43 | } 44 | String[] commandLines = commandLinesString.split(";"); 45 | for (String commandLine : commandLines) { 46 | MessagingUtil.logFlagCommands("Exit command: " + commandLine); 47 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 48 | } 49 | } 50 | 51 | @Override 52 | public String getName() { 53 | return "ExitCommand-Members"; 54 | } 55 | 56 | @Override 57 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 58 | if (parameters.isEmpty()) { 59 | return new SetFlagResult(false, new MessageSpecifier(Messages.ConsoleCommandRequired)); 60 | } 61 | 62 | return new SetFlagResult(true, this.getSetMessage(parameters)); 63 | } 64 | 65 | @Override 66 | public MessageSpecifier getSetMessage(String parameters) { 67 | return new MessageSpecifier(Messages.AddedExitCommand, parameters); 68 | } 69 | 70 | @Override 71 | public MessageSpecifier getUnSetMessage() { 72 | return new MessageSpecifier(Messages.RemovedExitCommand); 73 | } 74 | 75 | } 76 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ExitCommand_Owner.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GriefPrevention.Claim; 11 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 12 | import me.ryanhamshire.GriefPrevention.PlayerData; 13 | import org.bukkit.Bukkit; 14 | import org.bukkit.Location; 15 | import org.bukkit.command.CommandSender; 16 | import org.bukkit.entity.Player; 17 | import org.jetbrains.annotations.Nullable; 18 | 19 | public class FlagDef_ExitCommand_Owner extends PlayerMovementFlagDefinition { 20 | 21 | public FlagDef_ExitCommand_Owner(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @Override 26 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 27 | if (flagFrom == null) return; 28 | // moving to different claim with the same params 29 | if (flagTo != null && flagTo.parameters.equals(flagFrom.parameters)) return; 30 | 31 | if (player.hasPermission("gpflags.bypass.exitcommand")) return; 32 | if (!claimFrom.getOwnerName().equals(player.getName())) return; 33 | 34 | executeFlagCommandsFromConsole(flagFrom, player, claimFrom); 35 | } 36 | 37 | public void executeFlagCommandsFromConsole(Flag flag, Player player, Claim claim) { 38 | String commandLinesString = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()); 39 | if (claim != null) { 40 | String ownerName = claim.getOwnerName(); 41 | if (ownerName != null) { 42 | commandLinesString = commandLinesString.replace("%owner%", ownerName); 43 | } 44 | } 45 | String[] commandLines = commandLinesString.split(";"); 46 | for (String commandLine : commandLines) { 47 | MessagingUtil.logFlagCommands("Exit command: " + commandLine); 48 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 49 | } 50 | } 51 | 52 | @Override 53 | public String getName() { 54 | return "ExitCommand-Owner"; 55 | } 56 | 57 | @Override 58 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 59 | if (parameters.isEmpty()) { 60 | return new SetFlagResult(false, new MessageSpecifier(Messages.ConsoleCommandRequired)); 61 | } 62 | 63 | return new SetFlagResult(true, this.getSetMessage(parameters)); 64 | } 65 | 66 | @Override 67 | public MessageSpecifier getSetMessage(String parameters) { 68 | return new MessageSpecifier(Messages.AddedExitCommand, parameters); 69 | } 70 | 71 | @Override 72 | public MessageSpecifier getUnSetMessage() { 73 | return new MessageSpecifier(Messages.RemovedExitCommand); 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ExitMessage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.TextMode; 10 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import org.bukkit.Location; 13 | import org.bukkit.command.CommandSender; 14 | import org.bukkit.entity.Player; 15 | import org.jetbrains.annotations.Nullable; 16 | 17 | public class FlagDef_ExitMessage extends PlayerMovementFlagDefinition { 18 | 19 | private final String prefix; 20 | 21 | public FlagDef_ExitMessage(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | this.prefix = plugin.getFlagsDataStore().getMessage(Messages.EnterExitPrefix); 24 | } 25 | 26 | @Override 27 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 28 | if (flagFrom == null) return; 29 | // moving to different claim with the same message 30 | if (flagTo != null && flagTo.parameters.equals(flagFrom.parameters)) return; 31 | String message = flagFrom.parameters; 32 | if (claimFrom != null) { 33 | String ownerName = claimFrom.getOwnerName(); 34 | if (ownerName != null) { 35 | message = message.replace("%owner%", ownerName); 36 | } 37 | } 38 | message = message.replace("%name%", player.getName()); 39 | MessagingUtil.sendMessage(player, TextMode.Info + prefix + message); 40 | } 41 | 42 | @Override 43 | public String getName() { 44 | return "ExitMessage"; 45 | } 46 | 47 | @Override 48 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 49 | if (parameters.isEmpty()) { 50 | return new SetFlagResult(false, new MessageSpecifier(Messages.MessageRequired)); 51 | } 52 | 53 | return new SetFlagResult(true, this.getSetMessage(parameters)); 54 | } 55 | 56 | @Override 57 | public MessageSpecifier getSetMessage(String parameters) { 58 | return new MessageSpecifier(Messages.AddedExitMessage, parameters); 59 | } 60 | 61 | @Override 62 | public MessageSpecifier getUnSetMessage() { 63 | return new MessageSpecifier(Messages.RemovedExitMessage); 64 | } 65 | 66 | } 67 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ExitPlayerCommand.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GriefPrevention.Claim; 11 | import org.bukkit.Bukkit; 12 | import org.bukkit.Location; 13 | import org.bukkit.command.CommandSender; 14 | import org.bukkit.entity.Player; 15 | import org.jetbrains.annotations.Nullable; 16 | 17 | public class FlagDef_ExitPlayerCommand extends PlayerMovementFlagDefinition { 18 | 19 | public FlagDef_ExitPlayerCommand(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @Override 24 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 25 | if (flagFrom == null) return; 26 | // moving to different claim with the same params 27 | if (flagTo != null && flagTo.parameters.equals(flagFrom.parameters)) return; 28 | 29 | executeFlagCommands(flagFrom, player, claimFrom); 30 | } 31 | 32 | public void executeFlagCommands(Flag flag, Player player, Claim claim) { 33 | String commandLinesString = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()); 34 | if (claim != null) { 35 | String ownerName = claim.getOwnerName(); 36 | if (ownerName != null) { 37 | commandLinesString = commandLinesString.replace("%owner%", ownerName); 38 | } 39 | } 40 | String[] commandLines = commandLinesString.split(";"); 41 | for (String commandLine : commandLines) { 42 | MessagingUtil.logFlagCommands("Exit command: " + commandLine); 43 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 44 | } 45 | } 46 | 47 | @Override 48 | public String getName() { 49 | return "ExitPlayerCommand"; 50 | } 51 | 52 | @Override 53 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 54 | if (parameters.isEmpty()) { 55 | return new SetFlagResult(false, new MessageSpecifier(Messages.PlayerCommandRequired)); 56 | } 57 | 58 | return new SetFlagResult(true, this.getSetMessage(parameters)); 59 | } 60 | 61 | @Override 62 | public MessageSpecifier getSetMessage(String parameters) { 63 | return new MessageSpecifier(Messages.AddedExitCommand, parameters); 64 | } 65 | 66 | @Override 67 | public MessageSpecifier getUnSetMessage() { 68 | return new MessageSpecifier(Messages.RemovedExitCommand); 69 | } 70 | 71 | } 72 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_InfiniteArrows.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.*; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.entity.EntityShootBowEvent; 11 | import org.bukkit.inventory.ItemStack; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_InfiniteArrows extends FlagDefinition { 17 | 18 | public FlagDef_InfiniteArrows(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler 23 | public void onShootBow(EntityShootBowEvent event) { 24 | ItemStack bow = event.getBow(); 25 | if (bow == null) return; 26 | 27 | LivingEntity livingEntity = event.getEntity(); 28 | if (!(livingEntity instanceof Player)) return; 29 | Player player = (Player) livingEntity; 30 | 31 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 32 | if (flag == null) return; 33 | 34 | Entity projectile = event.getProjectile(); 35 | if (!(projectile instanceof Arrow)) return; 36 | Arrow arrow = (Arrow) projectile; 37 | 38 | try { 39 | event.setConsumeArrow(false); 40 | } catch (NoSuchMethodError error) { 41 | event.setConsumeItem(false); 42 | } 43 | player.updateInventory(); 44 | arrow.setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED); 45 | 46 | } 47 | 48 | @Override 49 | public String getName() { 50 | return "InfiniteArrows"; 51 | } 52 | 53 | @Override 54 | public MessageSpecifier getSetMessage(String parameters) { 55 | return new MessageSpecifier(Messages.EnableInfiniteArrows); 56 | } 57 | 58 | @Override 59 | public MessageSpecifier getUnSetMessage() { 60 | return new MessageSpecifier(Messages.DisableInfiniteArrows); 61 | } 62 | 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_KeepInventory.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.Player; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.entity.PlayerDeathEvent; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_KeepInventory extends FlagDefinition { 17 | 18 | public FlagDef_KeepInventory(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.HIGHEST) 23 | public void onPlayerDeath(PlayerDeathEvent event) { 24 | Player player = event.getEntity(); 25 | 26 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 27 | if (flag == null) return; 28 | 29 | event.setKeepInventory(true); 30 | event.getDrops().clear(); 31 | } 32 | 33 | @Override 34 | public String getName() { 35 | return "KeepInventory"; 36 | } 37 | 38 | @Override 39 | public MessageSpecifier getSetMessage(String parameters) { 40 | return new MessageSpecifier(Messages.EnableKeepInventory); 41 | } 42 | 43 | @Override 44 | public MessageSpecifier getUnSetMessage() { 45 | return new MessageSpecifier(Messages.DisableKeepInventory); 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_KeepLevel.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.Player; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.entity.PlayerDeathEvent; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_KeepLevel extends FlagDefinition { 17 | 18 | public FlagDef_KeepLevel(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.LOWEST) 23 | public void onPlayerDeath(PlayerDeathEvent event) { 24 | Player player = event.getEntity(); 25 | 26 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), null); 27 | if (flag == null) return; 28 | 29 | event.setKeepLevel(true); 30 | event.setDroppedExp(0); 31 | } 32 | 33 | @Override 34 | public String getName() { 35 | return "KeepLevel"; 36 | } 37 | 38 | @Override 39 | public MessageSpecifier getSetMessage(String parameters) { 40 | return new MessageSpecifier(Messages.EnableKeepLevel); 41 | } 42 | 43 | @Override 44 | public MessageSpecifier getUnSetMessage() { 45 | return new MessageSpecifier(Messages.DisableKeepLevel); 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_KeepLoaded.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GriefPrevention.Claim; 5 | import org.bukkit.Chunk; 6 | 7 | import java.util.*; 8 | 9 | public class FlagDef_KeepLoaded extends FlagDefinition { 10 | 11 | public FlagDef_KeepLoaded(FlagManager manager, GPFlags plugin) { 12 | super(manager, plugin); 13 | } 14 | 15 | @Override 16 | public void onFlagSet(Claim claim, String string) { 17 | ArrayList chunks = claim.getChunks(); 18 | for (Chunk chunk : chunks) { 19 | chunk.setForceLoaded(true); 20 | chunk.load(true); 21 | } 22 | } 23 | 24 | @Override 25 | public void onFlagUnset(Claim claim) { 26 | ArrayList chunks = claim.getChunks(); 27 | for (Chunk chunk : chunks) { 28 | chunk.setForceLoaded(false); 29 | } 30 | } 31 | 32 | @Override 33 | public String getName() { 34 | return "KeepLoaded"; 35 | } 36 | 37 | @Override 38 | public MessageSpecifier getSetMessage(String parameters) { 39 | return new MessageSpecifier(Messages.EnableKeepLoaded); 40 | } 41 | 42 | @Override 43 | public MessageSpecifier getUnSetMessage() { 44 | return new MessageSpecifier(Messages.DisableKeepLoaded); 45 | } 46 | 47 | @Override 48 | public List getFlagType() { 49 | return Collections.singletonList(FlagType.CLAIM); 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NetherPortalConsoleCommand.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.EventHandler; 14 | import org.bukkit.event.EventPriority; 15 | import org.bukkit.event.player.PlayerTeleportEvent; 16 | import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; 17 | 18 | import java.util.Arrays; 19 | import java.util.List; 20 | 21 | public class FlagDef_NetherPortalConsoleCommand extends FlagDefinition { 22 | 23 | public FlagDef_NetherPortalConsoleCommand(FlagManager manager, GPFlags plugin) { 24 | super(manager, plugin); 25 | } 26 | 27 | @EventHandler(priority = EventPriority.LOWEST) 28 | public void onPlayerTeleport(PlayerTeleportEvent event) { 29 | TeleportCause cause = event.getCause(); 30 | 31 | if (cause != TeleportCause.NETHER_PORTAL) return; 32 | 33 | Player player = event.getPlayer(); 34 | 35 | Flag flag = this.getFlagInstanceAtLocation(event.getFrom(), player); 36 | if (flag == null) return; 37 | 38 | event.setCancelled(true); 39 | String[] commandLines = flag.parameters.replace("%name%", player.getName()).replace("%uuid%", player.getUniqueId().toString()).split(";"); 40 | for (String commandLine : commandLines) { 41 | Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandLine); 42 | } 43 | } 44 | 45 | @Override 46 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 47 | if (parameters.isEmpty()) { 48 | return new SetFlagResult(false, new MessageSpecifier(Messages.ConsoleCommandRequired)); 49 | } 50 | 51 | return new SetFlagResult(true, this.getSetMessage(parameters)); 52 | } 53 | 54 | @Override 55 | public String getName() { 56 | return "NetherPortalConsoleCommand"; 57 | } 58 | 59 | @Override 60 | public MessageSpecifier getSetMessage(String parameters) { 61 | return new MessageSpecifier(Messages.EnableNetherPortalConsoleCommand); 62 | } 63 | 64 | @Override 65 | public MessageSpecifier getUnSetMessage() { 66 | return new MessageSpecifier(Messages.DisableNetherPortalConsoleCommand); 67 | } 68 | 69 | } 70 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NetherPortalPlayerCommand.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.EventPriority; 13 | import org.bukkit.event.player.PlayerTeleportEvent; 14 | import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; 15 | 16 | import java.util.Arrays; 17 | import java.util.List; 18 | 19 | public class FlagDef_NetherPortalPlayerCommand extends FlagDefinition { 20 | 21 | public FlagDef_NetherPortalPlayerCommand(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler(priority = EventPriority.LOWEST) 26 | public void onPlayerTeleport(PlayerTeleportEvent event) { 27 | TeleportCause cause = event.getCause(); 28 | 29 | if (cause != TeleportCause.NETHER_PORTAL) return; 30 | 31 | Player player = event.getPlayer(); 32 | 33 | Flag flag = this.getFlagInstanceAtLocation(event.getFrom(), player); 34 | if (flag == null) return; 35 | 36 | event.setCancelled(true); 37 | player.performCommand(flag.parameters); 38 | } 39 | 40 | @Override 41 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 42 | if (parameters.isEmpty()) { 43 | return new SetFlagResult(false, new MessageSpecifier(Messages.CommandRequired)); 44 | } 45 | 46 | return new SetFlagResult(true, this.getSetMessage(parameters)); 47 | } 48 | 49 | @Override 50 | public String getName() { 51 | return "NetherPortalPlayerCommand"; 52 | } 53 | 54 | @Override 55 | public MessageSpecifier getSetMessage(String parameters) { 56 | return new MessageSpecifier(Messages.EnableNetherPortalPlayerCommand); 57 | } 58 | 59 | @Override 60 | public MessageSpecifier getUnSetMessage() { 61 | return new MessageSpecifier(Messages.DisableNetherPortalPlayerCommand); 62 | } 63 | 64 | } 65 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoAnvilDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import com.destroystokyo.paper.event.block.AnvilDamagedEvent; 4 | import me.ryanhamshire.GPFlags.*; 5 | import org.bukkit.Location; 6 | import org.bukkit.entity.HumanEntity; 7 | import org.bukkit.entity.Player; 8 | import org.bukkit.event.EventHandler; 9 | 10 | import java.util.Arrays; 11 | import java.util.List; 12 | 13 | public class FlagDef_NoAnvilDamage extends FlagDefinition { 14 | 15 | public FlagDef_NoAnvilDamage(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @EventHandler 20 | public void onAnvilDamage(AnvilDamagedEvent event) { 21 | Location location = event.getInventory().getLocation(); 22 | if (location == null) return; 23 | 24 | HumanEntity human = event.getView().getPlayer(); 25 | Player player = null; 26 | if (human instanceof Player) player = (Player) human; 27 | 28 | Flag flag = this.getFlagInstanceAtLocation(location, player); 29 | if (flag == null) return; 30 | event.setCancelled(true); 31 | 32 | } 33 | 34 | @Override 35 | public String getName() { 36 | return "NoAnvilDamage"; 37 | } 38 | 39 | @Override 40 | public MessageSpecifier getSetMessage(String parameters) { 41 | return new MessageSpecifier(Messages.EnableNoAnvilDamage); 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getUnSetMessage() { 46 | return new MessageSpecifier(Messages.DisableNoAnvilDamage); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoBlockFade.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.EventPriority; 7 | import org.bukkit.event.block.BlockFadeEvent; 8 | 9 | import java.util.Arrays; 10 | import java.util.List; 11 | 12 | public class FlagDef_NoBlockFade extends FlagDefinition { 13 | 14 | public FlagDef_NoBlockFade(FlagManager manager, GPFlags plugin) { 15 | super(manager, plugin); 16 | } 17 | 18 | @EventHandler(priority = EventPriority.LOWEST) 19 | public void onFade(BlockFadeEvent event) { 20 | Block block = event.getBlock(); 21 | 22 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 23 | if (flag == null) return; 24 | 25 | event.setCancelled(true); 26 | } 27 | 28 | @Override 29 | public String getName() { 30 | return "NoBlockFade"; 31 | } 32 | 33 | @Override 34 | public MessageSpecifier getSetMessage(String parameters) { 35 | return new MessageSpecifier(Messages.EnableNoBlockFade); 36 | } 37 | 38 | @Override 39 | public MessageSpecifier getUnSetMessage() { 40 | return new MessageSpecifier(Messages.DisableNoBlockFade); 41 | } 42 | 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoBlockForm.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.EventPriority; 6 | import org.bukkit.event.block.BlockFormEvent; 7 | 8 | import java.util.Arrays; 9 | import java.util.List; 10 | 11 | public class FlagDef_NoBlockForm extends FlagDefinition { 12 | 13 | public FlagDef_NoBlockForm(FlagManager manager, GPFlags plugin) { 14 | super(manager, plugin); 15 | } 16 | 17 | @EventHandler(priority = EventPriority.LOWEST) 18 | public void onEntityDamage(BlockFormEvent event) { 19 | Flag flag = this.getFlagInstanceAtLocation(event.getBlock().getLocation(), null); 20 | if (flag == null) return; 21 | event.setCancelled(true); 22 | } 23 | 24 | @Override 25 | public String getName() { 26 | return "NoBlockForm"; 27 | } 28 | 29 | @Override 30 | public MessageSpecifier getSetMessage(String parameters) { 31 | return new MessageSpecifier(Messages.EnableNoBlockForm); 32 | } 33 | 34 | @Override 35 | public MessageSpecifier getUnSetMessage() { 36 | return new MessageSpecifier(Messages.DisableNoBlockForm); 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoBlockGravity.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.entity.*; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.entity.EntityChangeBlockEvent; 7 | 8 | import java.util.Arrays; 9 | import java.util.List; 10 | 11 | public class FlagDef_NoBlockGravity extends FlagDefinition { 12 | 13 | public FlagDef_NoBlockGravity(FlagManager manager, GPFlags plugin) { 14 | super(manager, plugin); 15 | } 16 | 17 | @EventHandler 18 | private void onBlockFall(EntityChangeBlockEvent event){ 19 | if (this.getFlagInstanceAtLocation(event.getBlock().getLocation(), null) == null) return; 20 | if (event.getEntityType() == EntityType.FALLING_BLOCK) { 21 | event.setCancelled(true); 22 | event.getBlock().getState().update(false, false); 23 | } 24 | } 25 | 26 | @Override 27 | public String getName() { 28 | return "NoBlockGravity"; 29 | } 30 | 31 | @Override 32 | public MessageSpecifier getSetMessage(String parameters) { 33 | return new MessageSpecifier(Messages.EnableNoBlockGravity); 34 | } 35 | 36 | @Override 37 | public MessageSpecifier getUnSetMessage() { 38 | return new MessageSpecifier(Messages.DisableNoBlockGravity); 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoBlockSpread.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.event.EventHandler; 6 | import org.bukkit.event.EventPriority; 7 | import org.bukkit.event.block.BlockGrowEvent; 8 | import org.bukkit.event.block.BlockSpreadEvent; 9 | 10 | import java.util.Arrays; 11 | import java.util.List; 12 | 13 | public class FlagDef_NoBlockSpread extends FlagDefinition { 14 | 15 | public FlagDef_NoBlockSpread(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @EventHandler(priority = EventPriority.LOWEST) 20 | public void onSpread(BlockSpreadEvent event) { 21 | Block block = event.getBlock(); 22 | 23 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 24 | if (flag == null) return; 25 | 26 | event.setCancelled(true); 27 | } 28 | 29 | @Override 30 | public String getName() { 31 | return "NoBlockSpread"; 32 | } 33 | 34 | @Override 35 | public MessageSpecifier getSetMessage(String parameters) { 36 | return new MessageSpecifier(Messages.EnableNoBlockSpread); 37 | } 38 | 39 | @Override 40 | public MessageSpecifier getUnSetMessage() { 41 | return new MessageSpecifier(Messages.DisableNoBlockSpread); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoChorusFruit.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.util.Util; 9 | import me.ryanhamshire.GriefPrevention.Claim; 10 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.event.EventHandler; 13 | import org.bukkit.event.EventPriority; 14 | import org.bukkit.event.player.PlayerTeleportEvent; 15 | import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; 16 | 17 | import java.util.Arrays; 18 | import java.util.Collections; 19 | import java.util.List; 20 | 21 | public class FlagDef_NoChorusFruit extends FlagDefinition { 22 | 23 | public FlagDef_NoChorusFruit(FlagManager manager, GPFlags plugin) { 24 | super(manager, plugin); 25 | } 26 | 27 | @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) 28 | public void onPlayerTeleport(PlayerTeleportEvent event) { 29 | if (event.getCause() != TeleportCause.CHORUS_FRUIT) return; 30 | 31 | Player player = event.getPlayer(); 32 | 33 | Flag flag = this.getFlagInstanceAtLocation(event.getFrom(), event.getPlayer()); 34 | if (flag != null) { 35 | Claim claimFrom = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 36 | if (!Util.shouldBypass(player, claimFrom, flag)) { 37 | event.setCancelled(true); 38 | } 39 | } 40 | 41 | flag = this.getFlagInstanceAtLocation(event.getTo(), event.getPlayer()); 42 | if (flag != null) { 43 | Claim claimTo = GriefPrevention.instance.dataStore.getClaimAt(event.getTo(), false, null); 44 | if (!Util.shouldBypass(player, claimTo, flag)) { 45 | event.setCancelled(true); 46 | } 47 | } 48 | } 49 | 50 | @Override 51 | public String getName() { 52 | return "NoChorusFruit"; 53 | } 54 | 55 | @Override 56 | public MessageSpecifier getSetMessage(String parameters) { 57 | return new MessageSpecifier(Messages.EnableNoChorusFruit); 58 | } 59 | 60 | @Override 61 | public MessageSpecifier getUnSetMessage() { 62 | return new MessageSpecifier(Messages.DisableNoChorusFruit); 63 | } 64 | 65 | } 66 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoCombatLoot.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.EntityType; 9 | import org.bukkit.entity.LivingEntity; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.entity.EntityDeathEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoCombatLoot extends FlagDefinition { 18 | 19 | public FlagDef_NoCombatLoot(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.LOWEST) 24 | public void onEntityDeath(EntityDeathEvent event) { 25 | LivingEntity entity = event.getEntity(); 26 | 27 | if (entity.getType() == EntityType.PLAYER) return; 28 | 29 | Flag flag = this.getFlagInstanceAtLocation(entity.getLocation(), null); 30 | if (flag == null) return; 31 | 32 | event.getDrops().clear(); 33 | } 34 | 35 | @Override 36 | public String getName() { 37 | return "NoCombatLoot"; 38 | } 39 | 40 | @Override 41 | public MessageSpecifier getSetMessage(String parameters) { 42 | return new MessageSpecifier(Messages.EnableNoCombatLoot); 43 | } 44 | 45 | @Override 46 | public MessageSpecifier getUnSetMessage() { 47 | return new MessageSpecifier(Messages.DisableNoCombatLoot); 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoCoralDeath.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.Material; 5 | import org.bukkit.Tag; 6 | import org.bukkit.block.Block; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.EventPriority; 9 | import org.bukkit.event.block.BlockFadeEvent; 10 | 11 | import java.util.Arrays; 12 | import java.util.List; 13 | 14 | public class FlagDef_NoCoralDeath extends FlagDefinition { 15 | 16 | public FlagDef_NoCoralDeath(FlagManager manager, GPFlags plugin) { 17 | super(manager, plugin); 18 | } 19 | 20 | @EventHandler(priority = EventPriority.LOWEST) 21 | public void onFade(BlockFadeEvent event) { 22 | Block block = event.getBlock(); 23 | Material material = block.getType(); 24 | if (!Tag.CORALS.isTagged(material) && 25 | !Tag.CORAL_PLANTS.isTagged(material) && 26 | !Tag.CORAL_BLOCKS.isTagged(material) && 27 | !Tag.WALL_CORALS.isTagged(material)) { 28 | return; 29 | } 30 | 31 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 32 | if (flag == null) return; 33 | 34 | event.setCancelled(true); 35 | } 36 | 37 | @Override 38 | public String getName() { 39 | return "NoCoralDeath"; 40 | } 41 | 42 | @Override 43 | public MessageSpecifier getSetMessage(String parameters) { 44 | return new MessageSpecifier(Messages.EnableNoCoralDeath); 45 | } 46 | 47 | @Override 48 | public MessageSpecifier getUnSetMessage() { 49 | return new MessageSpecifier(Messages.DisableNoCoralDeath); 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoCropTrampling.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.Material; 5 | import org.bukkit.block.Block; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.entity.EntityChangeBlockEvent; 8 | 9 | 10 | public class FlagDef_NoCropTrampling extends FlagDefinition { 11 | 12 | public FlagDef_NoCropTrampling(FlagManager manager, GPFlags plugin) { 13 | super(manager, plugin); 14 | } 15 | 16 | @EventHandler 17 | public void onEntityChangeBlock(EntityChangeBlockEvent event) { 18 | // Check that the event is a crop trample 19 | Block block = event.getBlock(); 20 | if (block.getType() != Material.FARMLAND) return; 21 | 22 | // Check that the flag is set 23 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 24 | if (flag == null) return; 25 | 26 | // Prevent the trample 27 | event.setCancelled(true); 28 | } 29 | 30 | @Override 31 | public String getName() { 32 | return "NoCropTrampling"; 33 | } 34 | 35 | @Override 36 | public MessageSpecifier getSetMessage(String parameters) { 37 | return new MessageSpecifier(Messages.EnableNoCropTrampling); 38 | } 39 | 40 | @Override 41 | public MessageSpecifier getUnSetMessage() { 42 | return new MessageSpecifier(Messages.DisableNoCropTrampling); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoDripstoneSpread.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.Material; 5 | import org.bukkit.block.Block; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.EventPriority; 8 | import org.bukkit.event.block.BlockSpreadEvent; 9 | 10 | import java.util.Arrays; 11 | import java.util.List; 12 | 13 | public class FlagDef_NoDripstoneSpread extends FlagDefinition { 14 | 15 | public FlagDef_NoDripstoneSpread(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @EventHandler(priority = EventPriority.LOWEST) 20 | public void onSpread(BlockSpreadEvent event) { 21 | Block block = event.getBlock(); 22 | Material material = block.getType(); 23 | if (material != Material.POINTED_DRIPSTONE) return; 24 | 25 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 26 | if (flag == null) return; 27 | 28 | event.setCancelled(true); 29 | } 30 | 31 | @Override 32 | public String getName() { 33 | return "NoDripstoneSpread"; 34 | } 35 | 36 | @Override 37 | public MessageSpecifier getSetMessage(String parameters) { 38 | return new MessageSpecifier(Messages.EnableNoDripstoneSpread); 39 | } 40 | 41 | @Override 42 | public MessageSpecifier getUnSetMessage() { 43 | return new MessageSpecifier(Messages.DisableNoDripstoneSpread); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoEliteMobSpawns.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.entity.Entity; 5 | import org.bukkit.event.EventHandler; 6 | import com.magmaguy.elitemobs.api.EliteMobSpawnEvent; 7 | 8 | 9 | import java.util.Arrays; 10 | import java.util.List; 11 | 12 | public class FlagDef_NoEliteMobSpawns extends FlagDefinition { 13 | 14 | public FlagDef_NoEliteMobSpawns(FlagManager manager, GPFlags plugin) { 15 | super(manager, plugin); 16 | } 17 | 18 | @EventHandler 19 | public void onEntitySpawn(EliteMobSpawnEvent event) { 20 | Entity e = event.getEntity(); 21 | if (e == null) return; 22 | Flag flag = this.getFlagInstanceAtLocation(e.getLocation(), null); 23 | if (flag == null) return; 24 | event.setCancelled(true); 25 | } 26 | 27 | @Override 28 | public String getName() { 29 | return "NoEliteMobSpawns"; 30 | } 31 | 32 | @Override 33 | public MessageSpecifier getSetMessage(String parameters) { 34 | return new MessageSpecifier(Messages.EnableNoEliteMobSpawns); 35 | } 36 | 37 | @Override 38 | public MessageSpecifier getUnSetMessage() { 39 | return new MessageSpecifier(Messages.DisableNoEliteMobSpawns); 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoElytra.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 7 | import org.bukkit.Location; 8 | import org.bukkit.entity.Entity; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.entity.EntityToggleGlideEvent; 12 | import org.jetbrains.annotations.NotNull; 13 | import org.jetbrains.annotations.Nullable; 14 | 15 | import java.util.Arrays; 16 | import java.util.List; 17 | 18 | public class FlagDef_NoElytra extends PlayerMovementFlagDefinition { 19 | 20 | 21 | public FlagDef_NoElytra(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @Override 26 | public void onChangeClaim(@NotNull Player player, Location lastLocation, @NotNull Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 27 | if (flagTo == null) return; 28 | if (!player.isGliding()) return; 29 | if (Util.shouldBypass(player, claimTo, flagTo)) return; 30 | player.setGliding(false); 31 | FlightManager.considerForFallImmunity(player); 32 | } 33 | 34 | @EventHandler 35 | private void onToggleElytra(EntityToggleGlideEvent event) { 36 | Entity entity = event.getEntity(); 37 | if (!(entity instanceof Player)) return; 38 | if (!event.isGliding()) return; 39 | Player player = (Player) event.getEntity(); 40 | Location location = player.getLocation(); 41 | Flag flag = this.getFlagInstanceAtLocation(location, player); 42 | if (flag == null) return; 43 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(location, false, null); 44 | if (Util.shouldBypass(player, claim, flag)) return; 45 | 46 | event.setCancelled(true); 47 | 48 | } 49 | 50 | @Override 51 | public String getName() { 52 | return "NoElytra"; 53 | } 54 | 55 | @Override 56 | public MessageSpecifier getSetMessage(String parameters) { 57 | return new MessageSpecifier(Messages.EnableNoElytra, parameters); 58 | } 59 | 60 | @Override 61 | public MessageSpecifier getUnSetMessage() { 62 | return new MessageSpecifier(Messages.DisableNoElytra); 63 | } 64 | 65 | @Override 66 | public List getFlagType() { 67 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT, FlagType.WORLD, FlagType.SERVER); 68 | } 69 | 70 | } 71 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoEnter.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.TextMode; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GPFlags.util.Util; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 13 | import org.bukkit.Location; 14 | import org.bukkit.World; 15 | import org.bukkit.entity.Player; 16 | import org.jetbrains.annotations.NotNull; 17 | import org.jetbrains.annotations.Nullable; 18 | 19 | public class FlagDef_NoEnter extends PlayerMovementFlagDefinition { 20 | 21 | public FlagDef_NoEnter(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @Override 26 | public void onFlagSet(Claim claim, String string) { 27 | World world = claim.getLesserBoundaryCorner().getWorld(); 28 | for (Player p : world.getPlayers()) { 29 | if (claim.contains(Util.getInBoundsLocation(p), false, false)) { 30 | if (!Util.canAccess(claim, p) && !p.hasPermission("gpflags.bypass.noenter")) { 31 | GriefPrevention.instance.ejectPlayer(p); 32 | } 33 | } 34 | } 35 | } 36 | 37 | @Override 38 | public boolean allowMovement(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo) { 39 | Flag flag = getEffectiveFlag(claimTo, to); 40 | if (isAllowed(flag, claimTo, player)) return true; 41 | 42 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.NoEnterMessage); 43 | return false; 44 | } 45 | 46 | @Override 47 | public void onChangeClaim(@NotNull Player player, @Nullable Location from, @NotNull Location to, @Nullable Claim claimFrom, @Nullable Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 48 | if (isAllowed(flagTo, claimTo, player)) return; 49 | 50 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.NoEnterMessage); 51 | GriefPrevention.instance.ejectPlayer(player); 52 | } 53 | 54 | private boolean isAllowed(Flag flag, Claim claim, Player player) { 55 | if (flag == null) return true; 56 | if (Util.canAccess(claim, player)) return true; 57 | if (player.hasPermission("gpflags.bypass.noenter")) return true; 58 | return false; 59 | } 60 | 61 | @Override 62 | public String getName() { 63 | return "NoEnter"; 64 | } 65 | 66 | @Override 67 | public MessageSpecifier getSetMessage(String parameters) { 68 | return new MessageSpecifier(Messages.EnabledNoEnter, parameters); 69 | } 70 | 71 | @Override 72 | public MessageSpecifier getUnSetMessage() { 73 | return new MessageSpecifier(Messages.DisabledNoEnter); 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoExpiration.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GriefPrevention.events.ClaimExpirationEvent; 9 | import org.bukkit.Location; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | 13 | import java.util.Collections; 14 | import java.util.List; 15 | 16 | public class FlagDef_NoExpiration extends FlagDefinition { 17 | 18 | public FlagDef_NoExpiration(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) 23 | public void onClaimExpiration(ClaimExpirationEvent event) { 24 | Location location = event.getClaim().getLesserBoundaryCorner(); 25 | Flag flag = this.getFlagInstanceAtLocation(location, null); 26 | if (flag != null) { 27 | event.setCancelled(true); 28 | } 29 | } 30 | 31 | @Override 32 | public String getName() { 33 | return "NoExpiration"; 34 | } 35 | 36 | @Override 37 | public MessageSpecifier getSetMessage(String parameters) { 38 | return new MessageSpecifier(Messages.EnableNoExpiration); 39 | } 40 | 41 | @Override 42 | public MessageSpecifier getUnSetMessage() { 43 | return new MessageSpecifier(Messages.DisableNoExpiration); 44 | } 45 | 46 | @Override 47 | public List getFlagType() { 48 | return Collections.singletonList(FlagType.CLAIM); 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoExplosionDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.Player; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.entity.EntityDamageEvent; 11 | 12 | import java.util.Arrays; 13 | import java.util.List; 14 | 15 | public class FlagDef_NoExplosionDamage extends FlagDefinition { 16 | 17 | public FlagDef_NoExplosionDamage(FlagManager manager, GPFlags plugin) { 18 | super(manager, plugin); 19 | } 20 | 21 | @EventHandler 22 | public void onFall(EntityDamageEvent e) { 23 | if (!(e.getEntity() instanceof Player)) return; 24 | if (e.getCause() == EntityDamageEvent.DamageCause.ENTITY_EXPLOSION || 25 | e.getCause() == EntityDamageEvent.DamageCause.BLOCK_EXPLOSION) { 26 | 27 | Flag flag = this.getFlagInstanceAtLocation(e.getEntity().getLocation(), null); 28 | if (flag == null) return; 29 | 30 | e.setCancelled(true); 31 | } 32 | } 33 | 34 | @Override 35 | public String getName() { 36 | return "NoExplosionDamage"; 37 | } 38 | 39 | @Override 40 | public MessageSpecifier getSetMessage(String parameters) { 41 | return new MessageSpecifier(Messages.EnabledNoExplosionDamage); 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getUnSetMessage() { 46 | return new MessageSpecifier(Messages.DisabledNoExplosionDamage); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoFallDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.Player; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.entity.EntityDamageEvent; 11 | 12 | import java.util.Arrays; 13 | import java.util.List; 14 | 15 | public class FlagDef_NoFallDamage extends FlagDefinition { 16 | 17 | public FlagDef_NoFallDamage(FlagManager manager, GPFlags plugin) { 18 | super(manager, plugin); 19 | } 20 | 21 | @EventHandler 22 | public void onFall(EntityDamageEvent e) { 23 | if (!(e.getEntity() instanceof Player)) return; 24 | if (e.getCause() != EntityDamageEvent.DamageCause.FALL) return; 25 | 26 | Flag flag = this.getFlagInstanceAtLocation(e.getEntity().getLocation(), null); 27 | if (flag == null) return; 28 | 29 | e.setCancelled(true); 30 | } 31 | 32 | @Override 33 | public String getName() { 34 | return "NoFallDamage"; 35 | } 36 | 37 | @Override 38 | public MessageSpecifier getSetMessage(String parameters) { 39 | return new MessageSpecifier(Messages.EnabledNoFallDamage); 40 | } 41 | 42 | @Override 43 | public MessageSpecifier getUnSetMessage() { 44 | return new MessageSpecifier(Messages.DisabledNoFallDamage); 45 | } 46 | 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoFireDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.block.Block; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.block.BlockBurnEvent; 12 | import org.bukkit.event.block.BlockIgniteEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoFireDamage extends FlagDefinition { 18 | 19 | public FlagDef_NoFireDamage(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.LOWEST) 24 | public void onFireSpread(BlockBurnEvent e) { 25 | Block fire = e.getBlock(); 26 | Flag flag = this.getFlagInstanceAtLocation(fire.getLocation(), null); 27 | if (flag == null) return; 28 | 29 | e.setCancelled(true); 30 | } 31 | 32 | @EventHandler(priority = EventPriority.LOWEST) 33 | public void onBlockIgnite(BlockIgniteEvent e) { 34 | Block fire = e.getBlock(); 35 | Flag flag = this.getFlagInstanceAtLocation(fire.getLocation(), null); 36 | if (flag == null) return; 37 | if (e.getCause() == BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL) return; 38 | 39 | e.setCancelled(true); 40 | } 41 | 42 | @Override 43 | public String getName() { 44 | return "NoFireDamage"; 45 | } 46 | 47 | @Override 48 | public MessageSpecifier getSetMessage(String parameters) { 49 | return new MessageSpecifier(Messages.EnableNoFireDamage); 50 | } 51 | 52 | @Override 53 | public MessageSpecifier getUnSetMessage() { 54 | return new MessageSpecifier(Messages.DisableNoFireDamage); 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoFireSpread.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.Material; 9 | import org.bukkit.block.Block; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.block.BlockSpreadEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoFireSpread extends FlagDefinition { 18 | 19 | public FlagDef_NoFireSpread(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.LOWEST) 24 | public void onFireSpread(BlockSpreadEvent e) { 25 | Block fire = e.getSource(); 26 | if (fire.getType() != Material.FIRE) return; 27 | 28 | Flag flag = this.getFlagInstanceAtLocation(fire.getLocation(), null); 29 | if (flag == null) return; 30 | 31 | e.setCancelled(true); 32 | } 33 | 34 | @Override 35 | public String getName() { 36 | return "NoFireSpread"; 37 | } 38 | 39 | @Override 40 | public MessageSpecifier getSetMessage(String parameters) { 41 | return new MessageSpecifier(Messages.EnabledNoFireSpread); 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getUnSetMessage() { 46 | return new MessageSpecifier(Messages.DisabledNoFireSpread); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoFlight.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | 7 | import org.bukkit.Location; 8 | import org.bukkit.entity.Player; 9 | 10 | import java.util.Arrays; 11 | import java.util.List; 12 | 13 | public class FlagDef_NoFlight extends FlagDefinition { 14 | 15 | public FlagDef_NoFlight(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @Override 20 | public void onFlagSet(Claim claim, String param) { 21 | for (Player p : Util.getPlayersIn(claim)) { 22 | FlightManager.managePlayerFlight(p, null, p.getLocation()); 23 | } 24 | } 25 | 26 | @Override 27 | public void onFlagUnset(Claim claim) { 28 | for (Player p : Util.getPlayersIn(claim)) { 29 | FlightManager.manageFlightLater(p, 1, p.getLocation()); 30 | } 31 | } 32 | 33 | public static boolean letPlayerFly(Player player, Location location, Claim claim) { 34 | Flag flag = GPFlags.getInstance().getFlagManager().getEffectiveFlag(location, "NoFlight", claim); 35 | if (flag == null) return true; 36 | return Util.shouldBypass(player, claim, flag); 37 | } 38 | 39 | @Override 40 | public String getName() { 41 | return "NoFlight"; 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getSetMessage(String parameters) { 46 | return new MessageSpecifier(Messages.EnableNoFlight); 47 | } 48 | 49 | @Override 50 | public MessageSpecifier getUnSetMessage() { 51 | return new MessageSpecifier(Messages.DisableNoFlight); 52 | } 53 | 54 | @Override 55 | public List getFlagType() { 56 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT, FlagType.WORLD, FlagType.SERVER); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoFluidFlow.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.Location; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.block.BlockFromToEvent; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_NoFluidFlow extends FlagDefinition { 17 | 18 | private Location previousLocation = null; 19 | private boolean previousWasCancelled = false; 20 | 21 | public FlagDef_NoFluidFlow(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) 26 | public void onBlockFromTo(BlockFromToEvent event) { 27 | Location location = event.getBlock().getLocation(); 28 | if (location.equals(this.previousLocation)) { 29 | if (!this.previousWasCancelled) return; 30 | event.setCancelled(true); 31 | return; 32 | } 33 | 34 | Flag flag = this.getFlagInstanceAtLocation(location, null); 35 | boolean cancel = (flag != null); 36 | 37 | this.previousLocation = location; 38 | this.previousWasCancelled = cancel; 39 | if (cancel) { 40 | event.setCancelled(true); 41 | } 42 | } 43 | 44 | @Override 45 | public String getName() { 46 | return "NoFluidFlow"; 47 | } 48 | 49 | @Override 50 | public MessageSpecifier getSetMessage(String parameters) { 51 | return new MessageSpecifier(Messages.EnableNoFluidFlow); 52 | } 53 | 54 | @Override 55 | public MessageSpecifier getUnSetMessage() { 56 | return new MessageSpecifier(Messages.DisableNoFluidFlow); 57 | } 58 | 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoGrowth.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.block.Block; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.block.BlockGrowEvent; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_NoGrowth extends FlagDefinition { 17 | 18 | public FlagDef_NoGrowth(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.LOWEST) 23 | public void onGrowth(BlockGrowEvent event) { 24 | Block block = event.getBlock(); 25 | 26 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 27 | if (flag == null) return; 28 | 29 | event.setCancelled(true); 30 | } 31 | 32 | @Override 33 | public String getName() { 34 | return "NoGrowth"; 35 | } 36 | 37 | @Override 38 | public MessageSpecifier getSetMessage(String parameters) { 39 | return new MessageSpecifier(Messages.EnableNoGrowth); 40 | } 41 | 42 | @Override 43 | public MessageSpecifier getUnSetMessage() { 44 | return new MessageSpecifier(Messages.DisableNoGrowth); 45 | } 46 | 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoHunger.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.EntityType; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.entity.EntityDamageEvent; 12 | import org.bukkit.event.entity.EntityDamageEvent.DamageCause; 13 | import org.bukkit.event.entity.FoodLevelChangeEvent; 14 | 15 | import java.util.Arrays; 16 | import java.util.List; 17 | 18 | public class FlagDef_NoHunger extends FlagDefinition { 19 | 20 | public FlagDef_NoHunger(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @EventHandler 25 | public void onHungerDeplete(FoodLevelChangeEvent e) { 26 | Flag flag = this.getFlagInstanceAtLocation(e.getEntity().getLocation(), null); 27 | if (flag == null) return; 28 | if (e.getFoodLevel() >= e.getEntity().getFoodLevel()) return; 29 | e.setCancelled(true); 30 | } 31 | 32 | @EventHandler(ignoreCancelled = true) 33 | public void onPlayerDamage(EntityDamageEvent event) { 34 | if (event.getCause() != DamageCause.STARVATION) return; 35 | if (event.getEntityType() != EntityType.PLAYER) return; 36 | Player player = (Player) event.getEntity(); 37 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 38 | if (flag == null) return; 39 | 40 | event.setCancelled(true); 41 | } 42 | 43 | @Override 44 | public String getName() { 45 | return "NoHunger"; 46 | } 47 | 48 | @Override 49 | public MessageSpecifier getSetMessage(String parameters) { 50 | return new MessageSpecifier(Messages.EnableNoHunger, parameters); 51 | } 52 | 53 | @Override 54 | public MessageSpecifier getUnSetMessage() { 55 | return new MessageSpecifier(Messages.DisableNoHunger); 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoIceForm.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.Material; 9 | import org.bukkit.block.Block; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.block.BlockFormEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoIceForm extends FlagDefinition { 18 | 19 | public FlagDef_NoIceForm(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.HIGHEST) 24 | public void onGrowth(BlockFormEvent event) { 25 | Block block = event.getBlock(); 26 | 27 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 28 | if (flag == null) return; 29 | 30 | Material newBlock = event.getNewState().getType(); 31 | if (newBlock == Material.ICE || newBlock == Material.FROSTED_ICE) { 32 | event.setCancelled(true); 33 | } 34 | } 35 | 36 | @Override 37 | public String getName() { 38 | return "NoIceForm"; 39 | } 40 | 41 | @Override 42 | public MessageSpecifier getSetMessage(String parameters) { 43 | return new MessageSpecifier(Messages.EnableNoIceForm); 44 | } 45 | 46 | @Override 47 | public MessageSpecifier getUnSetMessage() { 48 | return new MessageSpecifier(Messages.DisableNoIceForm); 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoItemDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.event.EventHandler; 9 | import org.bukkit.event.player.PlayerItemDamageEvent; 10 | 11 | import java.util.Arrays; 12 | import java.util.List; 13 | 14 | public class FlagDef_NoItemDamage extends FlagDefinition { 15 | 16 | public FlagDef_NoItemDamage(FlagManager manager, GPFlags plugin) { 17 | super(manager, plugin); 18 | } 19 | 20 | @EventHandler 21 | private void onItemDamage(PlayerItemDamageEvent event) { 22 | Flag flag = this.getFlagInstanceAtLocation(event.getPlayer().getLocation(), null); 23 | if (flag == null) return; 24 | event.setCancelled(true); 25 | } 26 | 27 | @Override 28 | public String getName() { 29 | return "NoItemDamage"; 30 | } 31 | 32 | @Override 33 | public MessageSpecifier getSetMessage(String parameters) { 34 | return new MessageSpecifier(Messages.EnabledNoItemDamage); 35 | } 36 | 37 | @Override 38 | public MessageSpecifier getUnSetMessage() { 39 | return new MessageSpecifier(Messages.DisabledNoItemDamage); 40 | } 41 | 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoItemDrop.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.util.Util; 9 | import me.ryanhamshire.GriefPrevention.Claim; 10 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.event.EventHandler; 13 | import org.bukkit.event.EventPriority; 14 | import org.bukkit.event.player.PlayerDropItemEvent; 15 | 16 | import java.util.Arrays; 17 | import java.util.List; 18 | 19 | public class FlagDef_NoItemDrop extends FlagDefinition { 20 | 21 | public FlagDef_NoItemDrop(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler(priority = EventPriority.LOWEST) 26 | public void onPlayerDropItem(PlayerDropItemEvent event) { 27 | Player player = event.getPlayer(); 28 | 29 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 30 | if (flag == null) return; 31 | 32 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 33 | if (Util.shouldBypass(player, claim, flag)) return; 34 | 35 | event.setCancelled(true); 36 | } 37 | 38 | @Override 39 | public String getName() { 40 | return "NoItemDrop"; 41 | } 42 | 43 | @Override 44 | public MessageSpecifier getSetMessage(String parameters) { 45 | return new MessageSpecifier(Messages.EnableNoItemDrop); 46 | } 47 | 48 | @Override 49 | public MessageSpecifier getUnSetMessage() { 50 | return new MessageSpecifier(Messages.DisableNoItemDrop); 51 | } 52 | 53 | @Override 54 | public List getFlagType() { 55 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT, FlagType.WORLD, FlagType.SERVER); 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoItemPickup.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.util.Util; 9 | import me.ryanhamshire.GriefPrevention.Claim; 10 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.event.EventHandler; 13 | import org.bukkit.event.EventPriority; 14 | import org.bukkit.event.entity.EntityPickupItemEvent; 15 | 16 | import java.util.Arrays; 17 | import java.util.List; 18 | 19 | public class FlagDef_NoItemPickup extends FlagDefinition { 20 | 21 | public FlagDef_NoItemPickup(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler(priority = EventPriority.LOWEST) 26 | public void onPlayerPickupItem(EntityPickupItemEvent event) { 27 | if (event.getEntity() instanceof Player) { 28 | Player player = ((Player) event.getEntity()); 29 | 30 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 31 | if (flag == null) return; 32 | 33 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 34 | if (Util.shouldBypass(player, claim, flag)) return; 35 | 36 | event.setCancelled(true); 37 | } 38 | } 39 | 40 | @Override 41 | public String getName() { 42 | return "NoItemPickup"; 43 | } 44 | 45 | @Override 46 | public MessageSpecifier getSetMessage(String parameters) { 47 | return new MessageSpecifier(Messages.EnableNoItemPickup); 48 | } 49 | 50 | @Override 51 | public MessageSpecifier getUnSetMessage() { 52 | return new MessageSpecifier(Messages.DisableNoItemPickup); 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoLeafDecay.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.block.Block; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.block.LeavesDecayEvent; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_NoLeafDecay extends FlagDefinition { 17 | 18 | public FlagDef_NoLeafDecay(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.LOWEST) 23 | public void onLeafDecay(LeavesDecayEvent event) { 24 | Block block = event.getBlock(); 25 | 26 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 27 | if (flag == null) return; 28 | 29 | event.setCancelled(true); 30 | } 31 | 32 | @Override 33 | public String getName() { 34 | return "NoLeafDecay"; 35 | } 36 | 37 | @Override 38 | public MessageSpecifier getSetMessage(String parameters) { 39 | return new MessageSpecifier(Messages.EnableNoLeafDecay); 40 | } 41 | 42 | @Override 43 | public MessageSpecifier getUnSetMessage() { 44 | return new MessageSpecifier(Messages.DisableNoLeafDecay); 45 | } 46 | 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoLootProtection.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GriefPrevention.events.ProtectDeathDropsEvent; 9 | import org.bukkit.event.EventHandler; 10 | 11 | import java.util.Arrays; 12 | import java.util.List; 13 | 14 | public class FlagDef_NoLootProtection extends FlagDefinition { 15 | 16 | public FlagDef_NoLootProtection(FlagManager manager, GPFlags plugin) { 17 | super(manager, plugin); 18 | } 19 | 20 | @EventHandler 21 | public void onPlayerDeath(ProtectDeathDropsEvent event) { 22 | if (event.getClaim() != null) { 23 | Flag flag = this.getFlagInstanceAtLocation(event.getClaim().getLesserBoundaryCorner(), null); 24 | if (flag == null) return; 25 | 26 | event.setCancelled(true); 27 | } 28 | } 29 | 30 | @Override 31 | public String getName() { 32 | return "NoLootProtection"; 33 | } 34 | 35 | @Override 36 | public MessageSpecifier getSetMessage(String parameters) { 37 | return new MessageSpecifier(Messages.EnableNoLootProtection); 38 | } 39 | 40 | @Override 41 | public MessageSpecifier getUnSetMessage() { 42 | return new MessageSpecifier(Messages.DisableNoLootProtection); 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMapMaking.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GPFlags.util.Util; 6 | import me.ryanhamshire.GriefPrevention.Claim; 7 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 8 | import org.bukkit.Material; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.block.Action; 12 | import org.bukkit.event.player.PlayerInteractEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoMapMaking extends FlagDefinition { 18 | 19 | public FlagDef_NoMapMaking(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler 24 | public void onMapMake(PlayerInteractEvent event) { 25 | // Check if the flag exists 26 | Player player = event.getPlayer(); 27 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 28 | if (flag == null) return; 29 | 30 | // Check if they are trying to make a map 31 | if (event.getAction() == Action.LEFT_CLICK_AIR) return; 32 | if (event.getAction() == Action.LEFT_CLICK_BLOCK) return; 33 | if (event.getMaterial() != Material.MAP) return; 34 | 35 | // Check if they should bypass 36 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 37 | if (Util.shouldBypass(player, claim, flag)) return; 38 | 39 | MessagingUtil.sendMessage(player, TextMode.Err, Messages.MapMakingDisabled); 40 | event.setCancelled(true); 41 | 42 | } 43 | 44 | @Override 45 | public String getName() { 46 | return "NoMapMaking"; 47 | } 48 | 49 | @Override 50 | public MessageSpecifier getSetMessage(String parameters) { 51 | return new MessageSpecifier(Messages.EnableNoMapMaking); 52 | } 53 | 54 | @Override 55 | public MessageSpecifier getUnSetMessage() { 56 | return new MessageSpecifier(Messages.DisableNoMapMaking); 57 | } 58 | 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMcMMODeathPenalty.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import com.gmail.nossr50.events.hardcore.McMMOPlayerDeathPenaltyEvent; 4 | import me.ryanhamshire.GPFlags.Flag; 5 | import me.ryanhamshire.GPFlags.FlagManager; 6 | import me.ryanhamshire.GPFlags.GPFlags; 7 | import me.ryanhamshire.GPFlags.MessageSpecifier; 8 | import me.ryanhamshire.GPFlags.Messages; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | 13 | import java.util.Arrays; 14 | import java.util.List; 15 | 16 | public class FlagDef_NoMcMMODeathPenalty extends FlagDefinition { 17 | 18 | public FlagDef_NoMcMMODeathPenalty(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) 23 | public void onPlayerDisarm(McMMOPlayerDeathPenaltyEvent event) { 24 | Player player = event.getPlayer(); 25 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 26 | if (flag != null) { 27 | event.setCancelled(true); 28 | } 29 | } 30 | 31 | @Override 32 | public String getName() { 33 | return "NoMcMMODeathPenalty"; 34 | } 35 | 36 | @Override 37 | public MessageSpecifier getSetMessage(String parameters) { 38 | return new MessageSpecifier(Messages.EnableNoMcMMODeathPenalty); 39 | } 40 | 41 | @Override 42 | public MessageSpecifier getUnSetMessage() { 43 | return new MessageSpecifier(Messages.DisableNoMcMMODeathPenalty); 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMcMMOSkills.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import com.gmail.nossr50.events.skills.abilities.McMMOPlayerAbilityActivateEvent; 4 | import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillEvent; 5 | import com.gmail.nossr50.events.skills.unarmed.McMMOPlayerDisarmEvent; 6 | import me.ryanhamshire.GPFlags.Flag; 7 | import me.ryanhamshire.GPFlags.FlagManager; 8 | import me.ryanhamshire.GPFlags.GPFlags; 9 | import me.ryanhamshire.GPFlags.MessageSpecifier; 10 | import me.ryanhamshire.GPFlags.Messages; 11 | import me.ryanhamshire.GPFlags.util.Util; 12 | import me.ryanhamshire.GriefPrevention.Claim; 13 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 14 | import org.bukkit.entity.Player; 15 | import org.bukkit.event.Cancellable; 16 | import org.bukkit.event.EventHandler; 17 | import org.bukkit.event.EventPriority; 18 | 19 | import java.util.Arrays; 20 | import java.util.List; 21 | 22 | public class FlagDef_NoMcMMOSkills extends FlagDefinition { 23 | 24 | public FlagDef_NoMcMMOSkills(FlagManager manager, GPFlags plugin) { 25 | super(manager, plugin); 26 | } 27 | 28 | @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) 29 | public void onPlayerDisarm(McMMOPlayerDisarmEvent event) { 30 | this.handleEvent(event.getPlayer(), event); 31 | } 32 | 33 | @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) 34 | public void onPlayerAbility(McMMOPlayerAbilityActivateEvent event) { 35 | this.handleEvent(event.getPlayer(), event); 36 | } 37 | 38 | @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) 39 | public void onPlayerSecondaryAbility(SubSkillEvent event) { 40 | this.handleEvent(event.getPlayer(), event); 41 | } 42 | 43 | private void handleEvent(Player player, Cancellable event) { 44 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 45 | if (flag == null) return; 46 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 47 | if (Util.shouldBypass(player, claim, flag)) return; 48 | 49 | event.setCancelled(true); 50 | } 51 | 52 | @Override 53 | public String getName() { 54 | return "NoMcMMOSkills"; 55 | } 56 | 57 | @Override 58 | public MessageSpecifier getSetMessage(String parameters) { 59 | return new MessageSpecifier(Messages.EnableNoMcMMOSkills); 60 | } 61 | 62 | @Override 63 | public MessageSpecifier getUnSetMessage() { 64 | return new MessageSpecifier(Messages.DisableNoMcMMOSkills); 65 | } 66 | 67 | } 68 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMcMMOXP.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import com.gmail.nossr50.events.experience.McMMOPlayerXpGainEvent; 4 | import me.ryanhamshire.GPFlags.Flag; 5 | import me.ryanhamshire.GPFlags.FlagManager; 6 | import me.ryanhamshire.GPFlags.GPFlags; 7 | import me.ryanhamshire.GPFlags.MessageSpecifier; 8 | import me.ryanhamshire.GPFlags.Messages; 9 | import me.ryanhamshire.GPFlags.util.Util; 10 | import me.ryanhamshire.GriefPrevention.Claim; 11 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.Cancellable; 14 | import org.bukkit.event.EventHandler; 15 | import org.bukkit.event.EventPriority; 16 | 17 | import java.util.Arrays; 18 | import java.util.List; 19 | 20 | public class FlagDef_NoMcMMOXP extends FlagDefinition { 21 | 22 | public FlagDef_NoMcMMOXP(FlagManager manager, GPFlags plugin) { 23 | super(manager, plugin); 24 | } 25 | 26 | @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) 27 | public void onPlayerGainXP(McMMOPlayerXpGainEvent event) { 28 | this.handleEvent(event.getPlayer(), event); 29 | } 30 | 31 | private void handleEvent(Player player, Cancellable event) { 32 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 33 | if (flag == null) return; 34 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(player.getLocation(), false, null); 35 | if (Util.shouldBypass(player, claim, flag)) return; 36 | 37 | event.setCancelled(true); 38 | } 39 | 40 | @Override 41 | public String getName() { 42 | return "NoMcMMOXPGain"; 43 | } 44 | 45 | @Override 46 | public MessageSpecifier getSetMessage(String parameters) { 47 | return new MessageSpecifier(Messages.EnabledNoMcMMOXP); 48 | } 49 | 50 | @Override 51 | public MessageSpecifier getUnSetMessage() { 52 | return new MessageSpecifier(Messages.DisabledNoMcMMOXP); 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMobDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.*; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.EventPriority; 11 | import org.bukkit.event.entity.EntityDamageByEntityEvent; 12 | import org.bukkit.event.entity.EntityDamageEvent; 13 | import org.bukkit.event.entity.EntityDamageEvent.DamageCause; 14 | import org.bukkit.projectiles.ProjectileSource; 15 | 16 | import java.util.Arrays; 17 | import java.util.List; 18 | 19 | public class FlagDef_NoMobDamage extends FlagDefinition { 20 | 21 | public FlagDef_NoMobDamage(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler(priority = EventPriority.HIGHEST) 26 | public void onEntityDamage(EntityDamageEvent event) { 27 | // check flag 28 | Entity entity = event.getEntity(); 29 | Flag flag = this.getFlagInstanceAtLocation(entity.getLocation(), null); 30 | if (flag == null) return; 31 | 32 | // fix for GP discussion https://github.com/TechFortress/GriefPrevention/issues/1481 33 | DamageCause cause = event.getCause(); 34 | if (event.getDamage() == 0 && cause == DamageCause.CUSTOM) return; 35 | 36 | // Always allow cramming damage 37 | if (cause == DamageCause.CRAMMING) return; 38 | 39 | // Always allow attacks to players 40 | if (entity instanceof Player) return; 41 | 42 | // Always allow attacks from players 43 | if (event instanceof EntityDamageByEntityEvent) { 44 | EntityDamageByEntityEvent event2 = (EntityDamageByEntityEvent) event; 45 | Entity attacker = event2.getDamager(); 46 | if (attacker.getType() == EntityType.PLAYER) return; 47 | if (attacker instanceof Projectile) { 48 | ProjectileSource source = ((Projectile) attacker).getShooter(); 49 | if (source instanceof Player) return; 50 | } 51 | } 52 | 53 | if (entity instanceof LivingEntity) { 54 | event.setCancelled(true); 55 | } 56 | } 57 | 58 | @Override 59 | public String getName() { 60 | return "NoMobDamage"; 61 | } 62 | 63 | @Override 64 | public MessageSpecifier getSetMessage(String parameters) { 65 | return new MessageSpecifier(Messages.DisableMobDamage); 66 | } 67 | 68 | @Override 69 | public MessageSpecifier getUnSetMessage() { 70 | return new MessageSpecifier(Messages.EnableMobDamage); 71 | } 72 | 73 | } 74 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMobSpawns.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.EventPriority; 8 | import org.bukkit.event.entity.CreatureSpawnEvent; 9 | import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason; 10 | 11 | public class FlagDef_NoMobSpawns extends FlagDefinition { 12 | 13 | public FlagDef_NoMobSpawns(FlagManager manager, GPFlags plugin) { 14 | super(manager, plugin); 15 | } 16 | 17 | @EventHandler(priority = EventPriority.LOWEST) 18 | public void onEntitySpawn(CreatureSpawnEvent event) { 19 | EntityType type = event.getEntityType(); 20 | if (type == EntityType.PLAYER || type == EntityType.ARMOR_STAND) return; 21 | 22 | SpawnReason reason = event.getSpawnReason(); 23 | if (reason == SpawnReason.SLIME_SPLIT) return; 24 | WorldSettings settings = this.settingsManager.get(event.getEntity().getWorld()); 25 | if (settings.noMonsterSpawnIgnoreSpawners && Util.isSpawnerReason(reason)) return; 26 | 27 | Flag flag = this.getFlagInstanceAtLocation(event.getLocation(), null); 28 | if (flag == null) return; 29 | 30 | event.setCancelled(true); 31 | } 32 | 33 | @Override 34 | public String getName() { 35 | return "NoMobSpawns"; 36 | } 37 | 38 | @Override 39 | public MessageSpecifier getSetMessage(String parameters) { 40 | return new MessageSpecifier(Messages.DisableMobSpawns); 41 | } 42 | 43 | @Override 44 | public MessageSpecifier getUnSetMessage() { 45 | return new MessageSpecifier(Messages.EnableMobSpawns); 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoMonsterSpawns.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.WorldSettings; 9 | import me.ryanhamshire.GPFlags.util.Util; 10 | import org.bukkit.entity.LivingEntity; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.EventPriority; 13 | import org.bukkit.event.entity.CreatureSpawnEvent; 14 | import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason; 15 | 16 | public class FlagDef_NoMonsterSpawns extends FlagDefinition { 17 | 18 | public FlagDef_NoMonsterSpawns(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true) 23 | public void onEntitySpawn(CreatureSpawnEvent event) { 24 | Flag flag = this.getFlagInstanceAtLocation(event.getLocation(), null); 25 | if (flag == null) return; 26 | 27 | LivingEntity entity = event.getEntity(); 28 | if (!Util.isMonster(entity)) return; 29 | 30 | SpawnReason reason = event.getSpawnReason(); 31 | if (reason == SpawnReason.SLIME_SPLIT) return; 32 | 33 | WorldSettings settings = this.settingsManager.get(event.getEntity().getWorld()); 34 | if (settings.noMonsterSpawnIgnoreSpawners && Util.isSpawnerReason(reason)) return; 35 | 36 | event.setCancelled(true); 37 | } 38 | 39 | @Override 40 | public String getName() { 41 | return "NoMonsterSpawns"; 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getSetMessage(String parameters) { 46 | return new MessageSpecifier(Messages.DisableMonsterSpawns); 47 | } 48 | 49 | @Override 50 | public MessageSpecifier getUnSetMessage() { 51 | return new MessageSpecifier(Messages.EnableMonsterSpawns); 52 | } 53 | 54 | } 55 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoPetDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.Entity; 9 | import org.bukkit.entity.Tameable; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.entity.EntityDamageEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoPetDamage extends FlagDefinition { 18 | 19 | public FlagDef_NoPetDamage(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) 24 | public void onEntityDamage(EntityDamageEvent event) { 25 | Entity entity = event.getEntity(); 26 | if (!(entity instanceof Tameable)) return; 27 | 28 | Tameable tameable = (Tameable) entity; 29 | if (!tameable.isTamed() || tameable.getOwner() == null) return; 30 | 31 | Flag flag = this.getFlagInstanceAtLocation(entity.getLocation(), null); 32 | if (flag != null) { 33 | event.setCancelled(true); 34 | } 35 | } 36 | 37 | @Override 38 | public String getName() { 39 | return "NoPetDamage"; 40 | } 41 | 42 | @Override 43 | public MessageSpecifier getSetMessage(String parameters) { 44 | return new MessageSpecifier(Messages.EnableNoPetDamage); 45 | } 46 | 47 | @Override 48 | public MessageSpecifier getUnSetMessage() { 49 | return new MessageSpecifier(Messages.DisableNoPetDamage); 50 | } 51 | 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoPlayerDamage.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.entity.EntityType; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.entity.EntityDamageEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoPlayerDamage extends FlagDefinition { 18 | 19 | public FlagDef_NoPlayerDamage(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.LOWEST) 24 | public void onPlayerDamage(EntityDamageEvent event) { 25 | if (event.getEntityType() != EntityType.PLAYER) return; 26 | 27 | Player player = (Player) event.getEntity(); 28 | 29 | Flag flag = this.getFlagInstanceAtLocation(player.getLocation(), player); 30 | if (flag == null) return; 31 | 32 | event.setCancelled(true); 33 | } 34 | 35 | @Override 36 | public String getName() { 37 | return "NoPlayerDamage"; 38 | } 39 | 40 | @Override 41 | public MessageSpecifier getSetMessage(String parameters) { 42 | return new MessageSpecifier(Messages.EnableNoPlayerDamage); 43 | } 44 | 45 | @Override 46 | public MessageSpecifier getUnSetMessage() { 47 | return new MessageSpecifier(Messages.DisableNoPlayerDamage); 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoSnowForm.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.Material; 9 | import org.bukkit.block.Block; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.block.BlockFormEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoSnowForm extends FlagDefinition { 18 | 19 | public FlagDef_NoSnowForm(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.HIGHEST) 24 | public void onGrowth(BlockFormEvent event) { 25 | Block block = event.getBlock(); 26 | 27 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 28 | if (flag == null) return; 29 | 30 | if (event.getNewState().getType() != Material.SNOW) return; 31 | event.setCancelled(true); 32 | } 33 | 34 | @Override 35 | public String getName() { 36 | return "NoSnowForm"; 37 | } 38 | 39 | @Override 40 | public MessageSpecifier getSetMessage(String parameters) { 41 | return new MessageSpecifier(Messages.EnableNoSnowForm); 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getUnSetMessage() { 46 | return new MessageSpecifier(Messages.DisableNoSnowForm); 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoStructureGrowth.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.event.EventHandler; 5 | import org.bukkit.event.world.StructureGrowEvent; 6 | 7 | import java.util.Arrays; 8 | import java.util.List; 9 | 10 | public class FlagDef_NoStructureGrowth extends FlagDefinition { 11 | 12 | public FlagDef_NoStructureGrowth(FlagManager manager, GPFlags plugin) { 13 | super(manager, plugin); 14 | } 15 | 16 | @EventHandler 17 | public void onGrowth(StructureGrowEvent event) { 18 | 19 | Flag flag = this.getFlagInstanceAtLocation(event.getLocation(), null); 20 | if (flag == null) return; 21 | 22 | event.setCancelled(true); 23 | } 24 | 25 | @Override 26 | public String getName() { 27 | return "NoStructureGrowth"; 28 | } 29 | 30 | @Override 31 | public MessageSpecifier getSetMessage(String parameters) { 32 | return new MessageSpecifier(Messages.EnableNoGrowth); 33 | } 34 | 35 | @Override 36 | public MessageSpecifier getUnSetMessage() { 37 | return new MessageSpecifier(Messages.DisableNoStructureGrowth); 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoVineGrowth.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.Material; 9 | import org.bukkit.block.Block; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.block.BlockSpreadEvent; 13 | 14 | import java.util.Arrays; 15 | import java.util.List; 16 | 17 | public class FlagDef_NoVineGrowth extends FlagDefinition { 18 | 19 | public FlagDef_NoVineGrowth(FlagManager manager, GPFlags plugin) { 20 | super(manager, plugin); 21 | } 22 | 23 | @EventHandler(priority = EventPriority.HIGHEST) 24 | public void onGrowth(BlockSpreadEvent event) { 25 | Block block = event.getBlock(); 26 | 27 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 28 | if (flag == null) return; 29 | 30 | Material newType = event.getSource().getType(); 31 | if (newType == Material.VINE || newType == Material.GLOW_LICHEN || newType == Material.WEEPING_VINES || newType == Material.TWISTING_VINES || newType == Material.CAVE_VINES || newType == Material.CAVE_VINES_PLANT) { 32 | event.setCancelled(true); 33 | } 34 | } 35 | 36 | @Override 37 | public String getName() { 38 | return "NoVineGrowth"; 39 | } 40 | 41 | @Override 42 | public MessageSpecifier getSetMessage(String parameters) { 43 | return new MessageSpecifier(Messages.EnableNoVineGrowth); 44 | } 45 | 46 | @Override 47 | public MessageSpecifier getUnSetMessage() { 48 | return new MessageSpecifier(Messages.DisableNoVineGrowth); 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NoWeatherChange.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import org.bukkit.World; 9 | import org.bukkit.event.Cancellable; 10 | import org.bukkit.event.EventHandler; 11 | import org.bukkit.event.EventPriority; 12 | import org.bukkit.event.weather.ThunderChangeEvent; 13 | import org.bukkit.event.weather.WeatherChangeEvent; 14 | 15 | import java.util.Arrays; 16 | import java.util.List; 17 | 18 | public class FlagDef_NoWeatherChange extends FlagDefinition { 19 | 20 | public FlagDef_NoWeatherChange(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @EventHandler(priority = EventPriority.HIGHEST) 25 | public void onWeatherChange(WeatherChangeEvent event) { 26 | this.handleEvent(event.getWorld(), event); 27 | } 28 | 29 | @EventHandler(priority = EventPriority.HIGHEST) 30 | public void onWeatherChange(ThunderChangeEvent event) { 31 | this.handleEvent(event.getWorld(), event); 32 | } 33 | 34 | private void handleEvent(World world, Cancellable event) { 35 | Flag flag = this.getFlagInstanceAtLocation(world.getSpawnLocation(), null); 36 | if (flag == null) return; 37 | 38 | event.setCancelled(true); 39 | } 40 | 41 | @Override 42 | public String getName() { 43 | return "NoWeatherChange"; 44 | } 45 | 46 | @Override 47 | public MessageSpecifier getSetMessage(String parameters) { 48 | return new MessageSpecifier(Messages.EnableNoWeatherChange); 49 | } 50 | 51 | @Override 52 | public MessageSpecifier getUnSetMessage() { 53 | return new MessageSpecifier(Messages.DisableNoWeatherChange); 54 | } 55 | 56 | @Override 57 | public List getFlagType() { 58 | return Arrays.asList(FlagType.WORLD, FlagType.SERVER); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NotifyEnter.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 7 | import me.ryanhamshire.GriefPrevention.PlayerData; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.GameMode; 10 | import org.bukkit.Location; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.EventHandler; 14 | import org.bukkit.event.player.PlayerJoinEvent; 15 | import org.jetbrains.annotations.NotNull; 16 | import org.jetbrains.annotations.Nullable; 17 | 18 | import java.util.UUID; 19 | 20 | public class FlagDef_NotifyEnter extends PlayerMovementFlagDefinition { 21 | 22 | public FlagDef_NotifyEnter(FlagManager manager, GPFlags plugin) { 23 | super(manager, plugin); 24 | } 25 | 26 | @Override 27 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 28 | if (flagTo == null) return; 29 | 30 | if (shouldNotify(player, claimTo)) { 31 | notifyEntry(flagTo, claimTo, player); 32 | } 33 | } 34 | 35 | public boolean shouldNotify(@NotNull Player p, @Nullable Claim c) { 36 | if (c == null) return false; 37 | UUID ownerID = c.getOwnerID(); 38 | if (ownerID == null) return false; 39 | Player owner = Bukkit.getPlayer(ownerID); 40 | if (owner == null) return false; 41 | if (owner.getName().equals(p.getName())) return false; 42 | if (!owner.canSee(p)) return false; 43 | if (p.getGameMode() == GameMode.SPECTATOR) return false; 44 | if (p.hasPermission("gpflags.bypass.notifyenter")) return false; 45 | return true; 46 | } 47 | 48 | public void notifyEntry(@NotNull Flag flag, @NotNull Claim claim, @NotNull Player player) { 49 | UUID uuid = claim.getOwnerID(); 50 | if (uuid == null) return; 51 | Player owner = Bukkit.getPlayer(uuid); 52 | if (owner == null) return; 53 | if (owner.getName().equals(player.getName())) return; 54 | String param = flag.parameters; 55 | if (param == null || param.isEmpty()) { 56 | param = "claim " + claim.getID(); 57 | } 58 | MessagingUtil.sendMessage(owner, TextMode.Info, Messages.NotifyEnter, player.getName(), param); 59 | 60 | } 61 | 62 | @Override 63 | public String getName() { 64 | return "NotifyEnter"; 65 | } 66 | 67 | @Override 68 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 69 | return new SetFlagResult(true, this.getSetMessage(parameters)); 70 | } 71 | 72 | @Override 73 | public MessageSpecifier getSetMessage(String parameters) { 74 | return new MessageSpecifier(Messages.EnableNotifyEnter, parameters); 75 | } 76 | 77 | @Override 78 | public MessageSpecifier getUnSetMessage() { 79 | return new MessageSpecifier(Messages.DisableNotifyEnter); 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_NotifyExit.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.GameMode; 8 | import org.bukkit.Location; 9 | import org.bukkit.command.CommandSender; 10 | import org.bukkit.entity.Player; 11 | import org.jetbrains.annotations.NotNull; 12 | import org.jetbrains.annotations.Nullable; 13 | 14 | import java.util.UUID; 15 | 16 | public class FlagDef_NotifyExit extends PlayerMovementFlagDefinition { 17 | 18 | public FlagDef_NotifyExit(FlagManager manager, GPFlags plugin) { 19 | super(manager, plugin); 20 | } 21 | 22 | @Override 23 | public void onChangeClaim(Player player, Location lastLocation, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 24 | if (flagFrom == null) return; 25 | 26 | if (shouldNotify(player, claimFrom)) { 27 | notifyExit(flagFrom, claimFrom, player); 28 | } 29 | } 30 | 31 | public boolean shouldNotify(@NotNull Player p, @Nullable Claim c) { 32 | if (c == null) return false; 33 | UUID ownerID = c.getOwnerID(); 34 | if (ownerID == null) return false; 35 | Player owner = Bukkit.getPlayer(ownerID); 36 | if (owner == null) return false; 37 | if (owner.getName().equals(p.getName())) return false; 38 | if (!owner.canSee(p)) return false; 39 | if (p.getGameMode() == GameMode.SPECTATOR) return false; 40 | if (p.hasPermission("gpflags.bypass.notifyexit")) return false; 41 | return true; 42 | } 43 | 44 | public void notifyExit(@NotNull Flag flag, @NotNull Claim claim, @NotNull Player player) { 45 | UUID uuid = claim.getOwnerID(); 46 | if (uuid == null) return; 47 | Player owner = Bukkit.getPlayer(uuid); 48 | if (owner == null) return; 49 | if (owner.getName().equals(player.getName())) return; 50 | String param = flag.parameters; 51 | if (param == null || param.isEmpty()) { 52 | param = "claim " + claim.getID(); 53 | } 54 | MessagingUtil.sendMessage(owner, TextMode.Info, Messages.NotifyExit, player.getName(), param); 55 | 56 | } 57 | 58 | 59 | @Override 60 | public String getName() { 61 | return "NotifyExit"; 62 | } 63 | 64 | @Override 65 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 66 | return new SetFlagResult(true, this.getSetMessage(parameters)); 67 | } 68 | 69 | @Override 70 | public MessageSpecifier getSetMessage(String parameters) { 71 | return new MessageSpecifier(Messages.EnableNotifyExit, parameters); 72 | } 73 | 74 | @Override 75 | public MessageSpecifier getUnSetMessage() { 76 | return new MessageSpecifier(Messages.DisableNotifyExit); 77 | } 78 | 79 | } 80 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_OwnerFly.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.Location; 8 | import org.bukkit.entity.Player; 9 | 10 | import java.util.Arrays; 11 | import java.util.List; 12 | import java.util.UUID; 13 | 14 | public class FlagDef_OwnerFly extends FlagDefinition { 15 | 16 | public FlagDef_OwnerFly(FlagManager manager, GPFlags plugin) { 17 | super(manager, plugin); 18 | } 19 | 20 | @Override 21 | public void onFlagSet(Claim claim, String param) { 22 | UUID uuid = claim.getOwnerID(); 23 | if (uuid == null) return; 24 | Player owner = Bukkit.getPlayer(uuid); 25 | if (owner == null) return; 26 | Location location = owner.getLocation(); 27 | if (!claim.contains(location, false, false)) return; 28 | FlightManager.managePlayerFlight(owner, null, location); 29 | } 30 | 31 | @Override 32 | public void onFlagUnset(Claim claim) { 33 | UUID uuid = claim.getOwnerID(); 34 | if (uuid == null) return; 35 | Player owner = Bukkit.getPlayer(uuid); 36 | if (owner == null) { 37 | return; 38 | }; 39 | Location location = owner.getLocation(); 40 | if (!claim.contains(location, false, false)) { 41 | return; 42 | } 43 | FlightManager.manageFlightLater(owner, 1, owner.getLocation()); 44 | } 45 | 46 | public static boolean letPlayerFly(Player player, Location location, Claim claim) { 47 | if (claim == null) return false; 48 | Flag flag = GPFlags.getInstance().getFlagManager().getEffectiveFlag(location, "OwnerFly", claim); 49 | if (flag == null) return false; 50 | return (player.getUniqueId().equals(claim.getOwnerID())); 51 | } 52 | 53 | @Override 54 | public String getName() { 55 | return "OwnerFly"; 56 | } 57 | 58 | @Override 59 | public MessageSpecifier getSetMessage(String parameters) { 60 | return new MessageSpecifier(Messages.OwnerFlightEnabled); 61 | } 62 | 63 | @Override 64 | public MessageSpecifier getUnSetMessage() { 65 | return new MessageSpecifier(Messages.OwnerFlightDisabled); 66 | } 67 | 68 | @Override 69 | public List getFlagType() { 70 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT); 71 | } 72 | 73 | } 74 | 75 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_OwnerMemberFly.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import org.bukkit.Location; 7 | import org.bukkit.entity.Player; 8 | 9 | import java.util.Arrays; 10 | import java.util.List; 11 | 12 | public class FlagDef_OwnerMemberFly extends FlagDefinition { 13 | 14 | public FlagDef_OwnerMemberFly(FlagManager manager, GPFlags plugin) { 15 | super(manager, plugin); 16 | } 17 | 18 | @Override 19 | public void onFlagSet(Claim claim, String param) { 20 | for (Player p : Util.getPlayersIn(claim)) { 21 | FlightManager.managePlayerFlight(p, null, p.getLocation()); 22 | } 23 | } 24 | 25 | @Override 26 | public void onFlagUnset(Claim claim) { 27 | for (Player p : Util.getPlayersIn(claim)) { 28 | FlightManager.manageFlightLater(p, 1, p.getLocation()); 29 | } 30 | } 31 | 32 | public static boolean letPlayerFly(Player player, Location location, Claim claim) { 33 | if (claim == null) return false; 34 | Flag flag = GPFlags.getInstance().getFlagManager().getEffectiveFlag(location, "OwnerMemberFly", claim); 35 | if (flag == null) return false; 36 | if (!flag.getSet()) return false; 37 | return Util.canAccess(claim, player); 38 | } 39 | 40 | 41 | @Override 42 | public String getName() { 43 | return "OwnerMemberFly"; 44 | } 45 | 46 | @Override 47 | public MessageSpecifier getSetMessage(String parameters) { 48 | return new MessageSpecifier(Messages.OwnerMemberFlightEnabled); 49 | } 50 | 51 | @Override 52 | public MessageSpecifier getUnSetMessage() { 53 | return new MessageSpecifier(Messages.OwnerMemberFlightDisabled); 54 | } 55 | 56 | @Override 57 | public List getFlagType() { 58 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT); 59 | } 60 | 61 | } 62 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_PermissionFly.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import org.bukkit.Location; 7 | import org.bukkit.entity.Player; 8 | 9 | import java.util.Arrays; 10 | import java.util.List; 11 | 12 | 13 | public class FlagDef_PermissionFly extends FlagDefinition { 14 | 15 | public FlagDef_PermissionFly(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @Override 20 | public void onFlagSet(Claim claim, String param) { 21 | for (Player p : Util.getPlayersIn(claim)) { 22 | FlightManager.managePlayerFlight(p, null, p.getLocation()); 23 | } 24 | } 25 | 26 | @Override 27 | public void onFlagUnset(Claim claim) { 28 | for (Player p : Util.getPlayersIn(claim)) { 29 | FlightManager.manageFlightLater(p, 1, p.getLocation()); 30 | } 31 | } 32 | 33 | public static boolean letPlayerFly(Player player, Location location, Claim claim) { 34 | Flag flag = GPFlags.getInstance().getFlagManager().getEffectiveFlag(location, "PermissionFly", claim); 35 | if (flag == null) return false; 36 | return Util.shouldBypass(player, claim, flag); 37 | } 38 | 39 | @Override 40 | public String getName() { 41 | return "PermissionFly"; 42 | } 43 | 44 | @Override 45 | public MessageSpecifier getSetMessage(String parameters) { 46 | return new MessageSpecifier(Messages.PermissionFlightEnabled); 47 | } 48 | 49 | @Override 50 | public MessageSpecifier getUnSetMessage() { 51 | return new MessageSpecifier(Messages.PermissionFlightDisabled); 52 | } 53 | 54 | } 55 | 56 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_PlayerTime.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GriefPrevention.Claim; 10 | import org.bukkit.Location; 11 | import org.bukkit.command.CommandSender; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.EventHandler; 14 | import org.bukkit.event.Listener; 15 | import org.bukkit.event.entity.PlayerDeathEvent; 16 | import org.bukkit.event.player.PlayerJoinEvent; 17 | import org.jetbrains.annotations.NotNull; 18 | import org.jetbrains.annotations.Nullable; 19 | 20 | public class FlagDef_PlayerTime extends PlayerMovementFlagDefinition implements Listener { 21 | 22 | public FlagDef_PlayerTime(FlagManager manager, GPFlags plugin) { 23 | super(manager, plugin); 24 | } 25 | 26 | @Override 27 | public void onChangeClaim(Player player, Location from, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 28 | // Reset the time if moving from enabled to disabled 29 | if (flagTo == null && flagFrom != null) { 30 | player.resetPlayerTime(); 31 | return; 32 | } 33 | 34 | // Set time to new flag if exists 35 | if (flagTo == null) return; 36 | setPlayerTime(player, flagTo); 37 | } 38 | 39 | public void setPlayerTime(Player player, @NotNull Flag flag) { 40 | String time = flag.parameters; 41 | if (time.equalsIgnoreCase("day")) { 42 | player.setPlayerTime(0, false); 43 | } else if (time.equalsIgnoreCase("noon")) { 44 | player.setPlayerTime(6000, false); 45 | } else if (time.equalsIgnoreCase("night")) { 46 | player.setPlayerTime(12566, false); 47 | } else if (time.equalsIgnoreCase("midnight")) { 48 | player.setPlayerTime(18000, false); 49 | } 50 | } 51 | 52 | @Override 53 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 54 | if (parameters.isEmpty()) { 55 | return new SetFlagResult(false, new MessageSpecifier(Messages.PlayerTimeRequired)); 56 | } 57 | if (!parameters.equalsIgnoreCase("day") && !parameters.equalsIgnoreCase("noon") && 58 | !parameters.equalsIgnoreCase("night") && !parameters.equalsIgnoreCase("midnight")) { 59 | return new SetFlagResult(false, new MessageSpecifier(Messages.PlayerTimeRequired)); 60 | } 61 | return new SetFlagResult(true, this.getSetMessage(parameters)); 62 | } 63 | 64 | @Override 65 | public String getName() { 66 | return "PlayerTime"; 67 | } 68 | 69 | @Override 70 | public MessageSpecifier getSetMessage(String parameters) { 71 | return new MessageSpecifier(Messages.PlayerTimeSet, parameters); 72 | } 73 | 74 | @Override 75 | public MessageSpecifier getUnSetMessage() { 76 | return new MessageSpecifier(Messages.PlayerTimeUnSet); 77 | } 78 | 79 | } 80 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_PlayerWeather.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GriefPrevention.Claim; 10 | import org.bukkit.Location; 11 | import org.bukkit.WeatherType; 12 | import org.bukkit.command.CommandSender; 13 | import org.bukkit.entity.Player; 14 | import org.bukkit.event.Listener; 15 | import org.jetbrains.annotations.NotNull; 16 | import org.jetbrains.annotations.Nullable; 17 | 18 | public class FlagDef_PlayerWeather extends PlayerMovementFlagDefinition implements Listener { 19 | 20 | public FlagDef_PlayerWeather(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @Override 25 | public void onChangeClaim(Player player, Location from, Location to, Claim claimFrom, Claim claimTo, @Nullable Flag flagFrom, @Nullable Flag flagTo) { 26 | // Reset the weather if moving from enabled to disabled 27 | if (flagTo == null && flagFrom != null) { 28 | player.resetPlayerWeather(); 29 | return; 30 | } 31 | 32 | // Set weather to new flag if exists 33 | if (flagTo == null) return; 34 | setPlayerWeather(player, flagTo); 35 | } 36 | 37 | public void setPlayerWeather(Player player, @NotNull Flag flag) { 38 | String weather = flag.parameters; 39 | if (weather.equalsIgnoreCase("sun")) { 40 | player.setPlayerWeather(WeatherType.CLEAR); 41 | } else if (weather.equalsIgnoreCase("rain")) { 42 | player.setPlayerWeather(WeatherType.DOWNFALL); 43 | } 44 | } 45 | 46 | @Override 47 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 48 | if (parameters.isEmpty()) { 49 | return new SetFlagResult(false, new MessageSpecifier(Messages.PlayerWeatherRequired)); 50 | } 51 | if (!parameters.equalsIgnoreCase("sun") && !parameters.equalsIgnoreCase("rain")) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.PlayerWeatherRequired)); 53 | } 54 | return new SetFlagResult(true, this.getSetMessage(parameters)); 55 | } 56 | 57 | @Override 58 | public String getName() { 59 | return "PlayerWeather"; 60 | } 61 | 62 | @Override 63 | public MessageSpecifier getSetMessage(String parameters) { 64 | return new MessageSpecifier(Messages.PlayerWeatherSet, parameters); 65 | } 66 | 67 | @Override 68 | public MessageSpecifier getUnSetMessage() { 69 | return new MessageSpecifier(Messages.PlayerWeatherUnSet); 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_ProtectNamedMobs.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.hooks.MythicMobsHook; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.ClaimPermission; 7 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 8 | import org.bukkit.entity.Entity; 9 | import org.bukkit.entity.EntityType; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.EventPriority; 13 | import org.bukkit.event.entity.EntityDamageByEntityEvent; 14 | 15 | import java.util.Arrays; 16 | import java.util.List; 17 | 18 | public class FlagDef_ProtectNamedMobs extends FlagDefinition { 19 | 20 | public FlagDef_ProtectNamedMobs(FlagManager manager, GPFlags plugin) { 21 | super(manager, plugin); 22 | } 23 | 24 | @EventHandler(priority = EventPriority.LOWEST) 25 | public void onEntityDamage(EntityDamageByEntityEvent event) { 26 | Entity entity = event.getEntity(); 27 | 28 | Flag flag = this.getFlagInstanceAtLocation(entity.getLocation(), null); 29 | if (flag == null) return; 30 | if (entity.getCustomName() == null) return; 31 | 32 | EntityType eType = entity.getType(); 33 | if (eType == EntityType.PLAYER) return; 34 | if (eType == EntityType.ARMOR_STAND) return; 35 | if (eType == EntityType.ITEM_FRAME) return; 36 | if (eType == EntityType.GLOW_ITEM_FRAME) return; 37 | if (MythicMobsHook.isMythicMob(entity)) return; 38 | 39 | Entity damager = event.getDamager(); 40 | if (damager.getType() != EntityType.PLAYER) { 41 | event.setCancelled(true); 42 | return; 43 | } 44 | 45 | Player player = (Player) damager; 46 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(entity.getLocation(), false, null); 47 | if (claim != null && claim.getPermission(player.getUniqueId().toString()) == ClaimPermission.Inventory) return; 48 | event.setCancelled(true); 49 | } 50 | 51 | @Override 52 | public String getName() { 53 | return "ProtectNamedMobs"; 54 | } 55 | 56 | @Override 57 | public MessageSpecifier getSetMessage(String parameters) { 58 | return new MessageSpecifier(Messages.EnabledProtectNamedMobs); 59 | } 60 | 61 | @Override 62 | public MessageSpecifier getUnSetMessage() { 63 | return new MessageSpecifier(Messages.DisabledProtectNamedMobs); 64 | } 65 | 66 | @Override 67 | public List getFlagType() { 68 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT); 69 | } 70 | 71 | } 72 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_RaidMemberOnly.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.TextMode; 9 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 10 | import me.ryanhamshire.GPFlags.util.Util; 11 | import me.ryanhamshire.GriefPrevention.Claim; 12 | import me.ryanhamshire.GriefPrevention.GriefPrevention; 13 | import org.bukkit.entity.Player; 14 | import org.bukkit.event.EventHandler; 15 | import org.bukkit.event.raid.RaidTriggerEvent; 16 | import org.bukkit.potion.PotionEffectType; 17 | 18 | import java.util.Arrays; 19 | import java.util.Collections; 20 | import java.util.List; 21 | 22 | public class FlagDef_RaidMemberOnly extends FlagDefinition { 23 | 24 | public FlagDef_RaidMemberOnly(FlagManager manager, GPFlags plugin) { 25 | super(manager, plugin); 26 | } 27 | 28 | @EventHandler 29 | private void onRaidTrigger(RaidTriggerEvent event) { 30 | Flag flag = this.getFlagInstanceAtLocation(event.getRaid().getLocation(), null); 31 | if (flag == null) return; 32 | Player player = event.getPlayer(); 33 | Claim claim = GriefPrevention.instance.dataStore.getClaimAt(event.getRaid().getLocation(), false, null); 34 | if (claim == null) return; 35 | if (!Util.canAccess(claim, player)) { 36 | event.setCancelled(true); 37 | player.removePotionEffect(PotionEffectType.BAD_OMEN); 38 | MessagingUtil.sendMessage(player, TextMode.Warn, Messages.RaidMemberOnlyDeny); 39 | } 40 | } 41 | 42 | @Override 43 | public String getName() { 44 | return "RaidMemberOnly"; 45 | } 46 | 47 | @Override 48 | public MessageSpecifier getSetMessage(String parameters) { 49 | return new MessageSpecifier(Messages.EnabledRaidMemberOnly); 50 | } 51 | 52 | @Override 53 | public MessageSpecifier getUnSetMessage() { 54 | return new MessageSpecifier(Messages.DisabledRaidMemberOnly); 55 | } 56 | 57 | @Override 58 | public List getFlagType() { 59 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT); 60 | } 61 | 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_RestoreGrazedGrass.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.Material; 6 | import org.bukkit.block.Block; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.entity.Sheep; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.entity.EntityChangeBlockEvent; 11 | import org.bukkit.event.entity.SheepRegrowWoolEvent; 12 | 13 | 14 | public class FlagDef_RestoreGrazedGrass extends FlagDefinition { 15 | 16 | public FlagDef_RestoreGrazedGrass(FlagManager manager, GPFlags plugin) { 17 | super(manager, plugin); 18 | } 19 | 20 | @EventHandler 21 | public void onEntityChangeBlock(EntityChangeBlockEvent event) { 22 | // Check that a sheep is doing the action 23 | if (event.getEntityType() != EntityType.SHEEP) return; 24 | 25 | // Check that the block was grass and will turn into dirt 26 | // Check that the event is a crop trample 27 | Block block = event.getBlock(); 28 | if (block.getType() != Material.GRASS_BLOCK) return; 29 | if (event.getTo() != Material.DIRT) return; 30 | 31 | // Check that the flag is set 32 | Flag flag = this.getFlagInstanceAtLocation(block.getLocation(), null); 33 | if (flag == null) return; 34 | 35 | // Prevent the eating and regrow the wool 36 | event.setCancelled(true); 37 | Sheep sheep = (Sheep) event.getEntity(); 38 | SheepRegrowWoolEvent regrowEvent = new SheepRegrowWoolEvent(sheep); 39 | Bukkit.getPluginManager().callEvent(regrowEvent); 40 | } 41 | 42 | @Override 43 | public String getName() { 44 | return "RestoreGrazedGrass"; 45 | } 46 | 47 | @Override 48 | public MessageSpecifier getSetMessage(String parameters) { 49 | return new MessageSpecifier(Messages.EnabledRestoreGrazedGrass); 50 | } 51 | 52 | @Override 53 | public MessageSpecifier getUnSetMessage() { 54 | return new MessageSpecifier(Messages.DisabledRestoreGrazedGrass); 55 | } 56 | 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_SpawnReasonWhitelist.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.*; 4 | import me.ryanhamshire.GPFlags.util.MessagingUtil; 5 | import org.bukkit.command.CommandSender; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.entity.CreatureSpawnEvent; 9 | 10 | import java.util.Arrays; 11 | import java.util.List; 12 | 13 | public class FlagDef_SpawnReasonWhitelist extends FlagDefinition { 14 | 15 | public FlagDef_SpawnReasonWhitelist(FlagManager manager, GPFlags plugin) { 16 | super(manager, plugin); 17 | } 18 | 19 | @EventHandler 20 | public void onCreatureSpawn(CreatureSpawnEvent event) { 21 | Flag flag = this.getFlagInstanceAtLocation(event.getLocation(), null); 22 | if (flag == null) return; 23 | for (String string : flag.getParametersArray()) { 24 | CreatureSpawnEvent.SpawnReason reason; 25 | try { 26 | reason = CreatureSpawnEvent.SpawnReason.valueOf(string.toUpperCase()); 27 | } catch (IllegalArgumentException ex) { 28 | return; 29 | } 30 | if (reason != event.getSpawnReason()) { 31 | event.setCancelled(true); 32 | return; 33 | } 34 | } 35 | } 36 | 37 | @Override 38 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 39 | if (parameters.isEmpty()) { 40 | return new SetFlagResult(false, new MessageSpecifier(Messages.SpecifySpawnReason)); 41 | } 42 | for (String s : parameters.split(" ")) { 43 | try { 44 | CreatureSpawnEvent.SpawnReason.valueOf(s.toUpperCase()); 45 | } catch (IllegalArgumentException ex) { 46 | return new SetFlagResult(false, new MessageSpecifier(Messages.NotValidSpawnReason, s)); 47 | } 48 | } 49 | return new SetFlagResult(true, this.getSetMessage(parameters)); 50 | } 51 | 52 | @Override 53 | public String getName() { 54 | return "SpawnReasonWhitelist"; 55 | } 56 | 57 | @Override 58 | public MessageSpecifier getSetMessage(String parameters) { 59 | return new MessageSpecifier(Messages.EnabledSpawnReasonWhitelist, parameters); 60 | } 61 | 62 | @Override 63 | public MessageSpecifier getUnSetMessage() { 64 | return new MessageSpecifier(Messages.DisabledSpawnReasonWhitelist); 65 | } 66 | 67 | 68 | } 69 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/FlagDef_TrappedDestination.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.MessageSpecifier; 7 | import me.ryanhamshire.GPFlags.Messages; 8 | import me.ryanhamshire.GPFlags.SetFlagResult; 9 | import me.ryanhamshire.GriefPrevention.events.SaveTrappedPlayerEvent; 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.Location; 12 | import org.bukkit.World; 13 | import org.bukkit.command.CommandSender; 14 | import org.bukkit.event.EventHandler; 15 | 16 | import java.util.Arrays; 17 | import java.util.List; 18 | 19 | public class FlagDef_TrappedDestination extends FlagDefinition { 20 | 21 | public FlagDef_TrappedDestination(FlagManager manager, GPFlags plugin) { 22 | super(manager, plugin); 23 | } 24 | 25 | @EventHandler 26 | public void onPlayerDeath(SaveTrappedPlayerEvent event) { 27 | Flag flag = this.getFlagInstanceAtLocation(event.getClaim().getLesserBoundaryCorner(), null); 28 | if (flag == null) return; 29 | 30 | String[] params = flag.getParametersArray(); 31 | World world = Bukkit.getServer().getWorld(params[0]); 32 | Location location = new Location(world, Integer.valueOf(params[1]), Integer.valueOf(params[2]), Integer.valueOf(params[3])); 33 | 34 | event.setDestination(location); 35 | } 36 | 37 | @Override 38 | public String getName() { 39 | return "TrappedDestination"; 40 | } 41 | 42 | @Override 43 | public SetFlagResult validateParameters(String parameters, CommandSender sender) { 44 | String[] params = parameters.split(" "); 45 | 46 | if (params.length != 4) { 47 | return new SetFlagResult(false, new MessageSpecifier(Messages.LocationRequired)); 48 | } 49 | 50 | World world = Bukkit.getWorld(params[0]); 51 | if (world == null) { 52 | return new SetFlagResult(false, new MessageSpecifier(Messages.WorldNotFound)); 53 | } 54 | 55 | try { 56 | Integer.valueOf(params[1]); 57 | Integer.valueOf(params[2]); 58 | Integer.valueOf(params[3]); 59 | } catch (NumberFormatException e) { 60 | return new SetFlagResult(false, new MessageSpecifier(Messages.LocationRequired)); 61 | } 62 | 63 | return new SetFlagResult(true, this.getSetMessage(parameters)); 64 | } 65 | 66 | @Override 67 | public MessageSpecifier getSetMessage(String parameters) { 68 | return new MessageSpecifier(Messages.EnableTrappedDestination); 69 | } 70 | 71 | @Override 72 | public MessageSpecifier getUnSetMessage() { 73 | return new MessageSpecifier(Messages.DisableTrappedDestination); 74 | } 75 | 76 | @Override 77 | public List getFlagType() { 78 | return Arrays.asList(FlagType.CLAIM, FlagType.DEFAULT); 79 | } 80 | } 81 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/flags/TimedPlayerFlagDefinition.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.flags; 2 | 3 | import me.ryanhamshire.GPFlags.FlagManager; 4 | import me.ryanhamshire.GPFlags.GPFlags; 5 | import org.bukkit.Bukkit; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.event.Listener; 8 | 9 | import java.util.Collection; 10 | import java.util.concurrent.ConcurrentLinkedQueue; 11 | 12 | /** 13 | * Base flag definition for time based flags 14 | *

When creating flags which require a timer extend from this class

15 | */ 16 | public abstract class TimedPlayerFlagDefinition extends FlagDefinition implements Listener, Runnable { 17 | 18 | private static long tickOffset = 0L; 19 | private ConcurrentLinkedQueue> playerQueueQueue = new ConcurrentLinkedQueue<>(); 20 | private long taskIntervalTicks; 21 | 22 | public TimedPlayerFlagDefinition(FlagManager manager, GPFlags plugin) { 23 | super(manager, plugin); 24 | } 25 | 26 | public abstract long getPlayerCheckFrequency_Ticks(); 27 | 28 | public abstract void processPlayer(Player player); 29 | 30 | private boolean isSetup = false; 31 | 32 | public void firstTimeSetup() { 33 | super.firstTimeSetup(); 34 | 35 | if (isSetup) return; 36 | 37 | this.taskIntervalTicks = this.getPlayerCheckFrequency_Ticks() / Bukkit.getServer().getMaxPlayers(); 38 | if (this.taskIntervalTicks < 1) this.taskIntervalTicks = 1; 39 | Bukkit.getScheduler().scheduleSyncRepeatingTask(this.plugin, this, TimedPlayerFlagDefinition.tickOffset++, Math.max(this.taskIntervalTicks, 1)); 40 | isSetup = true; 41 | } 42 | 43 | @Override 44 | public void run() { 45 | ConcurrentLinkedQueue playerQueue = this.playerQueueQueue.poll(); 46 | if (playerQueue == null) { 47 | long iterationsToProcessAllPlayers = this.getPlayerCheckFrequency_Ticks() / this.taskIntervalTicks; 48 | if (iterationsToProcessAllPlayers < 1) iterationsToProcessAllPlayers = 1; 49 | for (int i = 0; i < iterationsToProcessAllPlayers; i++) { 50 | this.playerQueueQueue.add(new ConcurrentLinkedQueue()); 51 | } 52 | 53 | @SuppressWarnings("unchecked") 54 | Collection players = (Collection) Bukkit.getServer().getOnlinePlayers(); 55 | for (Player player : players) { 56 | ConcurrentLinkedQueue queueToFill = this.playerQueueQueue.poll(); 57 | queueToFill.add(player); 58 | this.playerQueueQueue.add(queueToFill); 59 | } 60 | 61 | playerQueue = this.playerQueueQueue.poll(); 62 | } 63 | 64 | Player player; 65 | while ((player = playerQueue.poll()) != null) { 66 | try { 67 | this.processPlayer(player); 68 | } catch (Throwable e) { 69 | if (player.isOnline()) { 70 | e.printStackTrace(); 71 | } 72 | } 73 | } 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/hooks/MythicMobsHook.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.hooks; 2 | 3 | import io.lumine.mythic.bukkit.BukkitAPIHelper; 4 | import org.bukkit.entity.Entity; 5 | 6 | public class MythicMobsHook { 7 | 8 | public static boolean isMythicMob(Entity entity) { 9 | try { 10 | BukkitAPIHelper mythicMobsAPI = new BukkitAPIHelper(); 11 | return mythicMobsAPI.isMythicMob(entity); 12 | } catch (NoClassDefFoundError error) { 13 | return false; 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/listener/ClaimCreatedListener.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.listener; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GriefPrevention.events.ClaimCreatedEvent; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.Listener; 9 | 10 | import java.util.Collection; 11 | 12 | public class ClaimCreatedListener implements Listener { 13 | 14 | @EventHandler 15 | private void onClaimCreate(ClaimCreatedEvent event) { 16 | Collection defaultFlags = GPFlags.getInstance().getFlagManager().getFlags(FlagManager.DEFAULT_FLAG_ID); 17 | for (Flag flag : defaultFlags) { 18 | flag.getFlagDefinition().onFlagSet(event.getClaim(), flag.parameters); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/listener/ClaimModifiedListener.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.listener; 2 | 3 | import me.ryanhamshire.GPFlags.event.PlayerPostClaimBorderEvent; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import me.ryanhamshire.GriefPrevention.Claim; 6 | import me.ryanhamshire.GriefPrevention.events.ClaimModifiedEvent; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.Location; 9 | import org.bukkit.World; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.Listener; 13 | 14 | public class ClaimModifiedListener implements Listener { 15 | 16 | @EventHandler 17 | private void onClaimResize(ClaimModifiedEvent event) { 18 | Claim claimTo = event.getTo(); 19 | Claim claimFrom = event.getFrom(); 20 | World world = claimFrom.getGreaterBoundaryCorner().getWorld(); 21 | for (Player player : world.getPlayers()) { 22 | Location loc = Util.getInBoundsLocation(player); 23 | 24 | // Resizing a claim to be smaller and falling on the outside 25 | if (!claimTo.contains(loc, false, false) && claimFrom.contains(loc, false, false)) { 26 | Claim parent = claimFrom.parent; 27 | PlayerPostClaimBorderEvent borderEvent; 28 | // Falling in the parent claim 29 | if (parent != null && parent.contains(loc, false, false)) { 30 | borderEvent = new PlayerPostClaimBorderEvent(player, claimFrom, parent, loc, loc); 31 | } else { 32 | // Falling in the non-claim 33 | borderEvent = new PlayerPostClaimBorderEvent(player, claimFrom, null, loc, loc); 34 | } 35 | Bukkit.getPluginManager().callEvent(borderEvent); 36 | return; 37 | } 38 | // Resizing a claim to be larger and falling on the inside 39 | if (claimTo.contains(loc, false, false) && !claimFrom.contains(loc, false, false)) { 40 | PlayerPostClaimBorderEvent borderEvent = new PlayerPostClaimBorderEvent(player, claimTo.parent, claimTo, loc, loc); 41 | Bukkit.getPluginManager().callEvent(borderEvent); 42 | return; 43 | } 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/listener/ClaimResizeListener.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.listener; 2 | 3 | import me.ryanhamshire.GPFlags.Flag; 4 | import me.ryanhamshire.GPFlags.FlagManager; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.event.PlayerPostClaimBorderEvent; 7 | import me.ryanhamshire.GPFlags.flags.FlagDefinition; 8 | import me.ryanhamshire.GPFlags.util.Util; 9 | import me.ryanhamshire.GriefPrevention.Claim; 10 | import me.ryanhamshire.GriefPrevention.events.ClaimResizeEvent; 11 | import org.bukkit.Bukkit; 12 | import org.bukkit.Location; 13 | import org.bukkit.World; 14 | import org.bukkit.entity.Player; 15 | import org.bukkit.event.EventHandler; 16 | import org.bukkit.event.Listener; 17 | 18 | public class ClaimResizeListener implements Listener { 19 | 20 | @EventHandler 21 | private void onClaimResize(ClaimResizeEvent event) { 22 | Claim claimTo = event.getTo(); 23 | Claim claimFrom = event.getFrom(); 24 | World world = claimFrom.getGreaterBoundaryCorner().getWorld(); 25 | for (Player player : world.getPlayers()) { 26 | Location loc = Util.getInBoundsLocation(player); 27 | 28 | // Resizing a claim and falling on the outside 29 | if (!claimTo.contains(loc, false, false) && claimFrom.contains(loc, false, false)) { 30 | Claim parent = claimFrom.parent; 31 | PlayerPostClaimBorderEvent borderEvent; 32 | // Falling in the parent claim 33 | if (parent != null && parent.contains(loc, false, false)) { 34 | borderEvent = new PlayerPostClaimBorderEvent(player, claimFrom, parent, loc, loc); 35 | } else { 36 | // Falling in the non-claim 37 | borderEvent = new PlayerPostClaimBorderEvent(player, claimFrom, null, loc, loc); 38 | } 39 | Bukkit.getPluginManager().callEvent(borderEvent); 40 | return; 41 | } 42 | // Resizing a claim and falling on the inside 43 | if (claimTo.contains(loc, false, false) && !claimFrom.contains(loc, false, false)) { 44 | PlayerPostClaimBorderEvent borderEvent = new PlayerPostClaimBorderEvent(player, claimTo.parent, claimTo, loc, loc); 45 | Bukkit.getPluginManager().callEvent(borderEvent); 46 | } 47 | } 48 | 49 | // Deal with claims 50 | FlagManager manager = GPFlags.getInstance().getFlagManager(); 51 | Flag keepLoaded = manager.getRawClaimFlag(claimFrom, "KeepLoaded"); 52 | if (keepLoaded != null) { 53 | FlagDefinition def = manager.getFlagDefinitionByName("KeepLoaded"); 54 | if (keepLoaded.getSet()) { 55 | def.onFlagUnset(claimFrom); 56 | def.onFlagSet(claimTo, null); 57 | } 58 | } 59 | 60 | Flag changeBiome = manager.getRawClaimFlag(claimFrom, "ChangeBiome"); 61 | if (changeBiome != null) { 62 | FlagDefinition def = manager.getFlagDefinitionByName("ChangeBiome"); 63 | if (changeBiome.getSet()) { 64 | def.onFlagUnset(claimFrom); 65 | def.onFlagSet(claimTo, changeBiome.getParameters()); 66 | } 67 | } 68 | 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/listener/ClaimTransferListener.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.listener; 2 | 3 | 4 | import me.ryanhamshire.GPFlags.Flag; 5 | import me.ryanhamshire.GPFlags.GPFlags; 6 | import me.ryanhamshire.GPFlags.WorldSettings; 7 | import me.ryanhamshire.GriefPrevention.Claim; 8 | import me.ryanhamshire.GriefPrevention.events.ClaimTransferEvent; 9 | import org.bukkit.event.EventHandler; 10 | import org.bukkit.event.Listener; 11 | 12 | import java.util.Collection; 13 | 14 | public class ClaimTransferListener implements Listener { 15 | 16 | @EventHandler 17 | private void onTransferClaim(ClaimTransferEvent event) { 18 | Claim claim = event.getClaim(); 19 | if (claim.isAdminClaim()) return; 20 | if (event.getNewOwner() == null) return; 21 | 22 | WorldSettings settings = GPFlags.getInstance().getWorldSettingsManager().get(claim.getLesserBoundaryCorner().getWorld()); 23 | if (settings.clearFlagsOnTransferClaim) return; 24 | Collection flags = GPFlags.getInstance().getFlagManager().getFlags(claim); 25 | flags.clear(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/me/ryanhamshire/GPFlags/listener/EntityMoveListener.java: -------------------------------------------------------------------------------- 1 | package me.ryanhamshire.GPFlags.listener; 2 | 3 | import io.papermc.paper.event.entity.EntityMoveEvent; 4 | import me.ryanhamshire.GPFlags.util.Util; 5 | import org.bukkit.Location; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.Listener; 9 | 10 | import java.util.Set; 11 | 12 | public class EntityMoveListener implements Listener { 13 | 14 | @EventHandler(ignoreCancelled = true) 15 | private void onMove(EntityMoveEvent event) { 16 | // Check if it'll be allowed 17 | Set group = Util.getMovementGroup(event.getEntity()); 18 | Location locTo = event.getTo(); 19 | Location locFrom = event.getFrom(); 20 | if (PlayerListener.flagsPreventMovement(locTo, locFrom, group)) { 21 | event.setCancelled(true); 22 | } 23 | } 24 | } --------------------------------------------------------------------------------