From fe90940047b1e2b45afc3f8281f0626f1f0f67e6 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Tue, 10 Feb 2026 16:03:09 +0200 Subject: [PATCH 1/3] Add luckperms integration --- core/common/build.gradle.kts | 1 + .../libreforge/LibreforgeSpigotPlugin.kt | 8 ++- .../luckperms/LuckPermsIntegration.kt | 26 +++++++++ .../impl/ConditionLuckPermHasPermission.kt | 30 ++++++++++ .../impl/EffectLuckPermGivePermission.kt | 56 +++++++++++++++++++ core/common/src/main/resources/plugin.yml | 1 + 6 files changed, 119 insertions(+), 3 deletions(-) create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts index a0e167fd5..5a9da09e7 100644 --- a/core/common/build.gradle.kts +++ b/core/common/build.gradle.kts @@ -42,6 +42,7 @@ dependencies { compileOnly("com.nexomc:nexo:1.17.0") { exclude(group = "*", module = "*") } + compileOnly("net.luckperms:api:5.4") compileOnly(fileTree("../../lib") { include("*.jar") diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt b/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt index 42054d550..ef790d907 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt @@ -21,6 +21,8 @@ import com.willfp.libreforge.integrations.aureliumskills.AureliumSkillsIntegrati import com.willfp.libreforge.integrations.axplugins.axenvoy.AxEnvoyIntegration import com.willfp.libreforge.integrations.axplugins.axtrade.AxTradeIntegration import com.willfp.libreforge.integrations.citizens.CitizensIntegration +import com.willfp.libreforge.integrations.custom_blocks.nexo.NexoIntegration +import com.willfp.libreforge.integrations.custom_blocks.oraxen.OraxenIntegration import com.willfp.libreforge.integrations.custombiomes.impl.CustomBiomesTerra import com.willfp.libreforge.integrations.custombiomes.impl.CustomBiomesTerraformGenerator import com.willfp.libreforge.integrations.edprisoncore.EdPrisonCoreIntegration @@ -30,11 +32,10 @@ import com.willfp.libreforge.integrations.huskintegration.husktowns.HuskTownsInt import com.willfp.libreforge.integrations.jobs.JobsIntegration import com.willfp.libreforge.integrations.lands.LandsIntegration import com.willfp.libreforge.integrations.levelledmobs.LevelledMobsIntegration +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration import com.willfp.libreforge.integrations.mcmmo.McMMOIntegration import com.willfp.libreforge.integrations.modelengine.ModelEngineIntegration import com.willfp.libreforge.integrations.mythicmobs.MythicMobsIntegration -import com.willfp.libreforge.integrations.custom_blocks.nexo.NexoIntegration -import com.willfp.libreforge.integrations.custom_blocks.oraxen.OraxenIntegration import com.willfp.libreforge.integrations.paper.PaperIntegration import com.willfp.libreforge.integrations.purpur.PurpurIntegration import com.willfp.libreforge.integrations.scyther.ScytherIntegration @@ -234,7 +235,8 @@ class LibreforgeSpigotPlugin : EcoPlugin() { IntegrationLoader("EdPrison") { EdPrisonCoreIntegration.load(this) }, IntegrationLoader("MythicMobs") { MythicMobsIntegration.load(this) }, IntegrationLoader("Nexo") { NexoIntegration.load(this) }, - IntegrationLoader("Oraxen") { OraxenIntegration.load(this)} + IntegrationLoader("Oraxen") { OraxenIntegration.load(this) }, + IntegrationLoader("LuckPerms") { LuckPermsIntegration.load(this) } ) } diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt new file mode 100644 index 000000000..5079c0fa7 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt @@ -0,0 +1,26 @@ +package com.willfp.libreforge.integrations.luckperms + +import com.willfp.eco.core.EcoPlugin +import com.willfp.libreforge.conditions.Conditions +import com.willfp.libreforge.effects.Effects +import com.willfp.libreforge.integrations.LoadableIntegration +import com.willfp.libreforge.integrations.luckperms.impl.ConditionLuckPermHasPermission +import com.willfp.libreforge.integrations.luckperms.impl.EffectLuckPermGivePermission +import net.luckperms.api.LuckPermsProvider +import net.luckperms.api.model.user.User +import org.bukkit.entity.Player + +object LuckPermsIntegration : LoadableIntegration { + override fun load(plugin: EcoPlugin) { + Conditions.register(ConditionLuckPermHasPermission) + Effects.register(EffectLuckPermGivePermission) + } + + override fun getPluginName(): String { + return "LuckPerms" + } + + fun Player.getLuckPermsUser(): User? { + return LuckPermsProvider.get().userManager.getUser(uniqueId) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt new file mode 100644 index 000000000..4b5d13cfc --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt @@ -0,0 +1,30 @@ +package com.willfp.libreforge.integrations.luckperms.impl + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.conditions.Condition +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import org.bukkit.entity.Player + +object ConditionLuckPermHasPermission : Condition("has_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun isMet( + dispatcher: Dispatcher<*>, + config: Config, + holder: ProvidedHolder, + compileData: NoCompileData + ): Boolean { + val player = dispatcher.get() ?: return false + + val user = player.getLuckPermsUser() ?: return false + + return user.cachedData.permissionData.checkPermission(config.getString("permission")).asBoolean() + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt new file mode 100644 index 000000000..f2ead1ffe --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt @@ -0,0 +1,56 @@ +package com.willfp.libreforge.integrations.luckperms.impl + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.core.map.listMap +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.effects.Identifiers +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import net.luckperms.api.node.types.PermissionNode +import org.bukkit.entity.Player +import java.util.UUID + +object EffectLuckPermGivePermission : Effect("give_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + private val permissions = listMap() + + override fun onEnable( + dispatcher: Dispatcher<*>, + config: Config, + identifiers: Identifiers, + holder: ProvidedHolder, + compileData: NoCompileData + ) { + val player = dispatcher.get() ?: return + val user = player.getLuckPermsUser() ?: return + val permission = config.getString("permission") + + val node = PermissionNode.builder(permission).value(true).build() + + permissions[player.uniqueId].add(GivenPermission(node, player.uniqueId)) + user.data().add(node) + } + + override fun onDisable(dispatcher: Dispatcher<*>, identifiers: Identifiers, holder: ProvidedHolder) { + val player = dispatcher.get() ?: return + val user = player.getLuckPermsUser() ?: return + + val givenPermission = permissions[player.uniqueId] + .firstOrNull { it.uuid == identifiers.uuid } ?: return + + permissions[player.uniqueId].remove(givenPermission) + user.data().remove(givenPermission.node) + } + + private data class GivenPermission( + val node: PermissionNode, + val uuid: UUID + ) +} \ No newline at end of file diff --git a/core/common/src/main/resources/plugin.yml b/core/common/src/main/resources/plugin.yml index 31b9661f6..7e3771c64 100644 --- a/core/common/src/main/resources/plugin.yml +++ b/core/common/src/main/resources/plugin.yml @@ -37,6 +37,7 @@ softdepend: - CustomFishing - Lands - EdPrison + - LuckPerms commands: lrcdb: From 06f543613086e3e32f56bda1f6a59956cd69cec1 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Tue, 10 Mar 2026 20:11:58 +0200 Subject: [PATCH 2/3] Fix give_permission not saving the permission --- .../libreforge/integrations/luckperms/LuckPermsIntegration.kt | 4 ++++ .../luckperms/impl/EffectLuckPermGivePermission.kt | 3 +++ 2 files changed, 7 insertions(+) diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt index 5079c0fa7..4fc3c84d5 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt @@ -23,4 +23,8 @@ object LuckPermsIntegration : LoadableIntegration { fun Player.getLuckPermsUser(): User? { return LuckPermsProvider.get().userManager.getUser(uniqueId) } + + fun User.saveChanges() { + LuckPermsProvider.get().userManager.saveUser(this) + } } diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt index f2ead1ffe..2fcd32c1e 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt @@ -10,6 +10,7 @@ import com.willfp.libreforge.effects.Effect import com.willfp.libreforge.effects.Identifiers import com.willfp.libreforge.get import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges import net.luckperms.api.node.types.PermissionNode import org.bukkit.entity.Player import java.util.UUID @@ -36,6 +37,7 @@ object EffectLuckPermGivePermission : Effect("give_permission") { permissions[player.uniqueId].add(GivenPermission(node, player.uniqueId)) user.data().add(node) + user.saveChanges() } override fun onDisable(dispatcher: Dispatcher<*>, identifiers: Identifiers, holder: ProvidedHolder) { @@ -47,6 +49,7 @@ object EffectLuckPermGivePermission : Effect("give_permission") { permissions[player.uniqueId].remove(givenPermission) user.data().remove(givenPermission.node) + user.saveChanges() } private data class GivenPermission( From 0cdd87582947a33709630548838710661eacab6b Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Wed, 18 Mar 2026 10:23:08 +0200 Subject: [PATCH 3/3] Add a lot more effects/conditions/triggers for luckperms --- .../luckperms/LuckPermsIntegration.kt | 53 ++++++++++- .../impl/group/ConditionLuckPermInGroup.kt | 36 ++++++++ .../group/EffectLuckPermDisinheritGroup.kt | 46 ++++++++++ .../impl/group/EffectLuckPermInheritGroup.kt | 53 +++++++++++ .../impl/group/TriggerLuckPermsGroupChange.kt | 24 +++++ .../group/TriggerLuckPermsGroupDisinherit.kt | 35 ++++++++ .../group/TriggerLuckPermsGroupInherit.kt | 35 ++++++++ .../impl/meta/ConditionLuckPermCheckMeta.kt | 32 +++++++ .../impl/meta/EffectLuckPermRemoveMeta.kt | 47 ++++++++++ .../impl/meta/EffectLuckPermSetMeta.kt | 53 +++++++++++ .../impl/meta/TriggerLuckPermsMetaAdd.kt | 35 ++++++++ .../impl/meta/TriggerLuckPermsMetaChange.kt | 24 +++++ .../impl/meta/TriggerLuckPermsMetaRemove.kt | 35 ++++++++ .../ConditionLuckPermHasPermission.kt | 12 ++- .../EffectLuckPermGivePermission.kt | 44 ++++++++-- .../perms/EffectLuckPermRemovePermission.kt | 46 ++++++++++ .../impl/perms/EffectLuckPermSetPermission.kt | 53 +++++++++++ .../perms/TriggerLuckPermsPermissionAdd.kt | 35 ++++++++ .../perms/TriggerLuckPermsPermissionChange.kt | 24 +++++ .../perms/TriggerLuckPermsPermissionRemove.kt | 35 ++++++++ .../EffectLuckPermGiveRegexPermission.kt | 88 +++++++++++++++++++ .../EffectLuckPermRemoveRegexPermission.kt | 47 ++++++++++ .../regex/EffectLuckPermSetRegexPermission.kt | 54 ++++++++++++ .../TriggerLuckPermsRegexPermissionAdd.kt | 35 ++++++++ .../TriggerLuckPermsRegexPermissionChange.kt | 24 +++++ .../TriggerLuckPermsRegexPermissionRemove.kt | 35 ++++++++ 26 files changed, 1026 insertions(+), 14 deletions(-) create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt rename core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/{ => perms}/ConditionLuckPermHasPermission.kt (67%) rename core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/{ => perms}/EffectLuckPermGivePermission.kt (58%) create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt create mode 100644 core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt index 4fc3c84d5..91c471c05 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt @@ -4,8 +4,32 @@ import com.willfp.eco.core.EcoPlugin import com.willfp.libreforge.conditions.Conditions import com.willfp.libreforge.effects.Effects import com.willfp.libreforge.integrations.LoadableIntegration -import com.willfp.libreforge.integrations.luckperms.impl.ConditionLuckPermHasPermission -import com.willfp.libreforge.integrations.luckperms.impl.EffectLuckPermGivePermission +import com.willfp.libreforge.integrations.luckperms.impl.group.ConditionLuckPermInGroup +import com.willfp.libreforge.integrations.luckperms.impl.group.EffectLuckPermDisinheritGroup +import com.willfp.libreforge.integrations.luckperms.impl.group.EffectLuckPermInheritGroup +import com.willfp.libreforge.integrations.luckperms.impl.group.TriggerLuckPermsGroupChange +import com.willfp.libreforge.integrations.luckperms.impl.group.TriggerLuckPermsGroupDisinherit +import com.willfp.libreforge.integrations.luckperms.impl.group.TriggerLuckPermsGroupInherit +import com.willfp.libreforge.integrations.luckperms.impl.meta.ConditionLuckPermCheckMeta +import com.willfp.libreforge.integrations.luckperms.impl.meta.EffectLuckPermRemoveMeta +import com.willfp.libreforge.integrations.luckperms.impl.meta.EffectLuckPermSetMeta +import com.willfp.libreforge.integrations.luckperms.impl.meta.TriggerLuckPermsMetaAdd +import com.willfp.libreforge.integrations.luckperms.impl.meta.TriggerLuckPermsMetaChange +import com.willfp.libreforge.integrations.luckperms.impl.meta.TriggerLuckPermsMetaRemove +import com.willfp.libreforge.integrations.luckperms.impl.perms.ConditionLuckPermHasPermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.EffectLuckPermGivePermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.EffectLuckPermRemovePermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.EffectLuckPermSetPermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.TriggerLuckPermsPermissionAdd +import com.willfp.libreforge.integrations.luckperms.impl.perms.TriggerLuckPermsPermissionChange +import com.willfp.libreforge.integrations.luckperms.impl.perms.TriggerLuckPermsPermissionRemove +import com.willfp.libreforge.integrations.luckperms.impl.regex.EffectLuckPermGiveRegexPermission +import com.willfp.libreforge.integrations.luckperms.impl.regex.EffectLuckPermRemoveRegexPermission +import com.willfp.libreforge.integrations.luckperms.impl.regex.EffectLuckPermSetRegexPermission +import com.willfp.libreforge.integrations.luckperms.impl.regex.TriggerLuckPermsRegexPermissionAdd +import com.willfp.libreforge.integrations.luckperms.impl.regex.TriggerLuckPermsRegexPermissionChange +import com.willfp.libreforge.integrations.luckperms.impl.regex.TriggerLuckPermsRegexPermissionRemove +import com.willfp.libreforge.triggers.Triggers import net.luckperms.api.LuckPermsProvider import net.luckperms.api.model.user.User import org.bukkit.entity.Player @@ -13,7 +37,32 @@ import org.bukkit.entity.Player object LuckPermsIntegration : LoadableIntegration { override fun load(plugin: EcoPlugin) { Conditions.register(ConditionLuckPermHasPermission) + Conditions.register(ConditionLuckPermCheckMeta) + Conditions.register(ConditionLuckPermInGroup) + // Effects.register(EffectLuckPermGivePermission) + Effects.register(EffectLuckPermSetPermission) + Effects.register(EffectLuckPermRemovePermission) + Effects.register(EffectLuckPermGiveRegexPermission) + Effects.register(EffectLuckPermSetRegexPermission) + Effects.register(EffectLuckPermRemoveRegexPermission) + Effects.register(EffectLuckPermSetMeta) + Effects.register(EffectLuckPermRemoveMeta) + Effects.register(EffectLuckPermInheritGroup) + Effects.register(EffectLuckPermDisinheritGroup) + // + Triggers.register(TriggerLuckPermsPermissionAdd) + Triggers.register(TriggerLuckPermsPermissionChange) + Triggers.register(TriggerLuckPermsPermissionRemove) + Triggers.register(TriggerLuckPermsRegexPermissionAdd) + Triggers.register(TriggerLuckPermsRegexPermissionChange) + Triggers.register(TriggerLuckPermsRegexPermissionRemove) + Triggers.register(TriggerLuckPermsMetaAdd) + Triggers.register(TriggerLuckPermsMetaChange) + Triggers.register(TriggerLuckPermsMetaRemove) + Triggers.register(TriggerLuckPermsGroupInherit) + Triggers.register(TriggerLuckPermsGroupDisinherit) + Triggers.register(TriggerLuckPermsGroupChange) } override fun getPluginName(): String { diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt new file mode 100644 index 000000000..517feaf62 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt @@ -0,0 +1,36 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.conditions.Condition +import com.willfp.libreforge.get +import com.willfp.libreforge.getFormattedStrings +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import net.luckperms.api.node.NodeType +import net.luckperms.api.node.types.InheritanceNode +import org.bukkit.entity.Player + +object ConditionLuckPermInGroup : Condition("in_group") { + override val arguments = arguments { + require(listOf("group", "groups"), "You must specify the group(s)!") + } + + override fun isMet( + dispatcher: Dispatcher<*>, + config: Config, + holder: ProvidedHolder, + compileData: NoCompileData + ): Boolean { + val player = dispatcher.get() ?: return false + val user = player.getLuckPermsUser() ?: return false + + val groups = config.getFormattedStrings("groups", "group") + + return user.getNodes(NodeType.INHERITANCE) + .map(InheritanceNode::getGroupName) + .containsAll(groups) + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt new file mode 100644 index 000000000..eb4b5b949 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt @@ -0,0 +1,46 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.InheritanceNode + +object EffectLuckPermDisinheritGroup : Effect("disinherit_group") { + override val arguments = arguments { + require("group", "You must specify the group!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val group = config.getFormattedString("group") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = InheritanceNode.builder(group) + .value(true) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt new file mode 100644 index 000000000..18b49b15f --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt @@ -0,0 +1,53 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.InheritanceNode +import java.time.Duration + +object EffectLuckPermInheritGroup : Effect("inherit_group") { + override val arguments = arguments { + require("group", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val group = config.getFormattedString("group") + val value = config.getBoolOrNull("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = InheritanceNode.builder(group) + .value(value ?: true) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt new file mode 100644 index 000000000..9ebe74171 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsGroupChange : Trigger("group_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, group: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = group + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt new file mode 100644 index 000000000..06c1fcfe2 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.InheritanceNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsGroupDisinherit : Trigger("group_disinherited") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? InheritanceNode ?: return + + TriggerLuckPermsGroupChange.dispatch(player, node.groupName) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.groupName + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt new file mode 100644 index 000000000..3424ff7ee --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.InheritanceNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsGroupInherit : Trigger("group_inherited") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? InheritanceNode ?: return + + TriggerLuckPermsGroupChange.dispatch(player, node.groupName) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.groupName + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt new file mode 100644 index 000000000..bd9478752 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt @@ -0,0 +1,32 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.conditions.Condition +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import org.bukkit.entity.Player + +object ConditionLuckPermCheckMeta : Condition("check_meta") { + override val arguments = arguments { + require("key", "You must specify the key!") + require("value", "You must specify the value!") + } + + override fun isMet( + dispatcher: Dispatcher<*>, + config: Config, + holder: ProvidedHolder, + compileData: NoCompileData + ): Boolean { + val player = dispatcher.get() ?: return false + val user = player.getLuckPermsUser() ?: return false + + return user.cachedData.metaData + .getMetaValue(config.getFormattedString("key")) + .equals(config.getFormattedString("value"), ignoreCase = true) + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt new file mode 100644 index 000000000..95e68dce1 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt @@ -0,0 +1,47 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.MetaNode + +object EffectLuckPermRemoveMeta : Effect("remove_meta") { + override val arguments = arguments { + require("key", "You must specify the key!") + require("value", "You must specify the value!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val key = config.getFormattedString("key") + val value = config.getFormattedString("value") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = MetaNode.builder(key, value) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt new file mode 100644 index 000000000..25f9a0123 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt @@ -0,0 +1,53 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.MetaNode +import java.time.Duration + +object EffectLuckPermSetMeta : Effect("set_meta") { + override val arguments = arguments { + require("key", "You must specify the key!") + require("value", "You must specify the value!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val key = config.getFormattedString("key") + val value = config.getFormattedString("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = MetaNode.builder(key, value) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt new file mode 100644 index 000000000..312f3e298 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.MetaNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsMetaAdd : Trigger("meta_added") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? MetaNode ?: return + + TriggerLuckPermsMetaChange.dispatch(player, node.metaKey, node.metaValue) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = "${node.metaKey}:${node.metaValue}" + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt new file mode 100644 index 000000000..5b52a4ab9 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsMetaChange : Trigger("meta_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, key: String, value: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = "$key:$value" + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt new file mode 100644 index 000000000..b14ed120b --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.MetaNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsMetaRemove : Trigger("meta_removed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? MetaNode ?: return + + TriggerLuckPermsMetaChange.dispatch(player, node.metaKey, node.metaValue) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = "${node.metaKey}:${node.metaValue}" + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/ConditionLuckPermHasPermission.kt similarity index 67% rename from core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt rename to core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/ConditionLuckPermHasPermission.kt index 4b5d13cfc..65d5f29cf 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/ConditionLuckPermHasPermission.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/ConditionLuckPermHasPermission.kt @@ -1,4 +1,4 @@ -package com.willfp.libreforge.integrations.luckperms.impl +package com.willfp.libreforge.integrations.luckperms.impl.perms import com.willfp.eco.core.config.interfaces.Config import com.willfp.libreforge.Dispatcher @@ -7,12 +7,13 @@ import com.willfp.libreforge.ProvidedHolder import com.willfp.libreforge.arguments import com.willfp.libreforge.conditions.Condition import com.willfp.libreforge.get +import com.willfp.libreforge.getFormattedStrings import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser import org.bukkit.entity.Player object ConditionLuckPermHasPermission : Condition("has_permission") { override val arguments = arguments { - require("permission", "You must specify the permission!") + require(listOf("permission", "permissions"), "You must specify the permission(s)!") } override fun isMet( @@ -22,9 +23,12 @@ object ConditionLuckPermHasPermission : Condition("has_permission compileData: NoCompileData ): Boolean { val player = dispatcher.get() ?: return false - val user = player.getLuckPermsUser() ?: return false - return user.cachedData.permissionData.checkPermission(config.getString("permission")).asBoolean() + val cached = user.cachedData.permissionData + + val permissions = config.getFormattedStrings("permissions", "permission") + + return permissions.all { cached.checkPermission(it).asBoolean() } } } \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermGivePermission.kt similarity index 58% rename from core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt rename to core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermGivePermission.kt index 2fcd32c1e..c8c818022 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/EffectLuckPermGivePermission.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermGivePermission.kt @@ -1,4 +1,4 @@ -package com.willfp.libreforge.integrations.luckperms.impl +package com.willfp.libreforge.integrations.luckperms.impl.perms import com.willfp.eco.core.config.interfaces.Config import com.willfp.eco.core.map.listMap @@ -11,6 +11,7 @@ import com.willfp.libreforge.effects.Identifiers import com.willfp.libreforge.get import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import net.luckperms.api.context.ImmutableContextSet import net.luckperms.api.node.types.PermissionNode import org.bukkit.entity.Player import java.util.UUID @@ -30,10 +31,28 @@ object EffectLuckPermGivePermission : Effect("give_permission") { compileData: NoCompileData ) { val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + val user = player.getLuckPermsUser() ?: return - val permission = config.getString("permission") + val permission = config.getFormattedString("permission") + val value = config.getBoolOrNull("value") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() - val node = PermissionNode.builder(permission).value(true).build() + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = PermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .build() permissions[player.uniqueId].add(GivenPermission(node, player.uniqueId)) user.data().add(node) @@ -42,14 +61,23 @@ object EffectLuckPermGivePermission : Effect("give_permission") { override fun onDisable(dispatcher: Dispatcher<*>, identifiers: Identifiers, holder: ProvidedHolder) { val player = dispatcher.get() ?: return - val user = player.getLuckPermsUser() ?: return - val givenPermission = permissions[player.uniqueId] + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = permissions[player.uniqueId] .firstOrNull { it.uuid == identifiers.uuid } ?: return - permissions[player.uniqueId].remove(givenPermission) - user.data().remove(givenPermission.node) - user.saveChanges() + permissions[player.uniqueId].remove(permission) + + // Remove the permission only if no other effect is giving it + if (permissions[dispatcher.uuid].none { it.node == permission.node }) { + user.data().remove(permission.node) + user.saveChanges() + } } private data class GivenPermission( diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt new file mode 100644 index 000000000..8c37dfaf1 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt @@ -0,0 +1,46 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.PermissionNode + +object EffectLuckPermRemovePermission : Effect("remove_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = config.getFormattedString("permission") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = PermissionNode.builder(permission) + .value(true) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt new file mode 100644 index 000000000..091a39140 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt @@ -0,0 +1,53 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.PermissionNode +import java.time.Duration + +object EffectLuckPermSetPermission : Effect("set_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = config.getFormattedString("permission") + val value = config.getBoolOrNull("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = PermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt new file mode 100644 index 000000000..f709a7dc9 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.PermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsPermissionAdd : Trigger("permission_added") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? PermissionNode ?: return + + TriggerLuckPermsPermissionChange.dispatch(player, node.permission) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.permission + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt new file mode 100644 index 000000000..45adc75c6 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsPermissionChange : Trigger("permission_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, permission: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = permission + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt new file mode 100644 index 000000000..ebab5d58d --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.PermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsPermissionRemove : Trigger("permission_removed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? PermissionNode ?: return + + TriggerLuckPermsPermissionChange.dispatch(player, node.permission) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.permission + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt new file mode 100644 index 000000000..13ec7dce1 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt @@ -0,0 +1,88 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.core.map.listMap +import com.willfp.eco.util.PatternUtils +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.effects.Identifiers +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.RegexPermissionNode +import org.bukkit.entity.Player +import java.util.UUID + +object EffectLuckPermGiveRegexPermission : Effect("give_regex_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + private val permissions = listMap() + + override fun onEnable( + dispatcher: Dispatcher<*>, + config: Config, + identifiers: Identifiers, + holder: ProvidedHolder, + compileData: NoCompileData + ) { + val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = PatternUtils.compileLiteral(config.getFormattedString("permission")) + val value = config.getBoolOrNull("value") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = RegexPermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .build() + + permissions[player.uniqueId].add(GivenPermission(node, player.uniqueId)) + user.data().add(node) + user.saveChanges() + } + + override fun onDisable(dispatcher: Dispatcher<*>, identifiers: Identifiers, holder: ProvidedHolder) { + val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = permissions[player.uniqueId] + .firstOrNull { it.uuid == identifiers.uuid } ?: return + + permissions[player.uniqueId].remove(permission) + + // Remove the permission only if no other effect is giving it + if (permissions[dispatcher.uuid].none { it.node == permission.node }) { + user.data().remove(permission.node) + user.saveChanges() + } + } + + private data class GivenPermission( + val node: RegexPermissionNode, + val uuid: UUID + ) +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt new file mode 100644 index 000000000..c21bde3a0 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt @@ -0,0 +1,47 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.util.PatternUtils +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.RegexPermissionNode + +object EffectLuckPermRemoveRegexPermission : Effect("remove_regex_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = PatternUtils.compileLiteral(config.getFormattedString("permission")) + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = RegexPermissionNode.builder(permission) + .value(true) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt new file mode 100644 index 000000000..0b4b58d46 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt @@ -0,0 +1,54 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.util.PatternUtils +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.RegexPermissionNode +import java.time.Duration + +object EffectLuckPermSetRegexPermission : Effect("set_regex_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = PatternUtils.compileLiteral(config.getFormattedString("permission")) + val value = config.getBoolOrNull("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = RegexPermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt new file mode 100644 index 000000000..55b8a64ea --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.RegexPermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsRegexPermissionAdd : Trigger("regex_permission_added") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? RegexPermissionNode ?: return + + TriggerLuckPermsRegexPermissionChange.dispatch(player, node.patternString) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.patternString + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt new file mode 100644 index 000000000..4eb73636b --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsRegexPermissionChange : Trigger("regex_permission_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, regex: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = regex + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt new file mode 100644 index 000000000..0e01a6526 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.RegexPermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsRegexPermissionRemove : Trigger("regex_permission_removed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? RegexPermissionNode ?: return + + TriggerLuckPermsRegexPermissionChange.dispatch(player, node.patternString) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.patternString + ) + ) + } +}