### Get All Equipped Trinkets

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Returns a list of all non-empty slots and their corresponding item stacks.

```java
getAllEquipped()
```

--------------------------------

### Defining a Custom Trinket Item

Source: https://github.com/emilyploszaj/trinkets/wiki/Quick-Start-Guide

Extend TrinketItem to create a custom trinket. This example adds movement speed and an extra ring slot. Ensure the item is registered with the game.

```java
public class MyAglet extends TrinketItem {

  public MyAglet(Settings settings) {
    super(settings);
  }

  public Multimap<EntityAttribute, EntityAttributeModifier> getModifiers(ItemStack stack, SlotReference slot, LivingEntity entity, UUID uuid) {
    var modifiers = super.getModifiers(stack, slot, entity, uuid);
    // +10% movement speed
    modifiers.put(EntityAttributes.GENERIC_MOVEMENT_SPEED, new EntityAttributeModifier(uuid, "guidemod:movement_speed", 0.1, EntityAttributeModifier.Operation.MULTIPLY_TOTAL));
    // If the player has access to ring slots, this will give them an extra one
    SlotAttributes.addSlotModifier(modifiers, "hand/ring", uuid, 1, EntityAttributeModifier.Operation.ADDITION);
    return modifiers;
  }
}
```

--------------------------------

### Get Equipped Trinkets

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Retrieves a list of slots and item stacks that match the provided item or predicate.

```java
getEquipped(Item)
```

```java
getEquipped(Predicate<ItemStack>)
```

--------------------------------

### Define a Custom Charm Slot

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-Data-Formats

This JSON defines a custom charm slot. It requires an icon to be specified for the slot's appearance in the GUI. This is a basic example, and other properties can be added as needed.

```json
{
  "icon": "trinkets:gui/slots/charm"
}
```

--------------------------------

### Use Custom Predicate in Slot Configuration

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Example JSON configuration for a slot that uses a custom predicate for validation. This references the `mymod:mending_only` predicate registered in Java.

```json
// data/trinkets/slots/special/enchanted.json - Use custom predicate
{
  "icon": "mymod:gui/slots/enchanted",
  "validator_predicates": ["mymod:mending_only", "trinkets:tag"]
}
```

--------------------------------

### Get Trinket Component for Entity

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Retrieves the TrinketComponent for a given LivingEntity. Returns an optional component if present.

```java
TrinketsApi.getTrinketComponent(LivingEntity)
```

--------------------------------

### Create a Basic Trinket Item in Java

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Extend `TrinketItem` to create items that can be equipped in trinket slots. The `TrinketItem` class handles registration and right-click equipping.

```java
package com.example.mymod;

import dev.emi.trinkets.api.TrinketItem;
import net.minecraft.item.Item;

public class MyTrinket extends TrinketItem {

    public MyTrinket(Item.Settings settings) {
        super(settings);
    }
}

// Registration in ModInitializer
public class MyMod implements ModInitializer {
    public static Item MY_TRINKET;

    @Override
    public void onInitialize() {
        MY_TRINKET = Registry.register(
            Registries.ITEM,
            Identifier.of("mymod", "my_trinket"),
            new MyTrinket(new Item.Settings()
                .registryKey(RegistryKey.of(RegistryKeys.ITEM, Identifier.of("mymod", "my_trinket")))
                .maxCount(1))
        );
    }
}
```

--------------------------------

### Register Trinket Renderers

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Implement `ClientModInitializer` to register custom `TrinketRenderer` instances for your trinket items.

```java
package com.example.mymod.client;

import dev.emi.trinkets.api.SlotReference;
import dev.emi.trinkets.api.client.TrinketRenderer;
import dev.emi.trinkets.api.client.TrinketRendererRegistry;
import net.fabricmc.api.ClientModInitializer;
import net.minecraft.client.render.OverlayTexture;
import net.minecraft.client.render.VertexConsumer;
import net.minecraft.client.render.VertexConsumerProvider;
import net.minecraft.client.render.entity.model.BipedEntityModel;
import net.minecraft.client.render.entity.model.EntityModel;
import net.minecraft.client.render.entity.state.BipedEntityRenderState;
import net.minecraft.client.render.entity.state.LivingEntityRenderState;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Identifier;

public class MyModClient implements ClientModInitializer {

    @Override
    public void onInitializeClient() {
        // Register renderer for trinket item
        TrinketRendererRegistry.registerRenderer(MyMod.MY_CAPE, new CapeRenderer());
        TrinketRendererRegistry.registerRenderer(MyMod.MY_RING, new RingRenderer());
    }
}
```

