too much shit to remember what I did

README.md

···
+# Islanders SMP mod
+
+## Links
+
+Islanders Crown recipe: https://misode.github.io/recipe/?share=Ui1jvLH0gi

src/main/java/net/radsteve/islanders/mixin/CraftingResultSlotMixin.java

···
 import net.minecraft.item.Items;
 import net.minecraft.screen.slot.CraftingResultSlot;
 import net.minecraft.server.network.ServerPlayerEntity;
-import net.radsteve.islanders.IslandersCrown;
+import net.radsteve.islanders.SpecialItem;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
···
   @Inject(method = "onCrafted(Lnet/minecraft/item/ItemStack;)V", at = @At("HEAD"))
   private void islanders$onCrafted(ItemStack stack, CallbackInfo ci) {
     if (stack.getItem() == Items.POPPED_CHORUS_FRUIT) {
-      IslandersCrown.INSTANCE.onCraft((ServerPlayerEntity) player);
+      SpecialItem.Crown.obtained((ServerPlayerEntity) player);
     }
   }
 }

src/main/java/net/radsteve/islanders/mixin/GrindstoneScreenHandlerMixin.java

···
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.Items;
 import net.minecraft.screen.GrindstoneScreenHandler;
-import net.radsteve.islanders.IslandersCrown;
+import net.radsteve.islanders.SpecialItem;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
···
     @Inject(method = "updateResult", at = @At("HEAD"), cancellable = true)
     private void islanders$updateResult(CallbackInfo ci) {
         final ItemStack output = getOutputStack(input.getStack(0), input.getStack(1));
-        if (output.getItem().equals(Items.MACE) || IslandersCrown.INSTANCE.check(output)) {
-            ci.cancel();
+        if (SpecialItem.Companion.find(output) != null) {
+          ci.cancel();
         }
     }
 }

src/main/java/net/radsteve/islanders/mixin/ItemStackMixin.java

···
+package net.radsteve.islanders.mixin;
+
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.radsteve.islanders.rule.RuleManager;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(ItemStack.class)
+public abstract class ItemStackMixin {
+  @Shadow
+  public abstract Item getItem();
+
+  @WrapMethod(method = "getMaxCount")
+  private int islanders$getMaxCount(Operation<Integer> original) {
+    final Integer limit = RuleManager.INSTANCE.limitFor(getItem());
+
+    if (limit == null) {
+      return original.call();
+    } else {
+      return limit;
+    }
+  }
+}

src/main/java/net/radsteve/islanders/mixin/LivingEntityMixin.java

···
       return;
     }
 
-    ItemDropCallback.Companion.getEVENT().invoker().onDrop(stack, (ServerPlayerEntity) (Object) this);
+    ItemDropCallback.Companion.getEVENT().invoker().onDrop(stack, player);
   }
 }

src/main/java/net/radsteve/islanders/mixin/PlayerEntityMixin.java

···
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.player.PlayerInventory;
 import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
+import net.minecraft.scoreboard.Scoreboard;
 import net.minecraft.server.world.ServerWorld;
-import net.radsteve.islanders.IslandersCrown;
 import net.radsteve.islanders.ItemEffects;
