476 lines
22 KiB
Java
476 lines
22 KiB
Java
/*
|
|
* This file is part of GriefDefender, licensed under the MIT License (MIT).
|
|
*
|
|
* Copyright (c) bloodmc
|
|
* Copyright (c) contributors
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
package com.griefdefender.storage;
|
|
|
|
import com.flowpowered.math.vector.Vector3i;
|
|
import com.google.common.collect.ImmutableList;
|
|
import com.google.common.collect.ImmutableMap;
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.griefdefender.GDPlayerData;
|
|
import com.griefdefender.GriefDefenderPlugin;
|
|
import com.griefdefender.api.GriefDefender;
|
|
import com.griefdefender.api.Tristate;
|
|
import com.griefdefender.api.claim.Claim;
|
|
import com.griefdefender.api.claim.ClaimContexts;
|
|
import com.griefdefender.api.claim.ClaimResult;
|
|
import com.griefdefender.api.claim.ClaimResultType;
|
|
import com.griefdefender.api.claim.ClaimType;
|
|
import com.griefdefender.api.claim.ClaimTypes;
|
|
import com.griefdefender.api.permission.Context;
|
|
import com.griefdefender.api.permission.flag.Flag;
|
|
import com.griefdefender.api.permission.flag.Flags;
|
|
import com.griefdefender.api.permission.option.Option;
|
|
import com.griefdefender.claim.GDClaim;
|
|
import com.griefdefender.claim.GDClaimManager;
|
|
import com.griefdefender.claim.GDClaimResult;
|
|
import com.griefdefender.configuration.ClaimTemplateStorage;
|
|
import com.griefdefender.configuration.FlagConfig;
|
|
import com.griefdefender.configuration.GriefDefenderConfig;
|
|
import com.griefdefender.configuration.MessageStorage;
|
|
import com.griefdefender.configuration.OptionConfig;
|
|
import com.griefdefender.configuration.type.ConfigBase;
|
|
import com.griefdefender.configuration.type.GlobalConfig;
|
|
import com.griefdefender.event.GDCauseStackManager;
|
|
import com.griefdefender.event.GDRemoveClaimEvent;
|
|
import com.griefdefender.migrator.PlayerDataMigrator;
|
|
import com.griefdefender.permission.GDPermissionUser;
|
|
import com.griefdefender.permission.flag.FlagContexts;
|
|
import com.griefdefender.permission.option.GDOption;
|
|
import com.griefdefender.registry.FlagRegistryModule;
|
|
import com.griefdefender.registry.OptionRegistryModule;
|
|
import com.griefdefender.util.PermissionUtil;
|
|
import net.kyori.text.TextComponent;
|
|
import net.kyori.text.format.TextColor;
|
|
import org.spongepowered.api.Sponge;
|
|
import org.spongepowered.api.command.CommandSource;
|
|
import org.spongepowered.api.entity.living.player.Player;
|
|
import org.spongepowered.api.world.Location;
|
|
import org.spongepowered.api.world.World;
|
|
import org.spongepowered.api.world.storage.WorldProperties;
|
|
|
|
import java.io.File;
|
|
import java.nio.file.Path;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
public abstract class BaseStorage {
|
|
|
|
protected final Map<UUID, GDClaimManager> claimWorldManagers = new ConcurrentHashMap<>();
|
|
|
|
public static Map<UUID, GriefDefenderConfig<ConfigBase>> dimensionConfigMap = new HashMap<>();
|
|
public static Map<UUID, GriefDefenderConfig<ConfigBase>> worldConfigMap = new HashMap<>();
|
|
public static Map<String, ClaimTemplateStorage> globalTemplates = new HashMap<>();
|
|
public static GriefDefenderConfig<GlobalConfig> globalConfig;
|
|
public static Map<UUID, GDPlayerData> GLOBAL_PLAYER_DATA = new ConcurrentHashMap<>();
|
|
public static boolean USE_GLOBAL_PLAYER_STORAGE = true;
|
|
public static Map<String, Double> GLOBAL_OPTION_DEFAULTS = new HashMap<>();
|
|
|
|
public final static Path dataLayerFolderPath = GriefDefenderPlugin.getInstance().getConfigPath();
|
|
public final static Path globalPlayerDataPath = dataLayerFolderPath.resolve("GlobalPlayerData");
|
|
|
|
public void initialize() throws Exception {
|
|
USE_GLOBAL_PLAYER_STORAGE = !GriefDefenderPlugin.getGlobalConfig().getConfig().playerdata.useWorldPlayerData();
|
|
if (USE_GLOBAL_PLAYER_STORAGE) {
|
|
// migrate player data
|
|
PlayerDataMigrator.migrateGlobal();
|
|
}
|
|
|
|
// handle default flag/option permissions
|
|
this.setDefaultGlobalPermissions();
|
|
}
|
|
|
|
public void clearCachedPlayerData(UUID worldUniqueId, UUID playerUniqueId) {
|
|
this.getClaimWorldManager(worldUniqueId).removePlayer(playerUniqueId);
|
|
}
|
|
|
|
public abstract ClaimResult writeClaimToStorage(GDClaim claim);
|
|
|
|
public abstract ClaimResult deleteClaimFromStorage(GDClaim claim);
|
|
|
|
public Claim getClaim(UUID worldUniqueId, UUID id) {
|
|
return this.getClaimWorldManager(worldUniqueId).getClaimByUUID(id).orElse(null);
|
|
}
|
|
|
|
public void asyncSaveGlobalPlayerData(UUID playerID, GDPlayerData playerData) {
|
|
// save everything except the ignore list
|
|
this.overrideSavePlayerData(playerID, playerData);
|
|
}
|
|
|
|
abstract void overrideSavePlayerData(UUID playerID, GDPlayerData playerData);
|
|
|
|
public ClaimResult createClaim(World world, Vector3i point1, Vector3i point2, ClaimType claimType, UUID ownerUniqueId, boolean cuboid) {
|
|
return createClaim(world, point1, point2, claimType, ownerUniqueId, cuboid, null);
|
|
}
|
|
|
|
public ClaimResult createClaim(World world, Vector3i point1, Vector3i point2, ClaimType claimType, UUID ownerUniqueId, boolean cuboid, Claim parent) {
|
|
ClaimResult claimResult = Claim.builder()
|
|
.bounds(point1, point2)
|
|
.cuboid(cuboid)
|
|
.world(world.getUniqueId())
|
|
.type(claimType)
|
|
.owner(ownerUniqueId)
|
|
.parent(parent)
|
|
.build();
|
|
|
|
if (claimResult.successful()) {
|
|
final Claim claim = claimResult.getClaim().get();
|
|
final GDClaimManager claimManager = GriefDefenderPlugin.getInstance().dataStore.getClaimWorldManager(world.getUniqueId());
|
|
claimManager.addClaim(claim, true);
|
|
|
|
/*if (claimResult.getClaims().size() > 1) {
|
|
claim.migrateClaims(new ArrayList<>(claimResult.getClaims()));
|
|
}*/
|
|
}
|
|
|
|
return claimResult;
|
|
}
|
|
|
|
public ClaimResult deleteAllAdminClaims(Player source, UUID worldUniqueId) {
|
|
if (worldUniqueId == null) {
|
|
worldUniqueId = source.getWorld().getUniqueId();
|
|
}
|
|
GDClaimManager claimWorldManager = this.claimWorldManagers.get(worldUniqueId);
|
|
if (claimWorldManager == null) {
|
|
return new GDClaimResult(ClaimResultType.CLAIMS_DISABLED);
|
|
}
|
|
|
|
List<Claim> claimsToDelete = new ArrayList<Claim>();
|
|
boolean adminClaimFound = false;
|
|
for (Claim claim : claimWorldManager.getWorldClaims()) {
|
|
if (worldUniqueId != null && !claim.getWorldUniqueId().equals(worldUniqueId)) {
|
|
continue;
|
|
}
|
|
if (claim.isAdminClaim()) {
|
|
claimsToDelete.add(claim);
|
|
adminClaimFound = true;
|
|
}
|
|
}
|
|
|
|
if (!adminClaimFound) {
|
|
return new GDClaimResult(ClaimResultType.CLAIM_NOT_FOUND);
|
|
}
|
|
|
|
GDCauseStackManager.getInstance().pushCause(source);
|
|
GDRemoveClaimEvent.Delete event = new GDRemoveClaimEvent.Delete(ImmutableList.copyOf(claimsToDelete));
|
|
GriefDefender.getEventManager().post(event);
|
|
GDCauseStackManager.getInstance().popCause();
|
|
if (event.cancelled()) {
|
|
return new GDClaimResult(ClaimResultType.CLAIM_EVENT_CANCELLED,
|
|
event.getMessage().orElse(GriefDefenderPlugin.getInstance().messageData.getMessage(MessageStorage.DELETE_ALL_TYPE_DENY,
|
|
ImmutableMap.of("type", TextComponent.of("ADMIN").color(TextColor.RED)))));
|
|
}
|
|
|
|
for (Claim claim : claimsToDelete) {
|
|
claimWorldManager.deleteClaimInternal(claim, true);
|
|
}
|
|
|
|
return new GDClaimResult(claimsToDelete, ClaimResultType.SUCCESS);
|
|
}
|
|
|
|
public ClaimResult deleteClaim(Claim claim, boolean deleteChildren) {
|
|
GDClaimManager claimManager = this.getClaimWorldManager(claim.getWorldUniqueId());
|
|
return claimManager.deleteClaim(claim, deleteChildren);
|
|
}
|
|
|
|
public void abandonClaimsForPlayer(GDPermissionUser user, Set<Claim> claimsToDelete) {
|
|
for (Claim claim : claimsToDelete) {
|
|
GDClaimManager claimWorldManager = this.claimWorldManagers.get(claim.getWorldUniqueId());
|
|
claimWorldManager.deleteClaimInternal(claim, true);
|
|
user.getInternalPlayerData().revertClaimVisual((GDClaim) claim);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
public void deleteClaimsForPlayer(UUID playerID) {
|
|
this.deleteClaimsForPlayer(playerID, null);
|
|
}
|
|
|
|
public void deleteClaimsForPlayer(UUID playerID, UUID worldUniqueId) {
|
|
if (BaseStorage.USE_GLOBAL_PLAYER_STORAGE && playerID != null) {
|
|
Set<Claim> claims = new HashSet<>();
|
|
if (worldUniqueId != null) {
|
|
final GDClaimManager claimManager = GriefDefenderPlugin.getInstance().dataStore.getClaimWorldManager(worldUniqueId);
|
|
claims = claimManager.getInternalPlayerClaims(playerID);
|
|
} else {
|
|
final GDPlayerData playerData = BaseStorage.GLOBAL_PLAYER_DATA.get(playerID);
|
|
claims = playerData.getInternalClaims();
|
|
}
|
|
List<Claim> claimsToDelete = new ArrayList<>(claims);
|
|
for (Claim claim : claimsToDelete) {
|
|
if (worldUniqueId != null && !claim.getWorldUniqueId().equals(worldUniqueId)) {
|
|
continue;
|
|
}
|
|
GDClaimManager claimWorldManager = this.claimWorldManagers.get(claim.getWorldUniqueId());
|
|
claimWorldManager.deleteClaimInternal(claim, true);
|
|
claims.remove(claim);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
for (GDClaimManager claimWorldManager : this.claimWorldManagers.values()) {
|
|
if (worldUniqueId != null && !claimWorldManager.getWorldId().equals(worldUniqueId)) {
|
|
continue;
|
|
}
|
|
Set<Claim> claims = claimWorldManager.getInternalPlayerClaims(playerID);
|
|
if (playerID == null) {
|
|
claims = claimWorldManager.getWorldClaims();
|
|
}
|
|
if (claims == null) {
|
|
continue;
|
|
}
|
|
|
|
List<Claim> claimsToDelete = new ArrayList<Claim>();
|
|
for (Claim claim : claims) {
|
|
if (worldUniqueId != null && !claim.getWorldUniqueId().equals(worldUniqueId)) {
|
|
continue;
|
|
}
|
|
if (!claim.isAdminClaim()) {
|
|
claimsToDelete.add(claim);
|
|
}
|
|
}
|
|
|
|
for (Claim claim : claimsToDelete) {
|
|
claimWorldManager.deleteClaimInternal(claim, true);
|
|
claims.remove(claim);
|
|
}
|
|
}
|
|
}
|
|
|
|
public GDClaim getClaimAt(Location<World> location) {
|
|
GDClaimManager claimManager = this.getClaimWorldManager(location.getExtent().getUniqueId());
|
|
return (GDClaim) claimManager.getClaimAt(location);
|
|
}
|
|
|
|
public GDClaim getClaimAtPlayer(GDPlayerData playerData, Location<World> location) {
|
|
GDClaimManager claimManager = this.getClaimWorldManager(location.getExtent().getUniqueId());
|
|
return (GDClaim) claimManager.getClaimAtPlayer(location, playerData);
|
|
}
|
|
|
|
public GDClaim getClaimAtPlayer(Location<World> location, GDPlayerData playerData, boolean useBorderBlockRadius) {
|
|
GDClaimManager claimManager = this.getClaimWorldManager(location.getExtent().getUniqueId());
|
|
return (GDClaim) claimManager.getClaimAt(location, playerData, useBorderBlockRadius);
|
|
}
|
|
|
|
public GDClaim getClaimAt(Location<World> location, GDClaim cachedClaim) {
|
|
GDClaimManager claimManager = this.getClaimWorldManager(location.getExtent().getUniqueId());
|
|
return (GDClaim) claimManager.getClaimAt(location, null, false);
|
|
}
|
|
|
|
public GDPlayerData getPlayerData(World world, UUID playerUniqueId) {
|
|
return this.getPlayerData(world.getUniqueId(), playerUniqueId);
|
|
}
|
|
|
|
public GDPlayerData getPlayerData(UUID worldUniqueId, UUID playerUniqueId) {
|
|
GDPlayerData playerData = null;
|
|
GDClaimManager claimWorldManager = this.getClaimWorldManager(worldUniqueId);
|
|
playerData = claimWorldManager.getPlayerDataMap().get(playerUniqueId);
|
|
return playerData;
|
|
}
|
|
|
|
public GDPlayerData getOrCreateGlobalPlayerData(UUID playerUniqueId) {
|
|
if (BaseStorage.USE_GLOBAL_PLAYER_STORAGE) {
|
|
final GDPlayerData playerData = GLOBAL_PLAYER_DATA.get(playerUniqueId);
|
|
if (playerData != null) {
|
|
return playerData;
|
|
}
|
|
}
|
|
|
|
GDClaimManager claimWorldManager = this.getClaimWorldManager(null);
|
|
return claimWorldManager.getOrCreatePlayerData(playerUniqueId);
|
|
}
|
|
|
|
public GDPlayerData getOrCreatePlayerData(World world, UUID playerUniqueId) {
|
|
return getOrCreatePlayerData(world.getUniqueId(), playerUniqueId);
|
|
}
|
|
|
|
public GDPlayerData getOrCreatePlayerData(UUID worldUniqueId, UUID playerUniqueId) {
|
|
if (BaseStorage.USE_GLOBAL_PLAYER_STORAGE) {
|
|
final GDPlayerData playerData = GLOBAL_PLAYER_DATA.get(playerUniqueId);
|
|
if (playerData != null) {
|
|
return playerData;
|
|
}
|
|
}
|
|
|
|
GDClaimManager claimWorldManager = this.getClaimWorldManager(worldUniqueId);
|
|
return claimWorldManager.getOrCreatePlayerData(playerUniqueId);
|
|
}
|
|
|
|
public void removePlayerData(UUID worldUniqueId, UUID playerUniqueId) {
|
|
GDClaimManager claimWorldManager = this.getClaimWorldManager(worldUniqueId);
|
|
claimWorldManager.removePlayer(playerUniqueId);
|
|
}
|
|
|
|
public GDClaimManager getClaimWorldManager(UUID worldUniqueId) {
|
|
GDClaimManager claimWorldManager = null;
|
|
if (worldUniqueId == null) {
|
|
worldUniqueId = Sponge.getServer().getDefaultWorld().get().getUniqueId();
|
|
}
|
|
claimWorldManager = this.claimWorldManagers.get(worldUniqueId);
|
|
|
|
if (claimWorldManager == null) {
|
|
final WorldProperties defaultWorldProperties = Sponge.getServer().getDefaultWorld().get();
|
|
final World world = Sponge.getServer().getWorld(worldUniqueId).orElse(Sponge.getServer().getWorld(defaultWorldProperties.getUniqueId()).get());
|
|
registerWorld(world);
|
|
claimWorldManager = this.claimWorldManagers.get(world.getUniqueId());
|
|
}
|
|
return claimWorldManager;
|
|
}
|
|
|
|
public void removeClaimWorldManager(WorldProperties worldProperties) {
|
|
if (BaseStorage.USE_GLOBAL_PLAYER_STORAGE) {
|
|
return;
|
|
}
|
|
this.claimWorldManagers.remove(worldProperties.getUniqueId());
|
|
}
|
|
|
|
public void setDefaultGlobalPermissions() {
|
|
// Admin defaults
|
|
Set<Context> contexts = new HashSet<>();
|
|
contexts.add(ClaimContexts.ADMIN_DEFAULT_CONTEXT);
|
|
final FlagConfig flagConfig = GriefDefenderPlugin.getFlagConfig();
|
|
final OptionConfig optionConfig = GriefDefenderPlugin.getOptionConfig();
|
|
final Map<String, Boolean> adminDefaultFlags = flagConfig.getConfig().defaultFlagCategory.getFlagDefaults(ClaimTypes.ADMIN.getName().toLowerCase());
|
|
if (adminDefaultFlags != null && !adminDefaultFlags.isEmpty()) {
|
|
this.setDefaultFlags(contexts, adminDefaultFlags);
|
|
}
|
|
|
|
// Basic defaults
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimContexts.BASIC_DEFAULT_CONTEXT);
|
|
final Map<String, Boolean> basicDefaultFlags = flagConfig.getConfig().defaultFlagCategory.getFlagDefaults(ClaimTypes.BASIC.getName().toLowerCase());
|
|
if (basicDefaultFlags != null && !basicDefaultFlags.isEmpty()) {
|
|
this.setDefaultFlags(contexts, basicDefaultFlags);
|
|
}
|
|
final Map<String, String> basicDefaultOptions = optionConfig.getConfig().defaultOptionCategory.getBasicOptionDefaults();
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimTypes.BASIC.getDefaultContext());
|
|
this.setDefaultOptions(contexts, new HashMap<>(basicDefaultOptions));
|
|
|
|
// Town defaults
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimContexts.TOWN_DEFAULT_CONTEXT);
|
|
final Map<String, Boolean> townDefaultFlags = flagConfig.getConfig().defaultFlagCategory.getFlagDefaults(ClaimTypes.TOWN.getName().toLowerCase());
|
|
final Map<String, String> townDefaultOptions = optionConfig.getConfig().defaultOptionCategory.getTownOptionDefaults();
|
|
if (townDefaultFlags != null && !townDefaultFlags.isEmpty()) {
|
|
this.setDefaultFlags(contexts, townDefaultFlags);
|
|
}
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimTypes.TOWN.getDefaultContext());
|
|
this.setDefaultOptions(contexts, new HashMap<>(townDefaultOptions));
|
|
|
|
// Subdivision defaults
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimTypes.SUBDIVISION.getDefaultContext());
|
|
final Map<String, String> subdivisionDefaultOptions = optionConfig.getConfig().defaultOptionCategory.getSubdivisionOptionDefaults();
|
|
this.setDefaultOptions(contexts, new HashMap<>(subdivisionDefaultOptions));
|
|
|
|
// Wilderness defaults
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimContexts.WILDERNESS_DEFAULT_CONTEXT);
|
|
final Map<String, Boolean> wildernessDefaultFlags = flagConfig.getConfig().defaultFlagCategory.getFlagDefaults(ClaimTypes.WILDERNESS.getName().toLowerCase());
|
|
this.setDefaultFlags(contexts, wildernessDefaultFlags);
|
|
|
|
// Global default options
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimContexts.USER_DEFAULT_CONTEXT);
|
|
final Map<String, Boolean> globalDefaultFlags = flagConfig.getConfig().defaultFlagCategory.getFlagDefaults("user");
|
|
this.setDefaultFlags(contexts, globalDefaultFlags);
|
|
contexts = new HashSet<>();
|
|
contexts.add(ClaimContexts.GLOBAL_DEFAULT_CONTEXT);
|
|
final Map<String, String> globalDefaultOptions = optionConfig.getConfig().defaultOptionCategory.getUserOptionDefaults();
|
|
this.setDefaultOptions(contexts, new HashMap<>(globalDefaultOptions));
|
|
//GriefDefenderPlugin.getInstance().getPermissionProvider().setTransientPermission(GriefDefenderPlugin.GD_DEFAULT_HOLDER, "griefdefender", false, new HashSet<>());
|
|
flagConfig.save();
|
|
optionConfig.save();
|
|
}
|
|
|
|
private void setDefaultFlags(Set<Context> contexts, Map<String, Boolean> defaultFlags) {
|
|
final String serverName = PermissionUtil.getInstance().getServerName();
|
|
if (serverName != null) {
|
|
contexts.add(new Context("server", serverName));
|
|
}
|
|
GriefDefenderPlugin.getInstance().executor.execute(() -> {
|
|
for (Map.Entry<String, Boolean> mapEntry : defaultFlags.entrySet()) {
|
|
final Flag flag = FlagRegistryModule.getInstance().getById(mapEntry.getKey()).orElse(null);
|
|
if (flag == null) {
|
|
continue;
|
|
}
|
|
PermissionUtil.getInstance().setTransientPermission(GriefDefenderPlugin.GD_DEFAULT_HOLDER, flag.getPermission(), Tristate.fromBoolean(mapEntry.getValue()), contexts);
|
|
}
|
|
PermissionUtil.getInstance().refreshCachedData(GriefDefenderPlugin.GD_DEFAULT_HOLDER);
|
|
});
|
|
}
|
|
|
|
private void setDefaultOptions(Set<Context> contexts, Map<String, String> defaultOptions) {
|
|
final Map<Set<Context>, Map<String, List<String>>> permanentOptions = PermissionUtil.getInstance().getPermanentOptions(GriefDefenderPlugin.DEFAULT_HOLDER);
|
|
final Map<String, List<String>> options = permanentOptions.get(contexts);
|
|
GriefDefenderPlugin.getInstance().executor.execute(() -> {
|
|
for (Map.Entry<String, String> optionEntry : defaultOptions.entrySet()) {
|
|
final Option option = OptionRegistryModule.getInstance().getById(optionEntry.getKey()).orElse(null);
|
|
if (option == null) {
|
|
continue;
|
|
}
|
|
|
|
if (!((GDOption) option).validateStringValue(optionEntry.getValue(), true)) {
|
|
continue;
|
|
}
|
|
// Transient options are checked first so we must ignore setting if a persisted option exists
|
|
boolean foundPersisted = false;
|
|
if (options != null) {
|
|
for (Entry<String, List<String>> mapEntry : options.entrySet()) {
|
|
if (mapEntry.getKey().equalsIgnoreCase(option.getPermission())) {
|
|
foundPersisted = true;
|
|
break;
|
|
}
|
|
}
|
|
if (foundPersisted) {
|
|
continue;
|
|
}
|
|
}
|
|
PermissionUtil.getInstance().setTransientOption(GriefDefenderPlugin.GD_OPTION_HOLDER, option.getPermission(), optionEntry.getValue(), contexts);
|
|
}
|
|
PermissionUtil.getInstance().refreshCachedData(GriefDefenderPlugin.GD_OPTION_HOLDER);
|
|
});
|
|
}
|
|
|
|
abstract GDPlayerData getPlayerDataFromStorage(UUID playerID);
|
|
|
|
public abstract void registerWorld(World world);
|
|
|
|
public abstract void loadWorldData(World world);
|
|
|
|
public abstract void unloadWorldData(World world);
|
|
|
|
abstract void loadClaimTemplates();
|
|
} |