--------------------------------

### Enable Entity Trinket Slots

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Create a JSON file at `data/trinkets/entities/[modid].json` to define which trinket slots are available for specific entity types.

```json
// data/trinkets/entities/mymod.json
{
  "entities": [
    "player",
    "zombie"
  ],
  "slots": [
    "head/hat",
    "head/face",
    "chest/necklace",
    "chest/cape",
    "chest/back",
    "legs/belt",
    "feet/shoes",
    "feet/aglet",
    "hand/glove",
    "hand/ring",
    "offhand/glove",
    "offhand/ring"
  ]
}
```

--------------------------------

### Add Trinkets Repositories to build.gradle

Source: https://github.com/emilyploszaj/trinkets/blob/main/README.md

Configure your build.gradle file to include the necessary repositories for Trinkets. This is required before adding Trinkets as a dependency.

```gradle
repositories {
	maven {
		name = "TerraformersMC"
		url = "https://maven.terraformersmc.com/"
	}
	maven {
		name = "Ladysnake Libs"
		url = 'https://maven.ladysnake.org/releases'
	}
}
```

--------------------------------

### Iterate Over Equipped Trinkets

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Loops over all equipped trinket slots and item stacks for an entity.

```java
forEach(TrinketComponent.SlotVisitor)
```

--------------------------------

### Specify Items for a Trinket Slot Tag

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Create a tag file at `data/trinkets/tags/items/[group]/[slot].json` to define which items are accepted by a specific trinket slot.

```json
// data/trinkets/tags/items/head/hat.json
{
  "replace": false,
  "values": [
    "mymod:my_trinket",
    "mymod:fancy_hat",
    "#mymod:all_hats"
  ]
}
```

--------------------------------

### Registering a Trinket Slot

Source: https://github.com/emilyploszaj/trinkets/wiki/Quick-Start-Guide

Use this JSON structure to enable a specific trinket slot for players. Ensure the file path matches the desired mod ID and slot.

```json
{
  "entities": [
    "player"
  ],
  "slots": [
    "feet/aglet"
  ]
}
```

--------------------------------

### Define a Custom Trinket Slot Type

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Create JSON files at `data/trinkets/slots/[group]/[slot].json` to define custom slot types, including their icon, order, and validation rules.

```json
// data/trinkets/slots/charm/charm.json
{
  "icon": "mymod:gui/slots/charm",
  "order": 0,
  "amount": 1,
  "drop_rule": "default",
  "validator_predicates": ["trinkets:tag"],
  "quick_move_predicates": ["trinkets:all"],
  "tooltip_predicates": ["trinkets:all"]
}
```

--------------------------------

### Implement Trinket Lifecycle Methods

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Override `tick`, `onEquip`, and `onUnequip` to implement custom behaviors for trinkets, such as applying status effects or handling item durability. Ensure client-side checks for server-side operations.

```java
package com.example.mymod;

import dev.emi.trinkets.api.SlotReference;
import dev.emi.trinkets.api.TrinketItem;
import dev.emi.trinkets.api.TrinketsApi;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.effect.StatusEffectInstance;
import net.minecraft.entity.effect.StatusEffects;
import net.minecraft.item.ItemStack;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;

public class GlowingAmulet extends TrinketItem {

    public GlowingAmulet(Settings settings) {
        super(settings);
    }

    @Override
    public void tick(ItemStack stack, SlotReference slot, LivingEntity entity) {
        // Apply glowing effect every tick while equipped
        if (!entity.getWorld().isClient && entity.age % 20 == 0) {
            entity.addStatusEffect(new StatusEffectInstance(
                StatusEffects.GLOWING, 30, 0, false, false, true
            ));
        }

        // Example: Damage the trinket over time
        if (entity.getWorld() instanceof ServerWorld serverWorld
                && entity instanceof ServerPlayerEntity player) {
            stack.damage(1, serverWorld, player, item -> {
                TrinketsApi.onTrinketBroken(stack, slot, entity);
            });
        }
    }

    @Override
    public void onEquip(ItemStack stack, SlotReference slot, LivingEntity entity) {
        // Called when the trinket is equipped
        if (!entity.getWorld().isClient) {
            entity.addStatusEffect(new StatusEffectInstance(
                StatusEffects.NIGHT_VISION, 600, 0
            ));
        }
    }

    @Override
    public void onUnequip(ItemStack stack, SlotReference slot, LivingEntity entity) {
        // Called when the trinket is unequipped
        if (!entity.getWorld().isClient) {
            entity.removeStatusEffect(StatusEffects.NIGHT_VISION);
        }
    }
}
```