+import net.radsteve.islanders.SpecialItem;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
···
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(PlayerEntity.class)
-public class PlayerEntityMixin {
+public abstract class PlayerEntityMixin {
   @Shadow
   @Final
   PlayerInventory inventory;
 
+  @Shadow
+  public abstract Scoreboard getScoreboard();
+
+  @Shadow
+  public abstract String getNameForScoreboard();
+
   @Inject(method = "dropInventory", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/player/PlayerInventory;dropAll()V"))
   private void islanders$dropInventory(ServerWorld world, CallbackInfo ci) {
     final LivingEntity entity = (LivingEntity) (Object) this;
···
 
     for (int idx = 0; idx < this.inventory.size(); idx++) {
       ItemStack stack = this.inventory.getStack(idx);
-      if (IslandersCrown.INSTANCE.check(stack) || stack.getItem() == Items.MACE || stack.getItem() == Items.DRAGON_EGG) {
+      if (SpecialItem.Companion.find(stack) != null) {
         ItemEffects.INSTANCE.getItemsToRegive().add(new Pair<>(stack, entity.getUuid()));
         inventory.removeStack(idx);
       }
     }
+
+    SpecialItem.getEntries().forEach(item -> {
+      if (item.getTeam().getPlayerList().contains(getNameForScoreboard())) {
+        getScoreboard().removeScoreHolderFromTeam(getNameForScoreboard(), item.getTeam());
+      }
+    });
   }
 }

src/main/java/net/radsteve/islanders/mixin/ScreenHandlerMixin.java

···
 package net.radsteve.islanders.mixin;
 
 import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.inventory.EnderChestInventory;
 import net.minecraft.item.ItemStack;
+import net.minecraft.registry.tag.ItemTags;
+import net.minecraft.screen.GenericContainerScreenHandler;
+import net.minecraft.screen.PlayerScreenHandler;
 import net.minecraft.screen.ScreenHandler;
 import net.minecraft.screen.slot.Slot;
 import net.minecraft.screen.slot.SlotActionType;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.util.collection.DefaultedList;
-import net.radsteve.islanders.event.ItemClickCallback;
+import net.radsteve.islanders.SpecialItem;
+import net.radsteve.islanders.event.ItemTransferCallback;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
···
   @Shadow
   public abstract void setCursorStack(ItemStack stack);
 
+  @Shadow public abstract Slot getSlot(int index);
+
+  @Shadow public abstract ItemStack getCursorStack();
+
   @Unique
   private void islanders$runHandlers(int slotIdx, PlayerEntity player, CallbackInfo ci) {
     final Slot slot = slots.get(slotIdx);
     final ItemStack stack = slot.getStack();
 
-    if (ItemClickCallback.Companion.getEVENT().invoker().canClick(stack, (ServerPlayerEntity) player)) {
+    if (ItemTransferCallback.Companion.getEVENT().invoker().canTransfer(stack, (ServerPlayerEntity) player)) {
       return;
     }
     setCursorStack(ItemStack.EMPTY);
···
 
   @Inject(method = "internalOnSlotClick", at = @At(value = "INVOKE", target = "Lnet/minecraft/screen/slot/Slot;canTakeItems(Lnet/minecraft/entity/player/PlayerEntity;)Z"), cancellable = true)
   private void islanders$internalOnSlotClick$canTakeItems(int slotIdx, int button, SlotActionType slotActionType, PlayerEntity player, CallbackInfo ci) {
-    islanders$runHandlers(slotIdx, player, ci);
+//    islanders$runHandlers(slotIdx, player, ci);
   }
 
   @Inject(method = "internalOnSlotClick", at = @At(value = "INVOKE", target = "Lnet/minecraft/screen/slot/Slot;onTakeItem(Lnet/minecraft/entity/player/PlayerEntity;Lnet/minecraft/item/ItemStack;)V"), cancellable = true)
   private void islanders$internalOnSlotClick$onTakeItem(int slotIdx, int button, SlotActionType slotActionType, PlayerEntity player, CallbackInfo ci) {
-    islanders$runHandlers(slotIdx, player, ci);
+//    islanders$runHandlers(slotIdx, player, ci);
+  }
+
+  @Inject(method = "internalOnSlotClick", at = @At("HEAD"), cancellable = true)
+  private void islanders$internalOnSlotClick$limits(int slotIndex, int button, SlotActionType actionType, PlayerEntity player, CallbackInfo ci) {
+    if ((ScreenHandler) (Object) this instanceof PlayerScreenHandler) {
+      return;
+    }
+
+    if (actionType == SlotActionType.QUICK_MOVE) {
+      final Slot slot = slots.get(slotIndex);
+      if (ItemTransferCallback.Companion.getEVENT().invoker().canTransfer(slot.getStack(), (ServerPlayerEntity) player)) {
+        return;
+      }
+
+      ci.cancel();
+
+      return;
+    }
+
+    final int actualScreenSlots = slots.size() - player.playerScreenHandler.slots.size() + 9 /* hotbar */;
+
+    if (actionType == SlotActionType.SWAP) {
+      final ItemStack stack = getSlot(slotIndex).getStack();
+      if (ItemTransferCallback.Companion.getEVENT().invoker().canTransfer(stack, (ServerPlayerEntity) player)) {
+        return;
+      }
+
+      ci.cancel();
+
+      return;
+    }
+
+    if (slotIndex < 0 || slotIndex > actualScreenSlots) {
+      return;
+    }
+
+    if (ItemTransferCallback.Companion.getEVENT().invoker().canTransfer(getCursorStack(), (ServerPlayerEntity) player)) {
+      ci.cancel();
+    }
+  }
+
+  @Inject(method = "internalOnSlotClick", at = @At("HEAD"), cancellable = true)
+  private void islanders$internalOnSlotClick$shulkerBoxes(int slotIndex, int button, SlotActionType actionType, PlayerEntity player, CallbackInfo ci) {
+    if (!((ScreenHandler) (Object) this instanceof GenericContainerScreenHandler handler)) {
+      return;
+    }
+
+    if (!(handler.getInventory() instanceof EnderChestInventory)) {
+      return;
+    }
+
+    if (actionType == SlotActionType.QUICK_MOVE) {
+      final Slot slot = slots.get(slotIndex);
+      if (slot.getStack().getRegistryEntry().isIn(ItemTags.SHULKER_BOXES)) {
+        ci.cancel();
+      }
+
+      return;
+    }
+
+    final int actualScreenSlots = slots.size() - player.playerScreenHandler.slots.size() + 9 /* hotbar */;
+
+    if (actionType == SlotActionType.SWAP) {
+      final ItemStack stack = player.getInventory().getStack(button);
+      if (stack.getRegistryEntry().isIn(ItemTags.SHULKER_BOXES)) {
+        ci.cancel();
+      }
+
+      return;
+    }
+
+    if (slotIndex < 0 || slotIndex > actualScreenSlots) {
+      return;
+    }
+
+    if (getCursorStack().getRegistryEntry().isIn(ItemTags.SHULKER_BOXES)) {
+      ci.cancel();
+    }
+  }
+
+  @Inject(method = "internalOnSlotClick", at = @At("HEAD"), cancellable = true)
+  private void islanders$internalOnSlotClick$specialItems(int slotIndex, int button, SlotActionType actionType, PlayerEntity player, CallbackInfo ci) {
+    if ((Object) this instanceof PlayerScreenHandler) {
+      return;
+    }
+
+    if (actionType == SlotActionType.QUICK_MOVE) {
+      final Slot slot = slots.get(slotIndex);
+      if (SpecialItem.Companion.find(slot.getStack()) != null) {
+        ci.cancel();
+      }
+
+      return;
+    }
+
+    final int actualScreenSlots = slots.size() - player.playerScreenHandler.slots.size() + 9 /* hotbar */;
+
+    if (actionType == SlotActionType.SWAP) {
+      final ItemStack stack = player.getInventory().getStack(button);
+      if (SpecialItem.Companion.find(stack) != null) {
+        ci.cancel();
+      }
+
+      return;
+    }
+
+    if (slotIndex < 0 || slotIndex > actualScreenSlots) {
+      return;
+    }
+
+    if (SpecialItem.Companion.find(getCursorStack()) != null) {
+      ci.cancel();
+    }
   }
 }

src/main/java/net/radsteve/islanders/mixin/ServerPlayNetworkHandlerMixin.java src/main/java/net/radsteve/islanders/mixin/BundleHandlerMixin.java

···
 /// This prevents special items from being put into bundles.
 /// Time counter: 5h
 @Mixin(ServerPlayNetworkHandler.class)
-public class ServerPlayNetworkHandlerMixin {
+public class BundleHandlerMixin {
   @Shadow
   public ServerPlayerEntity player;
 

src/main/java/net/radsteve/islanders/mixin/SlotMixin.java

···
 import net.minecraft.item.ItemStack;
 import net.minecraft.screen.slot.Slot;
 import net.minecraft.server.network.ServerPlayerEntity;
-import net.radsteve.islanders.event.ItemClickCallback;
+import net.radsteve.islanders.event.ItemTransferCallback;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
···
 
   @Inject(method = "tryTakeStackRange", at = @At(value = "INVOKE", target = "Lnet/minecraft/screen/slot/Slot;takeStack(I)Lnet/minecraft/item/ItemStack;"), cancellable = true)
   private void islanders$tryTakeStackRange(int min, int max, PlayerEntity player, CallbackInfoReturnable<Optional<ItemStack>> cir) {
-    final ItemStack stack = getStack();
-
-    if (ItemClickCallback.Companion.getEVENT().invoker().canClick(stack, (ServerPlayerEntity) player)) {
-      return;
-    }
-    cir.setReturnValue(Optional.empty());
+//    final ItemStack stack = getStack();
+//
+//    if (ItemTransferCallback.Companion.getEVENT().invoker().canTransfer(stack, (ServerPlayerEntity) player)) {
+//      return;
+//    }
+//    cir.setReturnValue(Optional.empty());
   }
 
   @Inject(method = "onTakeItem", at = @At("HEAD"), cancellable = true)
   private void islanders$onTakeItem(PlayerEntity player, ItemStack stack, CallbackInfo ci) {
-    if (ItemClickCallback.Companion.getEVENT().invoker().canClick(stack, (ServerPlayerEntity) player)) {
-      return;
-    }
-
-    ci.cancel();
+//    if (ItemTransferCallback.Companion.getEVENT().invoker().canTransfer(stack, (ServerPlayerEntity) player)) {
+//      return;
+//    }
+//
+//    ci.cancel();
   }
 }

src/main/kotlin/net/radsteve/islanders/Islanders.kt

···
 import net.minecraft.server.MinecraftServer
 import net.radsteve.islanders.command.animacetionCommand
 import net.radsteve.islanders.command.ruleCommand
+import net.radsteve.islanders.rule.DefaultRules
 import net.radsteve.islanders.rule.RuleHandlers
 import org.slf4j.LoggerFactory
 
···
     MaceRewards
     IslandersData
     MaceAnimation
+    DefaultRules
 
     logger.info("Initialised!")
   }

src/main/kotlin/net/radsteve/islanders/IslandersCrown.kt

···
-package net.radsteve.islanders
-
-import net.minecraft.component.DataComponentTypes
-import net.minecraft.item.ItemStack
-import net.minecraft.item.Items
-import net.minecraft.server.network.ServerPlayerEntity
-import net.minecraft.sound.SoundCategory
-import net.minecraft.sound.SoundEvents
-import net.minecraft.text.Text
-import net.minecraft.util.Formatting
-
-// https://misode.github.io/recipe/?share=Ui1jvLH0gi
-public object IslandersCrown {
-  public fun check(stack: ItemStack): Boolean {
-    return stack.item == Items.POPPED_CHORUS_FRUIT && stack.get(DataComponentTypes.CUSTOM_MODEL_DATA)?.strings?.contains("islanders") == true
-  }
-
-  public fun onCraft(player: ServerPlayerEntity) {
-    player.server.playerManager.broadcast(
-      player.displayName!!.copy()
-        .formatted(Formatting.RESET)
-        .append(
-          Text.literal(" has completed the challenge ")
-            .append(
-              Text.literal("[Obtain ").formatted(Formatting.AQUA)
-                .append(Text.literal("Islanders Crown").formatted(Formatting.BOLD))
-                .append(Text.literal("]")),
-            )
-        ),
-      false
-    )
-    player.playSoundToPlayer(SoundEvents.UI_TOAST_CHALLENGE_COMPLETE, SoundCategory.MASTER, 0.5f, 1f)
-    IslandersData.obtainCrown(player.uuid)
-  }
-}

src/main/kotlin/net/radsteve/islanders/IslandersData.kt

···
     dir.createDirectories()
   }
 
+  public fun obtainer(id: String): UUID? {
+    return dir.resolve("${id}_obtained")
+      .takeIf(Path::exists)
+      ?.let(Path::readText)
+      ?.let(UUID::fromString)
+  }
+
+  public fun obtained(id: String): Boolean {
+    return obtainer(id) != null
+  }
+
+  public fun obtained(id: String, by: UUID) {
+    dir.resolve("${id}_obtained").writeText(by.toString())
+  }
+
   public fun maceObtainer(): UUID? {
     return dir.resolve("mace_obtained")
       .takeIf(Path::exists)

src/main/kotlin/net/radsteve/islanders/ItemEffects.kt

···
 package net.radsteve.islanders
 
-import com.google.common.collect.Multimaps
 import net.fabricmc.fabric.api.entity.event.v1.ServerPlayerEvents
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents
-import net.minecraft.component.DataComponentTypes
-import net.minecraft.enchantment.Enchantments
-import net.minecraft.entity.attribute.EntityAttributeModifier
-import net.minecraft.entity.attribute.EntityAttributes
-import net.minecraft.entity.effect.StatusEffectInstance
-import net.minecraft.entity.effect.StatusEffects
 import net.minecraft.item.ItemStack
-import net.minecraft.item.Items
 import net.minecraft.server.MinecraftServer
 import net.minecraft.server.network.ServerPlayerEntity
-import net.minecraft.sound.SoundCategory
-import net.minecraft.sound.SoundEvents
-import net.minecraft.text.Text
 import net.minecraft.util.Formatting
-import net.minecraft.util.Identifier
-import net.minecraft.util.Unit
 import net.radsteve.islanders.event.ItemDropCallback
 import net.radsteve.islanders.event.ItemPickupCallback
 import java.util.UUID
···
 
   override fun onEndTick(server: MinecraftServer) {
     server.playerManager.playerList.forEach { player ->
-      val hasEgg = player.inventory.contains { stack -> stack.item === Items.DRAGON_EGG }
-      val isDarkPurple = player.nameForScoreboard in darkPurpleTeam.playerList
-      if (hasEgg && !isDarkPurple) {
-        player.scoreboard.addScoreHolderToTeam(player.nameForScoreboard, darkPurpleTeam)
-      } else if (!hasEgg && isDarkPurple) {
-        player.scoreboard.removeScoreHolderFromTeam(player.nameForScoreboard, darkPurpleTeam)
-      }
-      if (hasEgg) {
-        if (!player.hasStatusEffect(StatusEffects.GLOWING)) {
-          player.addStatusEffect(StatusEffectInstance(StatusEffects.GLOWING, 200, 0, true, false, false))
-        }
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.SPEED, 20, 0, true, false, false))
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.HASTE, 20, 0, true, false, false))
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.RESISTANCE, 20, 0, true, false, false))
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.JUMP_BOOST, 20, 0, true, false, false))
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.STRENGTH, 20, 0, true, false, false))
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.REGENERATION, 20, 0, true, false, false))
-      }
-      val mace = player.inventory.find { stack -> stack.item === Items.MACE }
-      val hasMace = mace != null
-      val isGold = player.nameForScoreboard in goldTeam.playerList
-      if (hasMace && !isGold) {
-        player.scoreboard.addScoreHolderToTeam(player.nameForScoreboard, goldTeam)
-        player.attributes.addTemporaryModifiers(
-          Multimaps.forMap(
-            mapOf(
-              EntityAttributes.MAX_HEALTH to EntityAttributeModifier(
-                Identifier.of("islanders", "mace_health_boost"),
-                10.0,
-                EntityAttributeModifier.Operation.ADD_VALUE
-              )
-            )
-          )
-        )
-        mace.set(DataComponentTypes.UNBREAKABLE, Unit.INSTANCE)
-        mace.enchant(Enchantments.WIND_BURST, 3)
-        mace.enchant(Enchantments.DENSITY, 5)
-        mace.enchant(Enchantments.FIRE_ASPECT, 2)
-      } else if (!hasMace && isGold) {
-        player.scoreboard.removeScoreHolderFromTeam(player.nameForScoreboard, goldTeam)
-        player.attributes.getCustomInstance(EntityAttributes.MAX_HEALTH)?.clearModifiers()
-      }
-      if (hasMace && !player.hasStatusEffect(StatusEffects.GLOWING)) {
-        player.addStatusEffect(StatusEffectInstance(StatusEffects.GLOWING, 200, 0, true, false, false))
-      }
-      val hasCrown = player.inventory.contains(IslandersCrown::check)
-      val isAqua = player.nameForScoreboard in aquaTeam.playerList
-
-      if (hasCrown) {
-        player.hungerManager.foodLevel = 19
-
-        if (!isAqua) {
-          player.scoreboard.addScoreHolderToTeam(player.nameForScoreboard, aquaTeam)
-        }
-
-        if (!player.hasStatusEffect(StatusEffects.GLOWING)) {
-          player.addStatusEffect(StatusEffectInstance(StatusEffects.GLOWING, 200, 0, true, false, false))
-        }
+      SpecialItem.entries.forEach { item ->
+        item.handleEffects(player, player.inventory.firstOrNull(item::check))
       }
     }
   }
 
   override fun onDrop(item: ItemStack, player: ServerPlayerEntity) {
-    if (item.item == Items.DRAGON_EGG) {
-      player.server.playerManager.broadcast(
-        player.displayName!!.copy()
-          .formatted(Formatting.RESET)
-          .append(
-            Text.literal(" dropped the ")
-              .append(Text.literal("Dragon Egg").formatted(Formatting.DARK_PURPLE, Formatting.BOLD))
-          ),
-        false
-      )
-      player.server.playerManager.playerList.forEach { player ->
-        player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT, SoundCategory.MASTER, 0.5f, 1f)
-      }
-    }
-
-    if (item.item == Items.MACE) {
-      player.server.playerManager.broadcast(
-        player.displayName!!.copy()
-          .formatted(Formatting.RESET)
-          .append(
-            Text.literal(" dropped the ")
-              .append(Text.literal("Mace").formatted(Formatting.GOLD, Formatting.BOLD))
-          ),
-        false
-      )
-      player.server.playerManager.playerList.forEach { player ->
-        player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT, SoundCategory.MASTER, 0.5f, 1f)
-      }
-    }
-
-    if (IslandersCrown.check(item)) {
-      player.server.playerManager.broadcast(
-        player.displayName!!.copy()
-          .formatted(Formatting.RESET)
-          .append(
-            Text.literal(" dropped the ")
-              .append(Text.literal("Islanders Crown").formatted(Formatting.AQUA, Formatting.BOLD))
-          ),
-        false
-      )
-      player.server.playerManager.playerList.forEach { player ->
-        player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT, SoundCategory.MASTER, 0.5f, 1f)
-      }
-    }
+    SpecialItem.find(item)?.dropped(player)
   }
 
   override fun canPickUp(item: ItemStack, player: ServerPlayerEntity): Boolean {
-    if (item.item == Items.DRAGON_EGG) {
-      if (IslandersData.hasEggBeenObtained()) {
-        player.server.playerManager.broadcast(
-          player.displayName!!.copy()
-            .formatted(Formatting.RESET)
-            .append(
-              Text.literal(" picked up the ")
-                .append(Text.literal("Dragon Egg").formatted(Formatting.DARK_PURPLE, Formatting.BOLD))
-            ),
-          false
-        )
-        player.server.playerManager.playerList.forEach { player ->
-          player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT_PLAYER, SoundCategory.MASTER, 0.5f, 1f)
-        }
-      } else {
-        IslandersData.obtainEgg(player.uuid)
-
-        player.server.playerManager.broadcast(
-          player.displayName!!.copy()
-            .formatted(Formatting.RESET)
-            .append(
-              Text.literal(" has completed the challenge ")
-                .append(
-                  Text.literal("[Obtain ").formatted(Formatting.DARK_PURPLE)
-                    .append(Text.literal("Dragon Egg").formatted(Formatting.BOLD))
-                    .append(Text.literal("]")),
-                )
-            ),
-          false
-        )
-        player.playSound(SoundEvents.UI_TOAST_CHALLENGE_COMPLETE)
-      }
-    }
-
-    if (item.item == Items.MACE) {
-      if (IslandersData.hasMaceBeenObtained()) {
-        player.server.playerManager.broadcast(
-          player.displayName!!.copy()
-            .formatted(Formatting.RESET)
-            .append(
-              Text.literal(" picked up the ")
-                .append(Text.literal("Mace").formatted(Formatting.GOLD, Formatting.BOLD))
-            ),
-          false
-        )
-        player.server.playerManager.playerList.forEach { player ->
-          player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT_PLAYER, SoundCategory.MASTER, 0.5f, 1f)
-        }
-      } else {
-        IslandersData.obtainMace(player.uuid)
-
-        player.server.playerManager.broadcast(
-          player.displayName!!.copy()
-            .formatted(Formatting.RESET)
-            .append(
-              Text.literal(" has completed the challenge ")
-                .append(
-                  Text.literal("[Obtain ").formatted(Formatting.GOLD)
-                    .append(Text.literal("Mace").formatted(Formatting.BOLD))
-                    .append(Text.literal("]")),
-                )
-            ),
-          false
-        )
-
-        player.playSound(SoundEvents.UI_TOAST_CHALLENGE_COMPLETE)
-      }
-    }
-
-    if (IslandersCrown.check(item)) {
-      player.server.playerManager.broadcast(
-        player.displayName!!.copy()
-          .formatted(Formatting.RESET)
-          .append(
-            Text.literal(" picked up the ")
-              .append(Text.literal("Islanders Crown").formatted(Formatting.AQUA, Formatting.BOLD))
-          ),
-        false
-      )
-      player.server.playerManager.playerList.forEach { player ->
-        player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT_PLAYER, SoundCategory.MASTER, 0.5f, 1f)
-      }
-    }
+    SpecialItem.find(item)?.pickedUp(player)
 
     return true
   }

