Player Cosmetics

import kr.toxicity.model.api.BetterModel;
import kr.toxicity.model.api.entity.BaseEntity;
import kr.toxicity.model.api.profile.ModelProfile;
import kr.toxicity.model.api.tracker.PlayerTracker;
import kr.toxicity.model.api.tracker.TrackerModifier;
import org.bukkit.entity.Player;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class CosmeticManager {
    
    private final Map<UUID, Map<CosmeticSlot, PlayerTracker>> playerCosmetics = new ConcurrentHashMap<>();
    
    public void equipCosmetic(Player player, CosmeticSlot slot, String modelName) {
        // Remove existing cosmetic in slot
        unequipCosmetic(player, slot);
        
        BetterModel.limb(modelName).ifPresent(renderer -> {
            PlayerTracker tracker = (PlayerTracker) renderer.create(
                BaseEntity.of(player),
                ModelProfile.of(player),
                TrackerModifier.builder()
                    .sightTrace(false)
                    .damageAnimation(false)
                    .damageTint(false)
                    .build()
            );
            
            // Store tracker
            playerCosmetics
                .computeIfAbsent(player.getUniqueId(), k -> new ConcurrentHashMap<>())
                .put(slot, tracker);
            
            // Start idle animation
            tracker.animate("idle");
        });
    }
    
    public void unequipCosmetic(Player player, CosmeticSlot slot) {
        Map<CosmeticSlot, PlayerTracker> cosmetics = playerCosmetics.get(player.getUniqueId());
        if (cosmetics == null) return;
        
        PlayerTracker tracker = cosmetics.remove(slot);
        if (tracker != null) {
            tracker.close();
        }
    }
    
    public void removeAllCosmetics(Player player) {
        Map<CosmeticSlot, PlayerTracker> cosmetics = playerCosmetics.remove(player.getUniqueId());
        if (cosmetics != null) {
            cosmetics.values().forEach(PlayerTracker::close);
        }
    }
    
    public Map<CosmeticSlot, PlayerTracker> getCosmetics(Player player) {
        return playerCosmetics.getOrDefault(player.getUniqueId(), Collections.emptyMap());
    }
    
    public enum CosmeticSlot {
        HAT,
        BACK,      // Wings, capes
        SHOULDER,  // Parrots, pets
        AURA,      // Particle effects
        COMPANION  // Following pets
    }
}

import kr.toxicity.model.api.BetterModel;
import kr.toxicity.model.api.tracker.DummyTracker;
import kr.toxicity.model.api.tracker.ModelRotation;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;

public class CompanionPet {
    
    private final DummyTracker tracker;
    private final Player owner;
    private Location targetLocation;
    
    public CompanionPet(Player owner, String modelName) {
        this.owner = owner;
        this.targetLocation = owner.getLocation();
        
        this.tracker = BetterModel.model(modelName)
            .map(renderer -> renderer.create(owner.getLocation()))
            .orElse(null);
        
        if (tracker != null) {
            setupPetBehavior();
        }
    }
    
    private void setupPetBehavior() {
        // Start idle animation
        tracker.animate("pet_idle");
        
        // Follow player
        tracker.tick(2, (t, bundler) -> {
            Location ownerLoc = owner.getLocation();
            Location currentLoc = tracker.location().toBukkit();
            
            // Calculate offset behind player
            Vector direction = ownerLoc.getDirection().multiply(-1).normalize();
            targetLocation = ownerLoc.clone()
                .add(direction.multiply(2))
                .add(0, 0.5, 0);
            
            double distance = currentLoc.distance(targetLocation);
            
            // Move if too far
            if (distance > 0.5) {
                // Calculate movement
                Vector movement = targetLocation.toVector()
                    .subtract(currentLoc.toVector())
                    .normalize()
                    .multiply(Math.min(distance * 0.3, 0.5));
                
                Location newLoc = currentLoc.add(movement);
                
                // Update rotation to face movement direction
                float yaw = (float) Math.toDegrees(
                    Math.atan2(-movement.getX(), movement.getZ())
                );
                
                tracker.rotation(() -> new ModelRotation(0, yaw));
                tracker.location(newLoc);
                
                // Play walk animation if moving fast
                if (distance > 2) {
                    tracker.stopAnimation("pet_idle");
                    tracker.animate("pet_walk");
                }
            } else {
                // Play idle when close
                tracker.stopAnimation("pet_walk");
                tracker.animate("pet_idle");
            }
        });
    }
    
    public void remove() {
        if (tracker != null) {
            tracker.close();
        }
    }
    
    public DummyTracker getTracker() {
        return tracker;
    }
}