--------------------------------

### Query Player Slots

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Retrieve slot group information for players using `TrinketsApi.getPlayerSlots()`. This can be done for a specific player or for all players on a world.

```java
package com.example.mymod;

import dev.emi.trinkets.api.SlotGroup;
import dev.emi.trinkets.api.SlotType;
import dev.emi.trinkets.api.TrinketsApi;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.world.World;

import java.util.Map;

public class SlotInfoUtils {

    // Get all slot groups available to players
    public static Map<String, SlotGroup> getPlayerSlotGroups(World world) {
        return TrinketsApi.getPlayerSlots(world);
    }

    // Get slot groups for a specific player (respects their specific configuration)
    public static Map<String, SlotGroup> getPlayerSlotGroups(PlayerEntity player) {
        return TrinketsApi.getPlayerSlots(player);
    }

    // Get slot groups for any entity type
    public static Map<String, SlotGroup> getEntitySlotGroups(World world, EntityType<?> entityType) {
        return TrinketsApi.getEntitySlots(world, entityType);
    }

    // Print all available slots for debugging
    public static void printSlotInfo(PlayerEntity player) {
        Map<String, SlotGroup> groups = TrinketsApi.getPlayerSlots(player);

        for (Map.Entry<String, SlotGroup> groupEntry : groups.entrySet()) {
            SlotGroup group = groupEntry.getValue();
            System.out.println("Group: " + group.getName() + " (order: " + group.getOrder() + ")");

            for (Map.Entry<String, SlotType> slotEntry : group.getSlots().entrySet()) {
                SlotType slot = slotEntry.getValue();
                System.out.println("  Slot: " + slot.getId());
                System.out.println("    Amount: " + slot.getAmount());
                System.out.println("    Drop Rule: " + slot.getDropRule());
                System.out.println("    Icon: " + slot.getIcon());
            }
        }
    }
}
```

--------------------------------

### Register Trinket Event Callbacks

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Register callbacks for trinket equip, unequip, and drop events. Equip and unequip callbacks play sounds, while the drop callback customizes item drop behavior on death.

```java
package com.example.mymod;

import dev.emi.trinkets.api.TrinketEnums.DropRule;
import dev.emi.trinkets.api.event.TrinketDropCallback;
import dev.emi.trinkets.api.event.TrinketEquipCallback;
import dev.emi.trinkets.api.event.TrinketUnequipCallback;
import net.fabricmc.api.ModInitializer;
import net.minecraft.sound.SoundCategory;
import net.minecraft.sound.SoundEvents;
import net.minecraft.text.Text;

public class MyMod implements ModInitializer {

    @Override
    public void onInitialize() {
        // Called when any trinket is equipped
        TrinketEquipCallback.EVENT.register((stack, slot, entity) -> {
            if (stack.isOf(MY_TRINKET)) {
                entity.getWorld().playSound(
                    null,
                    entity.getBlockPos(),
                    SoundEvents.ENTITY_EXPERIENCE_ORB_PICKUP,
                    SoundCategory.PLAYERS,
                    1.0f, 1.0f
                );
            }
        });

        // Called when any trinket is unequipped
        TrinketUnequipCallback.EVENT.register((stack, slot, entity) -> {
            if (stack.isOf(MY_TRINKET)) {
                entity.getWorld().playSound(
                    null,
                    entity.getBlockPos(),
                    SoundEvents.ITEM_TRIDENT_THUNDER.value(),
                    SoundCategory.PLAYERS,
                    0.5f, 1.0f
                );
            }
        });

        // Called when determining what happens to trinkets on death
        TrinketDropCallback.EVENT.register((rule, stack, ref, entity) -> {
            // Keep all diamond trinkets on death
            if (stack.getItem().toString().contains("diamond")) {
                return DropRule.KEEP;
            }
            // Destroy cursed items
            if (stack.getItem().toString().contains("cursed")) {
                return DropRule.DESTROY;
            }
            // Use default behavior for everything else
            return rule;
        });
    }
}

```