src/main/kotlin/net/radsteve/islanders/MaceAnimation.kt

···
 
 public object MaceAnimation : ServerTickEvents.EndTick {
   init {
+    // play it at double speed for double swag
     ServerTickEvents.END_SERVER_TICK.register(this)
     ServerTickEvents.END_SERVER_TICK.register(this)
   }

src/main/kotlin/net/radsteve/islanders/SpecialItem.kt

···
+package net.radsteve.islanders
+
+import com.google.common.collect.Multimaps
+import net.minecraft.component.DataComponentTypes
+import net.minecraft.enchantment.Enchantments
+import net.minecraft.entity.attribute.EntityAttributeModifier
+import net.minecraft.entity.attribute.EntityAttributes
+import net.minecraft.entity.effect.StatusEffectInstance
+import net.minecraft.entity.effect.StatusEffects
+import net.minecraft.item.ItemStack
+import net.minecraft.item.Items
+import net.minecraft.scoreboard.Team
+import net.minecraft.server.network.ServerPlayerEntity
+import net.minecraft.sound.SoundCategory
+import net.minecraft.sound.SoundEvents
+import net.minecraft.text.Text
+import net.minecraft.util.Formatting
+import net.minecraft.util.Identifier
+import net.minecraft.util.Unit
+
+public enum class SpecialItem(
+  public val displayName: String,
+  public val color: Formatting,
+  public val id: String,
+) {
+  Mace("Mace", Formatting.GOLD, "mace") {
+    override fun applyEffects(player: ServerPlayerEntity, stack: ItemStack) {
+      if (!player.hasStatusEffect(StatusEffects.GLOWING)) {
+        player.addStatusEffect(StatusEffectInstance(StatusEffects.GLOWING, 200, 0, true, false, false))
+      }
+
+      player.attributes.addTemporaryModifiers(
+        Multimaps.forMap(
+          mapOf(
+            EntityAttributes.MAX_HEALTH to EntityAttributeModifier(
+              Identifier.of("islanders", "mace_health_boost"),
+              10.0,
+              EntityAttributeModifier.Operation.ADD_VALUE
+            )
+          )
+        )
+      )
+      stack.set(DataComponentTypes.UNBREAKABLE, Unit.INSTANCE)
+      stack.enchant(Enchantments.WIND_BURST, 3)
+      stack.enchant(Enchantments.DENSITY, 5)
+      stack.enchant(Enchantments.FIRE_ASPECT, 2)
+    }
+
+    override fun check(stack: ItemStack): Boolean {
+      return stack.item == Items.MACE
+    }
+
+    override fun deapplyEffects(player: ServerPlayerEntity) {
+      player.attributes.getCustomInstance(EntityAttributes.MAX_HEALTH)?.clearModifiers()
+    }
+  },
+  DragonEgg("Dragon Egg", Formatting.DARK_PURPLE, "egg") {
+    override fun applyEffects(player: ServerPlayerEntity, stack: ItemStack) {
+      if (!player.hasStatusEffect(StatusEffects.GLOWING)) {
+        player.addStatusEffect(StatusEffectInstance(StatusEffects.GLOWING, 200, 0, true, false, false))
+      }
+      player.addStatusEffect(StatusEffectInstance(StatusEffects.SPEED, 20, 0, true, false, false))
+      player.addStatusEffect(StatusEffectInstance(StatusEffects.HASTE, 20, 0, true, false, false))
+      player.addStatusEffect(StatusEffectInstance(StatusEffects.RESISTANCE, 20, 0, true, false, false))
+      player.addStatusEffect(StatusEffectInstance(StatusEffects.JUMP_BOOST, 20, 0, true, false, false))
+      player.addStatusEffect(StatusEffectInstance(StatusEffects.STRENGTH, 20, 0, true, false, false))
+      player.addStatusEffect(StatusEffectInstance(StatusEffects.REGENERATION, 20, 0, true, false, false))
+    }
+
+    override fun check(stack: ItemStack): Boolean {
+      return stack.item == Items.DRAGON_EGG
+    }
+  },
+  Crown("Islanders Crown", Formatting.AQUA, "crown") {
+    override fun applyEffects(player: ServerPlayerEntity, stack: ItemStack) {
+      player.hungerManager.foodLevel = 19
+      if (!player.hasStatusEffect(StatusEffects.GLOWING)) {
+        player.addStatusEffect(StatusEffectInstance(StatusEffects.GLOWING, 200, 0, true, false, false))
+      }
+    }
+
+    override fun check(stack: ItemStack): Boolean {
+      return stack.item == Items.POPPED_CHORUS_FRUIT && stack.get(DataComponentTypes.CUSTOM_MODEL_DATA)?.strings?.contains("islanders") == true
+    }
+  },
+  ;
+
+  public val team: Team by lazy {
+    val board = Islanders.server.scoreboard
+    board.getTeam(id) ?: board.addTeam(id).apply {
+      color = [e-mail]
+    }
+  }
+
+  public open fun deapplyEffects(player: ServerPlayerEntity) {}
+  public open fun applyEffects(player: ServerPlayerEntity, stack: ItemStack) {}
+  public abstract fun check(stack: ItemStack): Boolean
+
+  public fun handleEffects(player: ServerPlayerEntity, stack: ItemStack?) {
+    val inTeam = player.nameForScoreboard in team.playerList
+    if (stack != null) {
+      if (!inTeam) {
+        player.server.scoreboard.addScoreHolderToTeam(player.nameForScoreboard, team)
+      }
+      applyEffects(player, stack)
+    } else if (inTeam) {
+      player.scoreboard.removeScoreHolderFromTeam(player.nameForScoreboard, team)
+      deapplyEffects(player)
+    }
+  }
+
+  public fun obtained(player: ServerPlayerEntity) {
+    player.server.playerManager.broadcast(
+      player.displayName!!.copy()
+        .formatted(Formatting.RESET)
+        .append(
+          Text.literal(" has completed the challenge ")
+            .append(
+              Text.literal("[Obtain ").formatted(color)
+                .append(Text.literal(displayName).formatted(Formatting.BOLD))
+                .append(Text.literal("]")),
+            )
+        ),
+      false
+    )
+
+    player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT_PLAYER, SoundCategory.MASTER, 0.5f, 1f)
+
+    IslandersData.obtained(id, player.uuid)
+  }
+
+  public fun pickedUp(player: ServerPlayerEntity) {
+    if (!IslandersData.obtained(id)) {
+      obtained(player)
+      return
+    }
+
+    player.server.playerManager.broadcast(
+      player.displayName!!.copy()
+        .formatted(color)
+        .append(
+          Text.literal(" picked up the ")
+            .append(Text.literal(displayName).formatted(Formatting.BOLD))
+        ),
+      false
+    )
+    player.server.playerManager.playerList.forEach { player ->
+      player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT_PLAYER, SoundCategory.MASTER, 0.5f, 1f)
+    }
+  }
+
+  public fun dropped(player: ServerPlayerEntity) {
+    player.server.playerManager.broadcast(
+      player.displayName!!.copy()
+        .formatted(color)
+        .append(
+          Text.literal(" dropped the ")
+            .append(Text.literal(displayName).formatted(Formatting.BOLD))
+        ),
+      false
+    )
+    player.server.playerManager.playerList.forEach { player ->
+      player.playSoundToPlayer(SoundEvents.ENTITY_ARROW_HIT, SoundCategory.MASTER, 0.5f, 1f)
+    }
+
+    deapplyEffects(player)
+  }
+
+  public companion object {
+    public fun find(stack: ItemStack): SpecialItem? {
+      return SpecialItem.entries.firstOrNull { item -> item.check(stack) }
+    }
+
+    public fun handleEffects(player: ServerPlayerEntity, stack: ItemStack) {
+      entries.forEach { item ->
+        if (item.check(stack)) {
+          item.handleEffects(player, stack)
+        } else if (player.nameForScoreboard in item.team.playerList) {
+          player.scoreboard.removeScoreHolderFromTeam(player.nameForScoreboard, item.team)
+          item.deapplyEffects(player)
+        }
+      }
+    }
+  }
+}

