Completed kotlin rewrite

eco-core/core-plugin/src/main/kotlin/com/willfp/talismans/TalismansPlugin.kt

@@ -29,7 +29,7 @@ class TalismansPlugin : EcoPlugin(611, 9865, "&6", true) {
         CustomItem(
             this.namespacedKeyFactory.create("any_talisman"),
             { test -> TalismanChecks.getTalismanOnItem(test) != null },
-            Talismans.values()[0].getLevel(1)!!.itemStack
+            Talismans.values()[0].itemStack
         ).register()
     }
 

eco-core/core-plugin/src/main/kotlin/com/willfp/talismans/talismans/util/TalismanChecks.kt

@@ -1,92 +1,50 @@
-package com.willfp.talismans.talismans.util;
+package com.willfp.talismans.talismans.util
 
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.config.updating.ConfigUpdater;
-import com.willfp.talismans.TalismansPlugin;
-import com.willfp.talismans.talismans.Talisman;
-import com.willfp.talismans.talismans.Talismans;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.ShulkerBox;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.BlockStateMeta;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.persistence.PersistentDataContainer;
-import org.bukkit.persistence.PersistentDataType;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.config.updating.ConfigUpdater
+import com.willfp.talismans.TalismansPlugin.Companion.instance
+import com.willfp.talismans.talismans.Talisman
+import com.willfp.talismans.talismans.Talismans.getByID
+import com.willfp.talismans.talismans.util.TalismanUtils.convert
+import com.willfp.talismans.talismans.util.TalismanUtils.getLimit
+import com.willfp.talismans.talismans.util.TalismanUtils.isTalismanMaterial
+import org.bukkit.block.ShulkerBox
+import org.bukkit.entity.Player
+import org.bukkit.inventory.Inventory
+import org.bukkit.inventory.ItemStack
+import org.bukkit.inventory.meta.BlockStateMeta
+import org.bukkit.persistence.PersistentDataType
+import java.util.*
+import java.util.function.Function
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.WeakHashMap;
-import java.util.function.Function;
+object TalismanChecks {
+    private val CACHED_TALISMANS = Collections.synchronizedMap(HashMap<UUID, Set<Talisman>>())
+    private val CACHED_TALISMAN_ITEMS = Collections.synchronizedMap(WeakHashMap<UUID, Set<ItemStack>>())
+    private val PROVIDERS: MutableSet<Function<Player, List<ItemStack>>> = HashSet()
 
-public class TalismanChecks {
-    /**
-     * Cached talismans.
-     */
-    public static final Map<UUID, Set<Talisman>> CACHED_TALISMANS = Collections.synchronizedMap(new HashMap<>());
+    private var readEnderChest = true
+    private var readShulkerBoxes = true
+    private var offhandOnly = false
 
-    /**
-     * Cached items.
-     */
-    public static final Map<UUID, Set<ItemStack>> CACHED_TALISMAN_ITEMS = Collections.synchronizedMap(new WeakHashMap<>());
-
-    /**
-     * All providers.
-     */
-    private static final Set<Function<Player, List<ItemStack>>> PROVIDERS = new HashSet<>();
-
-    /**
-     * If ender chests should be checked.
-     */
-    private static boolean readEnderChest = true;
-
-    /**
-     * If shulker boxes should be read.
-     */
-    private static boolean readShulkerBoxes = true;
-
-    /**
-     * If only offhand should be read.
-     */
-    private static boolean offhandOnly = false;
-
-    /**
-     * Instance of talismans.
-     */
-    private static final EcoPlugin PLUGIN = TalismansPlugin.getInstance();
+    private val PLUGIN: EcoPlugin = instance
 
     /**
      * Does the specified ItemStack have a certain Talisman present?
      *
-     * @param item     The {@link ItemStack} to check
+     * @param item     The [ItemStack] to check
      * @param talisman The talisman to query
      * @return If the item has the queried talisman
      */
-    public static boolean item(@Nullable final ItemStack item,
-                               @NotNull final Talisman talisman) {
+    fun item(
+        item: ItemStack?,
+        talisman: Talisman
+    ): Boolean {
         if (item == null) {
-            return false;
+            return false
         }
-
-        ItemMeta meta = item.getItemMeta();
-
-        if (meta == null) {
-            return false;
-        }
-
-        PersistentDataContainer container = meta.getPersistentDataContainer();
-
-        return container.has(talisman.getKey(), PersistentDataType.INTEGER);
+        val meta = item.itemMeta ?: return false
+        val container = meta.persistentDataContainer
+        return container.has(talisman.key, PersistentDataType.INTEGER)
     }
 
     /**
@@ -95,30 +53,25 @@ public class TalismanChecks {
      * @param item The item to query.
      * @return The talisman, or null if no talisman is present.
      */
-    public static Talisman getTalismanOnItem(@Nullable final ItemStack item) {
+    fun getTalismanOnItem(item: ItemStack?): Talisman? {
         if (item == null) {
-            return null;
+            return null
         }
 
-        if (!TalismanUtils.isTalismanMaterial(item.getType())) {
-            return null;
+        if (!isTalismanMaterial(item.type)) {
+            return null
         }
 
-        ItemMeta meta = item.getItemMeta();
+        val meta = item.itemMeta ?: return null
 
-        if (meta == null) {
-            return null;
-        }
+        val container = meta.persistentDataContainer
 
-        PersistentDataContainer container = meta.getPersistentDataContainer();
-        String id = container.get(PLUGIN.getNamespacedKeyFactory().create("talisman"), PersistentDataType.STRING);
-        if (id == null) {
-            return null;
-        }
+        val id = container.get(
+            PLUGIN.namespacedKeyFactory.create("talisman"),
+            PersistentDataType.STRING
+        ) ?: return null
 
-        Talisman talisman = Talismans.getByID(id);
-
-        return talisman;
+        return getByID(id)
     }
 
     /**
@@ -127,11 +80,10 @@ public class TalismanChecks {
      * @param player The player to query.
      * @return A set of all found talismans.
      */
-    public static Set<Talisman> getTalismansOnPlayer(@NotNull final Player player) {
-        return getTalismansOnPlayer(player, true);
+    fun getTalismansOnPlayer(player: Player): Set<Talisman> {
+        return getTalismansOnPlayer(player, true)
     }
 
-
     /**
      * Get all talismans ItemStacks that a player has active.
      *
@@ -140,82 +92,78 @@ public class TalismanChecks {
      * @param extra    Bonus items.
      * @return A set of all found talismans.
      */
-    public static Set<ItemStack> getTalismanItemsOnPlayer(@NotNull final Player player,
-                                                         final boolean useCache,
-                                                         @NotNull final ItemStack... extra) {
+    fun getTalismanItemsOnPlayer(
+        player: Player,
+        useCache: Boolean,
+        vararg extra: ItemStack?
+    ): Set<ItemStack> {
         if (useCache) {
-            Set<ItemStack> cached = CACHED_TALISMAN_ITEMS.get(player.getUniqueId());
+            val cached = CACHED_TALISMAN_ITEMS[player.uniqueId]
             if (cached != null) {
-                return cached;
+                return cached
             }
         }
 
-        List<ItemStack> contents = new ArrayList<>();
-
-        List<ItemStack> rawContents = new ArrayList<>(Arrays.asList(player.getInventory().getContents()));
+        val contents = mutableListOf<ItemStack>()
+        val rawContents = player.inventory.contents.toMutableList()
 
         if (readEnderChest) {
-            Inventory enderChest = player.getEnderChest();
+            val enderChest = player.enderChest as Inventory?
 
             // Not always true, bug reported where it was null.
             if (enderChest != null) {
-                rawContents.addAll(Arrays.asList(enderChest.getContents()));
+                rawContents.addAll(enderChest.contents)
             }
         }
 
         if (offhandOnly) {
-            rawContents.clear();
-            rawContents.add(player.getInventory().getItemInOffHand());
+            rawContents.clear()
+            rawContents.add(player.inventory.itemInOffHand)
         }
 
-        rawContents.addAll(Arrays.asList(extra));
-
-        for (Function<Player, List<ItemStack>> provider : PROVIDERS) {
-            rawContents.addAll(provider.apply(player));
+        rawContents.addAll(extra)
+        for (provider in PROVIDERS) {
+            rawContents.addAll(provider.apply(player))
         }
 
-        for (ItemStack rawContent : rawContents) {
+        for (rawContent in rawContents) {
             if (rawContent == null) {
-                continue;
+                continue
             }
             if (readShulkerBoxes) {
-                ItemMeta meta = rawContent.getItemMeta();
-                if (meta instanceof BlockStateMeta shulkerMeta) {
+                val meta = rawContent.itemMeta
+                if (meta is BlockStateMeta) {
+                    val shulkerMeta = meta
                     if (!shulkerMeta.hasBlockState()) {
-                        continue;
+                        continue
                     }
-
-                    BlockState state = shulkerMeta.getBlockState();
-                    if (state instanceof ShulkerBox shulkerBox) {
-                        contents.addAll(Arrays.asList(shulkerBox.getInventory().getContents()));
-                        continue;
+                    val state = shulkerMeta.blockState
+                    if (state is ShulkerBox) {
+                        contents.addAll(Arrays.asList(*state.inventory.contents))
+                        continue
                     }
                 }
             }
-            contents.add(rawContent);
+            contents.add(rawContent)
         }
 
-        Set<ItemStack> items = new HashSet<>();
+        val items: MutableSet<ItemStack> = HashSet()
 
-        for (ItemStack itemStack : contents) {
-            Talisman talisman = getTalismanOnItem(itemStack);
-            if (talisman == null) {
-                continue;
+        for (itemStack in contents) {
+            convert(itemStack)
+            getTalismanOnItem(itemStack) ?: continue
+            if (items.size >= getLimit(player)) {
+                break
             }
-
-            if (items.size() >= TalismanUtils.getLimit(player)) {
-                break;
-            }
-
-            items.add(itemStack);
+            items.add(itemStack)
         }
 
         if (useCache) {
-            CACHED_TALISMAN_ITEMS.put(player.getUniqueId(), items);
-            PLUGIN.getScheduler().runLater(() -> CACHED_TALISMAN_ITEMS.remove(player.getUniqueId()), 40);
+            CACHED_TALISMAN_ITEMS[player.uniqueId] = items
+            PLUGIN.scheduler.runLater({ CACHED_TALISMAN_ITEMS.remove(player.uniqueId) }, 40)
         }
 
-        return items;
+        return items
     }
 
     /**
@@ -226,38 +174,35 @@ public class TalismanChecks {
      * @param extra    Bonus items.
      * @return A set of all found talismans.
      */
-    public static Set<Talisman> getTalismansOnPlayer(@NotNull final Player player,
-                                                          final boolean useCache,
-                                                          @NotNull final ItemStack... extra) {
+    fun getTalismansOnPlayer(
+        player: Player,
+        useCache: Boolean,
+        vararg extra: ItemStack?
+    ): Set<Talisman> {
         if (useCache) {
-            Set<Talisman> cached = CACHED_TALISMANS.get(player.getUniqueId());
+            val cached = CACHED_TALISMANS[player.uniqueId]
             if (cached != null) {
-                return cached;
+                return cached
             }
         }
 
-        Set<ItemStack> contents = getTalismanItemsOnPlayer(player, useCache, extra);
-        Set<Talisman> found = new HashSet<>();
+        val contents = getTalismanItemsOnPlayer(player, useCache, *extra)
+        val found: MutableSet<Talisman> = HashSet()
 
-        for (ItemStack itemStack : contents) {
-            Talisman talisman = getTalismanOnItem(itemStack);
-            if (talisman == null) {
-                continue;
+        for (itemStack in contents) {
+            val talisman = getTalismanOnItem(itemStack) ?: continue
+            if (found.size >= getLimit(player)) {
+                break
             }
-
-            if (found.size() >= TalismanUtils.getLimit(player)) {
-                break;
-            }
-
-            found.add(talisman);
+            found.add(talisman)
         }
 
         if (useCache) {
-            CACHED_TALISMANS.put(player.getUniqueId(), found);
-            PLUGIN.getScheduler().runLater(() -> CACHED_TALISMANS.remove(player.getUniqueId()), 40);
+            CACHED_TALISMANS[player.uniqueId] = found
+            PLUGIN.scheduler.runLater({ CACHED_TALISMANS.remove(player.uniqueId) }, 40)
         }
 
-        return found;
+        return found
     }
 
     /**
@@ -265,9 +210,9 @@ public class TalismanChecks {
      *
      * @param player The player.
      */
-    public static void clearCache(@NotNull final Player player) {
-        CACHED_TALISMAN_ITEMS.remove(player.getUniqueId());
-        CACHED_TALISMANS.remove(player.getUniqueId());
+    fun clearCache(player: Player) {
+        CACHED_TALISMAN_ITEMS.remove(player.uniqueId)
+        CACHED_TALISMANS.remove(player.uniqueId)
     }
 
     /**
@@ -275,8 +220,8 @@ public class TalismanChecks {
      *
      * @param provider The provider.
      */
-    public static void regsiterItemStackProvider(@NotNull final Function<Player, List<ItemStack>> provider) {
-        PROVIDERS.add(provider);
+    fun regsiterItemStackProvider(provider: Function<Player, List<ItemStack>>) {
+        PROVIDERS.add(provider)
     }
 
     /**
@@ -286,9 +231,11 @@ public class TalismanChecks {
      * @param talisman The talisman to search for.
      * @return A set of all found talismans.
      */
-    public static boolean hasTalisman(@NotNull final Player player,
-                                      @NotNull final Talisman talisman) {
-        return getTalismansOnPlayer(player).contains(talisman);
+    fun hasTalisman(
+        player: Player,
+        talisman: Talisman
+    ): Boolean {
+        return getTalismansOnPlayer(player).contains(talisman)
     }
 
     /**
@@ -297,9 +244,9 @@ public class TalismanChecks {
      * @param plugin Instance of Talismans.
      */
     @ConfigUpdater
-    public static void reload(@NotNull final EcoPlugin plugin) {
-        readEnderChest = plugin.getConfigYml().getBool("read-enderchest");
-        readShulkerBoxes = plugin.getConfigYml().getBool("read-shulkerboxes");
-        offhandOnly = plugin.getConfigYml().getBool("offhand-only");
+    fun reload(plugin: EcoPlugin) {
+        readEnderChest = plugin.configYml.getBool("read-enderchest")
+        readShulkerBoxes = plugin.configYml.getBool("read-shulkerboxes")
+        offhandOnly = plugin.configYml.getBool("offhand-only")
     }
-}
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/talismans/talismans/util/TalismanEnableListeners.kt

@@ -1,140 +1,81 @@
-package com.willfp.talismans.talismans.util;
+package com.willfp.talismans.talismans.util
 
-import com.willfp.eco.core.EcoPlugin;
-import com.willfp.eco.core.PluginDependent;
-import com.willfp.eco.core.events.ArmorChangeEvent;
-import com.willfp.libreforge.LibReforgeUtils;
-import com.willfp.libreforge.effects.ConfiguredEffect;
-import com.willfp.talismans.talismans.Talisman;
-import com.willfp.talismans.talismans.Talismans;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityPickupItemEvent;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.event.player.PlayerItemHeldEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.jetbrains.annotations.NotNull;
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.events.ArmorChangeEvent
+import com.willfp.libreforge.updateEffects
+import com.willfp.talismans.talismans.Talismans.values
+import org.bukkit.entity.Player
+import org.bukkit.event.EventHandler
+import org.bukkit.event.Listener
+import org.bukkit.event.entity.EntityPickupItemEvent
+import org.bukkit.event.inventory.InventoryClickEvent
+import org.bukkit.event.player.PlayerDropItemEvent
+import org.bukkit.event.player.PlayerItemHeldEvent
+import org.bukkit.event.player.PlayerJoinEvent
+import org.bukkit.event.player.PlayerQuitEvent
 
-public class TalismanEnableListeners extends PluginDependent<EcoPlugin> implements Listener {
-    /**
-     * Initialize new listeners and link them to a plugin.
-     *
-     * @param plugin The plugin to link to.
-     */
-    public TalismanEnableListeners(@NotNull final EcoPlugin plugin) {
-        super(plugin);
-    }
-
-    /**
-     * Called on item pickup.
-     *
-     * @param event The event to listen for.
-     */
+class TalismanEnableListeners(private val plugin :EcoPlugin) : Listener {
     @EventHandler
-    public void onItemPickup(@NotNull final EntityPickupItemEvent event) {
-        if (!(event.getEntity() instanceof Player player)) {
-            return;
+    fun onItemPickup(event: EntityPickupItemEvent) {
+        if (event.entity !is Player) {
+            return
         }
-
-        if (!TalismanUtils.isTalismanMaterial(event.getItem().getItemStack().getType())) {
-            return;
+        val player = event.entity as Player
+        if (!TalismanUtils.isTalismanMaterial(event.item.itemStack.type)) {
+            return
         }
-
-        refreshPlayer(player);
+        refreshPlayer(player)
     }
 
-    /**
-     * Called on player join.
-     *
-     * @param event The event to listen for.
-     */
     @EventHandler
-    public void onPlayerJoin(@NotNull final PlayerJoinEvent event) {
-        refresh();
+    fun onPlayerJoin(event: PlayerJoinEvent) {
+        refresh()
     }
 
-    /**
-     * Called on player leave.
-     *
-     * @param event The event to listen for.
-     */
     @EventHandler
-    public void onPlayerLeave(@NotNull final PlayerQuitEvent event) {
-        refresh();
-
-        Player player = event.getPlayer();
-
-        for (Talisman talisman : Talismans.values()) {
-            for (ConfiguredEffect effect : talisman.getEffects()) {
-                effect.getEffect().disableForPlayer(player);
+    fun onPlayerLeave(event: PlayerQuitEvent) {
+        refresh()
+        val player = event.player
+        for (talisman in values()) {
+            for ((effect1) in talisman.effects) {
+                effect1.disableForPlayer(player)
             }
         }
     }
 
-    /**
-     * Called on item drop.
-     *
-     * @param event The event to listen for.
-     */
     @EventHandler
-    public void onInventoryDrop(@NotNull final PlayerDropItemEvent event) {
-        if (!TalismanUtils.isTalismanMaterial(event.getItemDrop().getItemStack().getType())) {
-            return;
+    fun onInventoryDrop(event: PlayerDropItemEvent) {
+        if (!TalismanUtils.isTalismanMaterial(event.itemDrop.itemStack.type)) {
+            return
         }
-
-        refreshPlayer(event.getPlayer());
+        refreshPlayer(event.player)
     }
 
-    /**
-     * Called on slot change.
-     *
-     * @param event The event to listen for.
-     */
     @EventHandler
-    public void onChangeSlot(@NotNull final PlayerItemHeldEvent event) {
-        refreshPlayer(event.getPlayer());
-
-        this.getPlugin().getScheduler().run(() -> refreshPlayer(event.getPlayer()));
+    fun onChangeSlot(event: PlayerItemHeldEvent) {
+        refreshPlayer(event.player)
+        plugin.scheduler.run { refreshPlayer(event.player) }
     }
 
-    /**
-     * Called on armor change.
-     *
-     * @param event The event to listen for.
-     */
     @EventHandler
-    public void onArmorChange(@NotNull final ArmorChangeEvent event) {
-        refreshPlayer(event.getPlayer());
+    fun onArmorChange(event: ArmorChangeEvent) {
+        refreshPlayer(event.player)
     }
 
-    /**
-     * Called on inventory click.
-     *
-     * @param event The event to listen for.
-     */
     @EventHandler
-    public void onInventoryClick(@NotNull final InventoryClickEvent event) {
-        if (!(event.getWhoClicked() instanceof Player)) {
-            return;
+    fun onInventoryClick(event: InventoryClickEvent) {
+        if (event.whoClicked !is Player) {
+            return
         }
-
-        refreshPlayer((Player) event.getWhoClicked());
+        refreshPlayer(event.whoClicked as Player)
     }
 
-    /**
-     * Force refresh all online players.
-     * <p>
-     * This is a very expensive method.
-     */
-    public void refresh() {
-        this.getPlugin().getServer().getOnlinePlayers().forEach(this::refreshPlayer);
+    private fun refresh() {
+        plugin.server.onlinePlayers.forEach { player: Player -> refreshPlayer(player) }
     }
 
-    private void refreshPlayer(@NotNull final Player player) {
-        TalismanChecks.clearCache(player);
-        LibReforgeUtils.updateEffects(player);
+    private fun refreshPlayer(player: Player) {
+        TalismanChecks.clearCache(player)
+        player.updateEffects()
     }
-}
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/talismans/talismans/util/TalismanUtils.kt

@@ -1,61 +1,56 @@
-package com.willfp.talismans.talismans.util;
+package com.willfp.talismans.talismans.util
 
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.talismans.TalismansPlugin.Companion.instance
+import org.bukkit.Material
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+import org.bukkit.persistence.PersistentDataType
 
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.permissions.PermissionAttachmentInfo;
-import org.jetbrains.annotations.NotNull;
+object TalismanUtils {
+    private val TALISMAN_MATERIALS = mutableSetOf<Material>()
+    private val PLUGIN: EcoPlugin = instance
 
-import java.util.HashSet;
-import java.util.Set;
+    fun convert(itemStack: ItemStack?) {
+        if (itemStack == null) {
+            return
+        }
+        if (!isTalismanMaterial(itemStack.type)) {
+            return
+        }
+        val meta = itemStack.itemMeta ?: return
+        val container = meta.persistentDataContainer
+        val talismanKey = container.keys.firstOrNull { it.namespace == "talismans" } ?: return
+        val level = container.get(talismanKey, PersistentDataType.INTEGER) ?: return
+        container.remove(talismanKey)
+        container.set(
+            PLUGIN.namespacedKeyFactory.create("talisman"),
+            PersistentDataType.STRING,
+            talismanKey.key + "_" + level
+        )
+        itemStack.itemMeta = meta
+    }
 
-public class TalismanUtils {
-    /**
-     * All valid materials for talismans.
-     */
-    private static final Set<Material> TALISMAN_MATERIALS = new HashSet<>();
-
-    /**
-     * Get limit for talisman reading.
-     *
-     * @param player The player to check.
-     * @return The limit.
-     */
-    public static int getLimit(@NotNull final Player player) {
-        String prefix = "talismans.limit.";
-        for (PermissionAttachmentInfo permissionAttachmentInfo : player.getEffectivePermissions()) {
-            String permission = permissionAttachmentInfo.getPermission();
+    fun getLimit(player: Player): Int {
+        val prefix = "talismans.limit."
+        for (permissionAttachmentInfo in player.effectivePermissions) {
+            val permission = permissionAttachmentInfo.permission
             if (permission.startsWith(prefix)) {
-                return Integer.parseInt(permission.substring(permission.lastIndexOf(".") + 1));
+                return permission.substring(permission.lastIndexOf(".") + 1).toInt()
             }
         }
-
-        return 100000;
+        return 100000
     }
 
-    /**
-     * Get if a talisman could exist for a material.
-     *
-     * @param material The material.
-     * @return If possible.
-     */
-    public static boolean isTalismanMaterial(@NotNull final Material material) {
-        return TALISMAN_MATERIALS.contains(material);
+    fun isTalismanMaterial(material: Material): Boolean {
+        return TALISMAN_MATERIALS.contains(material)
     }
 
-    /**
-     * Register material as valid for talisman.
-     *
-     * @param material The material.
-     */
-    public static void registerTalismanMaterial(@NotNull final Material material) {
-        TALISMAN_MATERIALS.add(material);
+    fun registerTalismanMaterial(material: Material) {
+        TALISMAN_MATERIALS.add(material)
     }
 
-    /**
-     * Unregister all materials as valid for talismans.
-     */
-    public static void clearTalismanMaterials() {
-        TALISMAN_MATERIALS.clear();
+    fun clearTalismanMaterials() {
+        TALISMAN_MATERIALS.clear()
     }
-}
+}