--------------------------------

### Add Default Slots to Players

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-Data-Formats

This JSON configuration adds the default belt, aglet, and ring slots to all players. Ensure these slots are defined in your datapack.

```json
{
  "entities": [
    "player"
  ],
  "slots": [
    "legs/belt",
    "feet/aglet",
    "hand/ring"
  ]
}
```

--------------------------------

### Ring Trinket Renderer

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Renders a ring trinket on the entity's hand. Positions the ring based on whether it's in the right or left hand slot.

```java
class RingRenderer implements TrinketRenderer {
    private static final Identifier TEXTURE = Identifier.of("mymod", "textures/entity/trinket/ring.png");
    private BipedEntityModel<BipedEntityRenderState> model;

    @Override
    public void render(ItemStack stack, SlotReference slotReference,
            EntityModel<? extends LivingEntityRenderState> contextModel,
            MatrixStack matrices, VertexConsumerProvider vertexConsumers,
            int light, LivingEntityRenderState state,
            float limbAngle, float limbDistance) {

        if (state instanceof BipedEntityRenderState bipedState) {
            BipedEntityModel<BipedEntityRenderState> model = getModel();
            TrinketRenderer.followBodyRotations(contextModel, model);

            matrices.push();

            // Position based on which hand slot
            String group = slotReference.inventory().getSlotType().getGroup();
            if (group.equals("hand")) {
                TrinketRenderer.translateToRightArm(matrices, model, bipedState);
            } else {
                TrinketRenderer.translateToLeftArm(matrices, model, bipedState);
            }

            VertexConsumer vertexConsumer = vertexConsumers.getBuffer(model.getLayer(TEXTURE));
            model.render(matrices, vertexConsumer, light, OverlayTexture.DEFAULT_UV, 1);

            matrices.pop();
        }
    }

    private BipedEntityModel<BipedEntityRenderState> getModel() {
        return model;
    }
}
```

--------------------------------

### Register a Custom Trinket Predicate

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Allows for the registration of custom predicates on the code side for use in slot configurations.

```java
TrinketsApi.registerTrinketPredicate(Identifier, TrinketPredicate)
```

--------------------------------

### Trinkets Predicates API

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Details on registering custom predicates for slots.

```APIDOC
## Trinkets Predicates API

### Description
This section explains how to register custom predicates for Trinkets slots, which can be used for validation, quick movement, and tooltips.

### Method

#### `TrinketsApi.registerTrinketPredicate(Identifier, TrinketPredicate)`
- **Description**: Registers a new custom predicate that can be used in slot configurations.
- **Parameters**:
  - `id` (Identifier) - A unique identifier for the predicate.
  - `predicate` (TrinketPredicate) - The predicate logic to register.
- **Usage**: Allows defining custom logic for slot behaviors.
```

--------------------------------

### Render Ender Pearl Trinket

Source: https://github.com/emilyploszaj/trinkets/wiki/[OLD]-Rendering-Trinkets

Override the `render` method to draw an ender pearl at the center of the player's face. Requires `ITrinket` and `MinecraftClient`.

```java
    @Override
    public void render(String slot, PlayerEntityModel<AbstractClientPlayerEntity> model, AbstractClientPlayerEntity player, float headYaw, float headPitch){
        ItemRenderer itemRenderer = MinecraftClient.getInstance().getItemRenderer();
        ItemStack stack = new ItemStack(Items.ENDER_PEARL);
        ITrinket.translateToFace(model, player, headYaw, headPitch);
        GlStateManager.scalef(0.2F, -0.2F, 0.2F);
        itemRenderer.renderItem(stack, ModelTransformation.Type.FIXED);
    }
```

--------------------------------

### Override Trinket Equip/Unequip Logic

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Override `canEquip`, `canUnequip`, and `canEquipFromUse` to control when and how trinkets can be equipped or removed. The `getEquipSound` method can be overridden to provide custom equip sounds.