src/main/kotlin/net/radsteve/islanders/command/RuleCommand.kt

···
 import com.mojang.brigadier.CommandDispatcher
 import com.mojang.brigadier.arguments.IntegerArgumentType.integer
 import com.mojang.brigadier.builder.ArgumentBuilder
-import net.minecraft.command.argument.IdentifierArgumentType.identifier
 import net.minecraft.command.argument.RegistryKeyArgumentType.registryKey
 import net.minecraft.item.Item
 import net.minecraft.registry.Registries
···
 import net.minecraft.server.command.CommandManager
 import net.minecraft.server.command.ServerCommandSource
 import net.minecraft.text.Text.literal
-import net.minecraft.util.Identifier
 import net.radsteve.islanders.rule.ItemRule
 import net.radsteve.islanders.rule.ItemRuleInstance
 import net.radsteve.islanders.rule.RuleManager
···
 private fun ruleAddLimitedCommand(): ArgumentBuilder<ServerCommandSource, *> {
   return CommandManager.literal("limited")
     .then(
-      CommandManager.argument("id", identifier())
+      CommandManager.argument("item", registryKey(RegistryKeys.ITEM))
         .then(
-          CommandManager.argument("item", registryKey(RegistryKeys.ITEM))
-            .then(
-              CommandManager.argument("limit", integer(0))
-                .executes { ctx ->
-                  val id = ctx.getArgument("id", Identifier::class.java)
-
-                  @Suppress("UNCHECKED_CAST")
-                  val item = ctx.getArgument("item", RegistryKey::class.java) as RegistryKey<Item>
-                  val limit = ctx.getArgument("limit", Int::class.java)
+          CommandManager.argument("limit", integer(0))
+            .executes { ctx ->
+              @Suppress("UNCHECKED_CAST")
+              val item = ctx.getArgument("item", RegistryKey::class.java) as RegistryKey<Item>
+              val limit = ctx.getArgument("limit", Int::class.java)
 
-                  RuleManager.add(ItemRuleInstance(id, Registries.ITEM.get(item)!!, listOf(ItemRule.Limit(limit))))
+              RuleManager.add(ItemRuleInstance(Registries.ITEM.get(item)!!, listOf(ItemRule.Limit(limit))))
 
-                  ctx.source.sendMessage(literal("Added rule!"))
+              ctx.source.sendMessage(literal("Added rule!"))
 
-                  Command.SINGLE_SUCCESS
-                }
-            )
+              Command.SINGLE_SUCCESS
+            }
         )
     )
 }
