diff --git a/bukkit/src/main/resources/config.yml b/bukkit/src/main/resources/config.yml index b07a59f33..51c543b84 100644 --- a/bukkit/src/main/resources/config.yml +++ b/bukkit/src/main/resources/config.yml @@ -116,6 +116,8 @@ group-weight: # - lowest_own # - highest_on_track_ # - lowest_on_track_ +# - highest_not_on_track_ +# - lowest_not_on_track_ # # Each element is added in the order listed. meta-formatting: diff --git a/bungee/src/main/resources/config.yml b/bungee/src/main/resources/config.yml index de67ffeeb..c42664733 100644 --- a/bungee/src/main/resources/config.yml +++ b/bungee/src/main/resources/config.yml @@ -116,6 +116,8 @@ group-weight: # - lowest_own # - highest_on_track_ # - lowest_on_track_ +# - highest_not_on_track_ +# - lowest_not_on_track_ # # Each element is added in the order listed. meta-formatting: diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/stacking/MetaStackElement.java b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/MetaStackElement.java index af938ba9b..1d800af32 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/stacking/MetaStackElement.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/MetaStackElement.java @@ -94,4 +94,20 @@ public interface MetaStackElement { return t == null || !t.containsGroup(node.getLocation()); } + /** + * Returns true if the node is held by a group on the track + * @param node the node to check + * @param track the track + * @return true if the accumulation should return + */ + static boolean checkNotTrackElement(LuckPermsPlugin plugin, LocalizedNode node, String track) { + // it's not come from a group on this track (from the user directly) + if (node.getLocation() == null || node.getLocation().equals("")) { + return false; + } + + Track t = plugin.getTrackManager().getIfLoaded(track); + return t == null || t.containsGroup(node.getLocation()); + } + } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/stacking/StackElementFactory.java b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/StackElementFactory.java index ac8f296fb..539a1bc8d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/stacking/StackElementFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/StackElementFactory.java @@ -28,9 +28,11 @@ package me.lucko.luckperms.common.caching.stacking; import lombok.experimental.UtilityClass; import me.lucko.luckperms.common.caching.stacking.elements.HighestPriorityElement; +import me.lucko.luckperms.common.caching.stacking.elements.HighestPriorityNotOnTrackElement; import me.lucko.luckperms.common.caching.stacking.elements.HighestPriorityOwnElement; import me.lucko.luckperms.common.caching.stacking.elements.HighestPriorityTrackElement; import me.lucko.luckperms.common.caching.stacking.elements.LowestPriorityElement; +import me.lucko.luckperms.common.caching.stacking.elements.LowestPriorityNotOnTrackElement; import me.lucko.luckperms.common.caching.stacking.elements.LowestPriorityOwnElement; import me.lucko.luckperms.common.caching.stacking.elements.LowestPriorityTrackElement; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; @@ -71,6 +73,16 @@ public class StackElementFactory { return Optional.of(new LowestPriorityTrackElement(prefix, plugin, track)); } + if (s.startsWith("highest_not_on_track_") && s.length() > "highest_not_on_track_".length()) { + String track = s.substring("highest_not_on_track_".length()); + return Optional.of(new HighestPriorityNotOnTrackElement(prefix, plugin, track)); + } + + if (s.startsWith("lowest_not_on_track_") && s.length() > "lowest_not_on_track_".length()) { + String track = s.substring("lowest_not_on_track_".length()); + return Optional.of(new LowestPriorityNotOnTrackElement(prefix, plugin, track)); + } + new IllegalArgumentException("Cannot parse MetaStackElement: " + s).printStackTrace(); return Optional.empty(); } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/stacking/elements/HighestPriorityNotOnTrackElement.java b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/elements/HighestPriorityNotOnTrackElement.java new file mode 100644 index 000000000..9a518e66c --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/elements/HighestPriorityNotOnTrackElement.java @@ -0,0 +1,73 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * 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 me.lucko.luckperms.common.caching.stacking.elements; + +import lombok.RequiredArgsConstructor; + +import me.lucko.luckperms.api.LocalizedNode; +import me.lucko.luckperms.common.caching.stacking.MetaStackElement; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; + +import java.util.Map; +import java.util.Optional; + +@RequiredArgsConstructor +public class HighestPriorityNotOnTrackElement implements MetaStackElement { + private final boolean prefix; + private final LuckPermsPlugin plugin; + private final String trackName; + + private Map.Entry entry = null; + + @Override + public Optional> getEntry() { + return Optional.ofNullable(entry); + } + + @Override + public boolean accumulateNode(LocalizedNode node) { + if (MetaStackElement.checkMetaType(prefix, node)) { + return false; + } + + Map.Entry entry = prefix ? node.getPrefix() : node.getSuffix(); + if (HighestPriorityElement.compareEntries(this.entry, entry)) { + return false; + } + + if (MetaStackElement.checkNotTrackElement(plugin, node, trackName)) { + return false; + } + + this.entry = entry; + return true; + } + + @Override + public MetaStackElement copy() { + return new HighestPriorityNotOnTrackElement(prefix, plugin, trackName); + } +} diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/stacking/elements/LowestPriorityNotOnTrackElement.java b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/elements/LowestPriorityNotOnTrackElement.java new file mode 100644 index 000000000..a5062d2d8 --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/common/caching/stacking/elements/LowestPriorityNotOnTrackElement.java @@ -0,0 +1,73 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * 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 me.lucko.luckperms.common.caching.stacking.elements; + +import lombok.RequiredArgsConstructor; + +import me.lucko.luckperms.api.LocalizedNode; +import me.lucko.luckperms.common.caching.stacking.MetaStackElement; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; + +import java.util.Map; +import java.util.Optional; + +@RequiredArgsConstructor +public class LowestPriorityNotOnTrackElement implements MetaStackElement { + private final boolean prefix; + private final LuckPermsPlugin plugin; + private final String trackName; + + private Map.Entry entry = null; + + @Override + public Optional> getEntry() { + return Optional.ofNullable(entry); + } + + @Override + public boolean accumulateNode(LocalizedNode node) { + if (MetaStackElement.checkMetaType(prefix, node)) { + return false; + } + + Map.Entry entry = prefix ? node.getPrefix() : node.getSuffix(); + if (LowestPriorityElement.compareEntries(this.entry, entry)) { + return false; + } + + if (MetaStackElement.checkNotTrackElement(plugin, node, trackName)) { + return false; + } + + this.entry = entry; + return true; + } + + @Override + public MetaStackElement copy() { + return new LowestPriorityNotOnTrackElement(prefix, plugin, trackName); + } +} diff --git a/common/src/main/java/me/lucko/luckperms/common/core/model/ImmutableNode.java b/common/src/main/java/me/lucko/luckperms/common/core/model/ImmutableNode.java index 35b97bf7e..786c95795 100644 --- a/common/src/main/java/me/lucko/luckperms/common/core/model/ImmutableNode.java +++ b/common/src/main/java/me/lucko/luckperms/common/core/model/ImmutableNode.java @@ -57,7 +57,6 @@ import java.util.stream.Collectors; /** * An immutable permission node */ -@SuppressWarnings("OptionalGetWithoutIsPresent") @ToString(of = {"permission", "value", "override", "server", "world", "expireAt", "contexts"}) @EqualsAndHashCode(of = {"permission", "value", "override", "server", "world", "expireAt", "contexts"}) public final class ImmutableNode implements Node { @@ -193,6 +192,7 @@ public final class ImmutableNode implements Node { * @param world the world this node applies on * @param contexts any additional contexts applying to this node */ + @SuppressWarnings("deprecation") public ImmutableNode(String permission, boolean value, boolean override, long expireAt, String server, String world, ContextSet contexts) { if (permission == null || permission.equals("")) { throw new IllegalArgumentException("Empty permission"); diff --git a/sponge/src/main/resources/luckperms.conf b/sponge/src/main/resources/luckperms.conf index e6172e28d..1083334bb 100644 --- a/sponge/src/main/resources/luckperms.conf +++ b/sponge/src/main/resources/luckperms.conf @@ -118,6 +118,8 @@ group-weight { # - lowest_own # - highest_on_track_ # - lowest_on_track_ +# - highest_not_on_track_ +# - lowest_not_on_track_ # # Each element is added in the order listed. meta-formatting {