```java
package com.example.mymod;

import dev.emi.trinkets.api.SlotReference;
import dev.emi.trinkets.api.TrinketItem;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.item.ItemStack;
import net.minecraft.registry.entry.RegistryEntry;
import net.minecraft.sound.SoundEvent;
import net.minecraft.sound.SoundEvents;

public class CursedRing extends TrinketItem {

    public CursedRing(Settings settings) {
        super(settings);
    }

    @Override
    public boolean canEquip(ItemStack stack, SlotReference slot, LivingEntity entity) {
        // Only allow equipping in ring slots
        return slot.inventory().getSlotType().getName().equals("ring");
    }

    @Override
    public boolean canUnequip(ItemStack stack, SlotReference slot, LivingEntity entity) {
        // Cannot be unequipped unless in creative mode
        return entity instanceof PlayerEntity player && player.isCreative();
    }

    @Override
    public boolean canEquipFromUse(ItemStack stack, LivingEntity entity) {
        // Allow right-click to equip
        return true;
    }

    @Override
    public RegistryEntry<SoundEvent> getEquipSound(ItemStack stack, SlotReference slot, LivingEntity entity) {
        // Custom equip sound
        return SoundEvents.BLOCK_ANVIL_PLACE;
    }
}
```

--------------------------------

### Add Trinkets Dependency to build.gradle

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Add the necessary Maven repositories and dependency to your build.gradle file to use Trinkets in your Fabric mod.

```gradle
// build.gradle
repositories {
    maven {
        name = "TerraformersMC"
        url = "https://maven.terraformersmc.com/"
    }
    maven {
        name = "Ladysnake Libs"
        url = 'https://maven.ladysnake.org/releases'
    }
}

dependencies {
    modImplementation "dev.emi:trinkets:3.11.0"
}
```

--------------------------------

### Add Trinkets Dependency to build.gradle

Source: https://github.com/emilyploszaj/trinkets/blob/main/README.md

Include Trinkets as a mod implementation dependency in your project's build.gradle file. Ensure the trinkets_version variable is defined.

```gradle
dependencies {
	modImplementation "dev.emi:trinkets:${trinkets_version}"
}
```

--------------------------------

### Cape Trinket Renderer

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Renders a cape trinket attached to the entity's back. Ensure the model and texture are correctly set up.

```java
class CapeRenderer implements TrinketRenderer {
    private static final Identifier TEXTURE = Identifier.of("mymod", "textures/entity/trinket/cape.png");
    private BipedEntityModel<BipedEntityRenderState> model;

    @Override
    public void render(ItemStack stack, SlotReference slotReference,
            EntityModel<? extends LivingEntityRenderState> contextModel,
            MatrixStack matrices, VertexConsumerProvider vertexConsumers,
            int light, LivingEntityRenderState state,
            float limbAngle, float limbDistance) {

        if (state instanceof BipedEntityRenderState bipedState) {
            BipedEntityModel<BipedEntityRenderState> model = getModel();

            // Copy rotations from the entity model
            TrinketRenderer.followBodyRotations(contextModel, model);

            // Position at the chest/back area
            matrices.push();
            TrinketRenderer.translateToChest(matrices, model, bipedState);

            // Render the model
            VertexConsumer vertexConsumer = vertexConsumers.getBuffer(model.getLayer(TEXTURE));
            model.render(matrices, vertexConsumer, light, OverlayTexture.DEFAULT_UV, 1);

            matrices.pop();
        }
    }

    private BipedEntityModel<BipedEntityRenderState> getModel() {
        // Create or return cached model
        return model;
    }
}
```

--------------------------------

### Trinket Components API

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Provides methods for accessing and managing trinket components associated with entities.

```APIDOC
## Trinket Components API

### Description
This section covers the API for interacting with Trinket Components, which hold data and provide access to various Trinkets features for entities.

### Methods

#### `TrinketsApi.getTrinketComponent(LivingEntity)`
- **Description**: Retrieves the TrinketComponent for a given LivingEntity. Returns an optional component if present.
- **Parameters**:
  - `entity` (LivingEntity) - The entity to get the component for.
- **Returns**: Optional<TrinketComponent>

#### `TrinketComponent.isEquipped(Item)` or `TrinketComponent.isEquipped(Predicate)`
- **Description**: Checks if an item or an item matching a predicate is currently equipped by the entity.
- **Parameters**:
  - `item` (Item) or `predicate` (Predicate) - The item or predicate to check for.
- **Returns**: boolean

#### `TrinketComponent.getEquipped(Item)` or `TrinketComponent.getEquipped(Predicate)`
- **Description**: Returns a list of equipped slots and stacks that match the given item or predicate.
- **Parameters**:
  - `item` (Item) or `predicate` (Predicate) - The item or predicate to search for.
- **Returns**: List<Pair<Slot, ItemStack>>

#### `TrinketComponent.getAllEquipped()`
- **Description**: Returns a list of all non-empty equipped slots and their corresponding item stacks.
- **Returns**: List<Pair<Slot, ItemStack>>

#### `TrinketComponent.forEach(Consumer<Pair<Slot, ItemStack>>)`
- **Description**: Iterates over all equipped slots and item stacks for the entity, applying the provided consumer.
- **Parameters**:
  - `consumer` (Consumer<Pair<Slot, ItemStack>>) - The action to perform for each equipped item.
```