···
 private fun ruleAddUncontainableCommand(): ArgumentBuilder<ServerCommandSource, *> {
   return CommandManager.literal("uncontainable")
     .then(
-      CommandManager.argument("id", identifier())
-        .then(
-          CommandManager.argument("item", registryKey(RegistryKeys.ITEM))
-            .executes { ctx ->
-              val id = ctx.getArgument("id", Identifier::class.java)
-
-              @Suppress("UNCHECKED_CAST")
-              val item = ctx.getArgument("item", RegistryKey::class.java) as RegistryKey<Item>
+      CommandManager.argument("item", registryKey(RegistryKeys.ITEM))
+        .executes { ctx ->
+          @Suppress("UNCHECKED_CAST")
+          val item = ctx.getArgument("item", RegistryKey::class.java) as RegistryKey<Item>
 
-              RuleManager.add(ItemRuleInstance(id, Registries.ITEM.get(item)!!, listOf(ItemRule.Uncontainable)))
+          RuleManager.add(ItemRuleInstance(Registries.ITEM.get(item)!!, listOf(ItemRule.Uncontainable)))
 
-              ctx.source.sendMessage(literal("Added rule!"))
+          ctx.source.sendMessage(literal("Added rule!"))
 
-              Command.SINGLE_SUCCESS
-            }
-        )
+          Command.SINGLE_SUCCESS
+        }
     )
 }

src/main/kotlin/net/radsteve/islanders/event/ItemClickCallback.kt

···
-package net.radsteve.islanders.event
-
-import net.fabricmc.fabric.api.event.Event
-import net.fabricmc.fabric.api.event.EventFactory
-import net.minecraft.item.ItemStack
-import net.minecraft.server.network.ServerPlayerEntity
-
-public fun interface ItemClickCallback {
-  public companion object {
-    public val EVENT: Event<ItemClickCallback> = EventFactory.createArrayBacked(
-      ItemClickCallback::class.java, ItemClickCallback { _, _ -> true }) { callbacks ->
-      ItemClickCallback { item, player ->
-        var canClick = true
-
-        callbacks.forEach { callback ->
-          if (!callback.canClick(item, player)) {
-            canClick = false
-          }
-        }
-
-        canClick
-      }
-    }
-  }
-
-  public fun canClick(item: ItemStack, player: ServerPlayerEntity): Boolean
-}

src/main/kotlin/net/radsteve/islanders/event/ItemTransferCallback.kt

···
+package net.radsteve.islanders.event
+
+import net.fabricmc.fabric.api.event.Event
+import net.fabricmc.fabric.api.event.EventFactory
+import net.minecraft.item.ItemStack
+import net.minecraft.server.network.ServerPlayerEntity
+
+public fun interface ItemTransferCallback {
+  public companion object {
+    public val EVENT: Event<ItemTransferCallback> = EventFactory.createArrayBacked(
+      ItemTransferCallback::class.java, ItemTransferCallback { _, _ -> true }) { callbacks ->
+      ItemTransferCallback { item, player ->
+        var canClick = true
+
+        callbacks.forEach { callback ->
+          if (!callback.canTransfer(item, player)) {
+            canClick = false
+          }
+        }
+
+        canClick
+      }
+    }
+  }
+
+  public fun canTransfer(item: ItemStack, player: ServerPlayerEntity): Boolean
+}