--------------------------------

### Access TrinketComponent for Entity Trinkets

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Use `TrinketsApi.getTrinketComponent()` to access an entity's equipped trinkets. This allows checking for specific items, retrieving equipped trinkets, and iterating over all trinket slots.

```java
package com.example.mymod;

import dev.emi.trinkets.api.SlotReference;
import dev.emi.trinkets.api.TrinketComponent;
import dev.emi.trinkets.api.TrinketsApi;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Pair;

import java.util.List;
import java.util.Map;
import java.util.Optional;

public class TrinketUtils {

    // Check if an entity has a specific trinket equipped
    public static boolean hasTrinketEquipped(LivingEntity entity, Item item) {
        Optional<TrinketComponent> component = TrinketsApi.getTrinketComponent(entity);
        return component.map(comp -> comp.isEquipped(item)).orElse(false);
    }

    // Get all equipped trinkets of a specific type
    public static List<Pair<SlotReference, ItemStack>> getEquippedTrinkets(LivingEntity entity, Item item) {
        Optional<TrinketComponent> component = TrinketsApi.getTrinketComponent(entity);
        return component.map(comp -> comp.getEquipped(item)).orElse(List.of());
    }

    // Get all non-empty trinket slots
    public static List<Pair<SlotReference, ItemStack>> getAllEquippedTrinkets(LivingEntity entity) {
        Optional<TrinketComponent> component = TrinketsApi.getTrinketComponent(entity);
        return component.map(TrinketComponent::getAllEquipped).orElse(List.of());
    }

    // Check with a custom predicate
    public static boolean hasMatchingTrinket(LivingEntity entity, java.util.function.Predicate<ItemStack> predicate) {
        Optional<TrinketComponent> component = TrinketsApi.getTrinketComponent(entity);
        return component.map(comp -> comp.isEquipped(predicate)).orElse(false);
    }

    // Iterate over all trinket slots
    public static void forEachTrinket(LivingEntity entity, java.util.function.BiConsumer<SlotReference, ItemStack> consumer) {
        TrinketsApi.getTrinketComponent(entity).ifPresent(comp -> comp.forEach(consumer));
    }

    // Example usage: Count total trinkets equipped
    public static int countEquippedTrinkets(PlayerEntity player) {
        int[] count = {0};
        forEachTrinket(player, (slot, stack) -> {
            if (!stack.isEmpty()) {
                count[0]++;
            }
        });
        return count[0];
    }
}
```

--------------------------------

### Tagging an Item for a Trinket Slot

Source: https://github.com/emilyploszaj/trinkets/wiki/Quick-Start-Guide

This JSON file associates your custom item with a specific trinket slot. The 'replace' value determines if existing tags are overwritten.

```json
{
  "replace": false,
  "values": [
    "guidemod:my_aglet"
  ]
}
```

--------------------------------

### Register Custom Trinket Predicates

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Use `TrinketsApi.registerTrinketPredicate` to add custom slot validation logic. Predicates can be referenced in slot JSON configurations. The lambda should return `TriState.TRUE` to allow, `TriState.FALSE` to deny, or `TriState.DEFAULT` to pass to the next predicate.

```java
package com.example.mymod;

import dev.emi.trinkets.api.TrinketsApi;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.util.TriState;
import net.minecraft.enchantment.Enchantments;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.util.Identifier;

public class MyMod implements ModInitializer {

    @Override
    public void onInitialize() {
        // Only allow items with Mending enchantment
        TrinketsApi.registerTrinketPredicate(
            Identifier.of("mymod", "mending_only"),
            (stack, ref, entity) -> {
                // Check if item has mending
                // Return TRUE to allow, FALSE to deny, DEFAULT to pass to next predicate
                return TriState.DEFAULT; // Simplified - would check enchantments
            }
        );

        // Only allow for players above certain level
        TrinketsApi.registerTrinketPredicate(
            Identifier.of("mymod", "high_level"),
            (stack, ref, entity) -> {
                if (entity instanceof PlayerEntity player) {
                    if (player.experienceLevel >= 30) {
                        return TriState.TRUE;
                    }
                    return TriState.FALSE;
                }
                return TriState.DEFAULT;
            }
        );

        // Deny specific items
        TrinketsApi.registerTrinketPredicate(
            Identifier.of("mymod", "no_vanilla"),
            (stack, ref, entity) -> {
                String namespace = stack.getItem().toString();
                if (namespace.startsWith("minecraft:")) {
                    return TriState.FALSE;
                }
                return TriState.DEFAULT;
            }
        );
    }
}
```

--------------------------------

### Check if Trinket is Equipped

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Checks if a trinket of a specific type is equipped by an entity. Can be used with an item or a predicate.

```java
isEquiped(Item)
```

```java
isEquiped(Predicate<ItemStack>)
```

--------------------------------

### Slot Entity Attribute Modifiers API

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

Information on how to modify the number of available slots using attribute modifiers.

```APIDOC
## Slot Entity Attribute Modifiers API

### Description
This section describes the system for modifying the number of available slots for specific slot types using attribute modifiers.

### Helper Method

#### `SlotAttributes.addSlotModifier(Slot, AttributeModifier)`
- **Description**: A helper method to conveniently construct and apply attribute modifiers that adjust the count of a specific slot type. These modifiers can add or remove slots, potentially reducing the count to zero.
- **Parameters**:
  - `slot` (Slot) - The type of slot to modify.
  - `modifier` (AttributeModifier) - The attribute modifier to apply.
```

--------------------------------

### Add Slot Modifier

Source: https://github.com/emilyploszaj/trinkets/wiki/Trinkets-API

A helper method to conveniently construct slot modifiers that adjust the amount of available slots for specific types.

```java
SlotAttributes.addSlotModifier(SlotModifier.Modifier.ADD, SlotModifier.SlotModifierType.ITEM, 1.0, SlotModifier.Condition.any())
```

--------------------------------

### Add Entity Attribute Modifiers to Trinkets

Source: https://context7.com/emilyploszaj/trinkets/llms.txt

Override `getModifiers` to apply entity attribute modifiers, such as movement speed bonuses or extra slot counts, when a trinket is equipped. Use `SlotAttributes.addSlotModifier` for slot modifications.

```java
package com.example.mymod;

import com.google.common.collect.Multimap;
import dev.emi.trinkets.api.SlotAttributes;
import dev.emi.trinkets.api.SlotReference;
import dev.emi.trinkets.api.TrinketItem;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.attribute.EntityAttribute;
import net.minecraft.entity.attribute.EntityAttributeModifier;
import net.minecraft.entity.attribute.EntityAttributes;
import net.minecraft.item.ItemStack;
import net.minecraft.registry.entry.RegistryEntry;
import net.minecraft.util.Identifier;

public class SpeedRing extends TrinketItem {

    public SpeedRing(Settings settings) {
        super(settings);
    }

    @Override
    public Multimap<RegistryEntry<EntityAttribute>, EntityAttributeModifier> getModifiers(
            ItemStack stack, SlotReference slot, LivingEntity entity, Identifier slotIdentifier) {

        Multimap<RegistryEntry<EntityAttribute>, EntityAttributeModifier> modifiers = 
            super.getModifiers(stack, slot, entity, slotIdentifier);

        // Add 40% movement speed bonus
        modifiers.put(EntityAttributes.MOVEMENT_SPEED, new EntityAttributeModifier(
            slotIdentifier.withSuffixedPath("/movement_speed"),
            0.4,
            EntityAttributeModifier.Operation.ADD_MULTIPLIED_TOTAL
        ));

        // Add 6 extra ring slots when equipped
        SlotAttributes.addSlotModifier(
            modifiers,
            "offhand/ring",
            slotIdentifier.withSuffixedPath("/ring_slots"),
            6,
            EntityAttributeModifier.Operation.ADD_VALUE
        );

        // Add 1 extra glove slot
        SlotAttributes.addSlotModifier(
            modifiers,
            "hand/glove",
            slotIdentifier.withSuffixedPath("/glove_slot"),
            1,
            EntityAttributeModifier.Operation.ADD_VALUE
        );

        return modifiers;
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.