src/main/kotlin/net/radsteve/islanders/rule/DefaultRules.kt

···
+package net.radsteve.islanders.rule
+
+import net.minecraft.item.Items
+
+public object DefaultRules {
+  init {
+    val limits = mapOf(
+      Items.EXPERIENCE_BOTTLE to 64,
+      Items.COBWEB to 64,
+      Items.ENDER_PEARL to 16,
+      Items.GOLDEN_APPLE to 64,
+      Items.TOTEM_OF_UNDYING to 1,
+      Items.WIND_CHARGE to 64
+    )
+
+    limits.forEach { (item, limit) ->
+      RuleManager.add(ItemRuleInstance(item, listOf(ItemRule.Limit(limit))))
+    }
+  }
+}

src/main/kotlin/net/radsteve/islanders/rule/ItemRuleInstance.kt

···
 package net.radsteve.islanders.rule
 
 import net.minecraft.item.Item
-import net.minecraft.util.Identifier
 
 public data class ItemRuleInstance(
-  public val id: Identifier,
   public val item: Item,
   public val entries: List<ItemRule>,
 )

src/main/kotlin/net/radsteve/islanders/rule/RuleHandlers.kt

···
 import net.minecraft.entity.ItemEntity
 import net.minecraft.item.ItemStack
 import net.minecraft.server.network.ServerPlayerEntity
-import net.radsteve.islanders.event.ItemClickCallback
 import net.radsteve.islanders.event.ItemPickupCallback
+import net.radsteve.islanders.event.ItemTransferCallback
 import net.radsteve.islanders.event.ResizeItemEntityAndAddRemainingStackCallback
 
 public object RuleHandlers {
   init {
     ItemPickupCallback.EVENT.register(Limits)
-    ItemClickCallback.EVENT.register(Limits)
+    ItemTransferCallback.EVENT.register(Limits)
     ResizeItemEntityAndAddRemainingStackCallback.EVENT.register(Limits)
   }
 
-  public object Limits : ItemPickupCallback, ItemClickCallback, ResizeItemEntityAndAddRemainingStackCallback {
+  public object Limits : ItemPickupCallback, ItemTransferCallback, ResizeItemEntityAndAddRemainingStackCallback {
     private fun check(item: ItemStack, player: ServerPlayerEntity): Boolean {
-      var cancelled = false
-
-      RuleManager.ruled<ItemRule.Limit> { rule, limit ->
-        if (rule.item === item.item &&
-          player.inventory.mainStacks
-            .filter { stack -> stack.item === item.item }
-            .sumOf(ItemStack::getCount)
-          + item.count >= limit.maxAmount
-        ) {
-          cancelled = true
-        }
-      }
-
-      return !cancelled
+//      var cancelled = false
+//
+//      RuleManager.ruled<ItemRule.Limit> { rule, limit ->
+//        val itemsOnPlayer = player.inventory.mainStacks
+//          .filter { item -> item.item === rule.item }
+//          .sumOf(ItemStack::getCount)
+//
+//        if (rule.item == item.item && item.count <= limit.maxAmount && itemsOnPlayer == 0) {
+//          return@ruled
+//        }
+//
+//        if (itemsOnPlayer + item.count >= limit.maxAmount) {
+//          cancelled = true
+//        }
+//      }
+//
+      return true // FIXME - maybe?
     }
 
     override fun canPickUp(item: ItemStack, player: ServerPlayerEntity): Boolean {
       return check(item, player)
     }
 
-    override fun canClick(item: ItemStack, player: ServerPlayerEntity): Boolean {
+    override fun canTransfer(item: ItemStack, player: ServerPlayerEntity): Boolean {
       return check(item, player)
     }
 
     override fun resize(entity: ItemEntity, player: ServerPlayerEntity) {
       RuleManager.ruled<ItemRule.Limit> { rule, limit ->
-        if (rule.item == entity.stack.item &&
-          player.inventory.mainStacks
-            .filter { stack -> stack.item === entity.stack.item }
-            .sumOf(ItemStack::getCount)
-          + entity.stack.count >= limit.maxAmount
-        ) {
-          val newStack = entity.stack.copy()
-          newStack.count = entity.stack.count - limit.maxAmount
-          entity.stack = newStack
-          newStack.count = limit.maxAmount
-          player.inventory.insertStack(newStack)
+        if (rule.item != entity.stack.item) return@ruled
+        val itemsOnPlayer = player.inventory.mainStacks
+          .filter { item -> item.item === rule.item }
+          .sumOf(ItemStack::getCount)
+        val maxInsert = limit.maxAmount - itemsOnPlayer
+        if (maxInsert <= 0) return@ruled
+        val entityStack = entity.stack
+        val insertCount = minOf(entityStack.count, maxInsert)
+
+        if (insertCount > 0) {
+          val toInsert = ItemStack(entityStack.item, insertCount)
+          player.inventory.insertStack(toInsert)
+          entityStack.decrement(insertCount)
         }
       }
     }

src/main/kotlin/net/radsteve/islanders/rule/RuleManager.kt

···
 package net.radsteve.islanders.rule
 
-import net.minecraft.util.Identifier
+import net.minecraft.item.Item
 
 public object RuleManager {
   private val rules: MutableList<ItemRuleInstance> = mutableListOf()
···
     rules.add(rule)
   }
 
-  public fun remove(id: Identifier) {
-    rules.removeIf { rule -> rule.id == id }
-  }
-
   public fun forEach(block: (ItemRuleInstance) -> Unit) {
     rules.forEach(block)
+  }
+
+  public fun limitFor(item: Item): Int? {
+    return rules.find { instance -> instance.item == item }
+      ?.entries
+      ?.filterIsInstance<ItemRule.Limit>()
+      ?.firstOrNull()
+      ?.maxAmount
   }
 
   public inline fun <reified T : ItemRule> ruled(crossinline block: (ItemRuleInstance, T) -> Unit) {

src/main/resources/islanders.mixins.json

···
   "compatibilityLevel": "JAVA_21",
   "mixins": [
     "AnvilScreenHandlerMixin",
+    "BundleHandlerMixin",
     "CraftingResultSlotMixin",
     "CraftingScreenHandlerMixin",
     "GrindstoneScreenHandlerMixin",
     "ItemEntityMixin",
+    "ItemStackMixin",
     "LivingEntityAccessor",
     "LivingEntityMixin",
     "PlayerEntityMixin",
     "ScreenHandlerMixin",
-    "ServerPlayNetworkHandlerMixin",
     "SlotMixin"
   ],
   "injectors": {