Performance Optimization

import kr.toxicity.model.api.BetterModel;
import kr.toxicity.model.api.entity.BaseEntity;
import kr.toxicity.model.api.tracker.EntityTracker;
import kr.toxicity.model.api.tracker.TrackerModifier;
import org.bukkit.entity.Entity;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class OptimizedTrackerManager {
    
    private final Map<UUID, EntityTracker> trackerCache = new ConcurrentHashMap<>();
    
    // GOOD: Use getOrCreate to prevent duplicates
    public EntityTracker getTracker(Entity entity, String modelName) {
        return trackerCache.computeIfAbsent(entity.getUniqueId(), uuid -> 
            BetterModel.model(modelName)
                .map(renderer -> renderer.getOrCreate(BaseEntity.of(entity)))
                .orElse(null)
        );
    }
    
    // GOOD: Batch cleanup
    public void cleanupInactiveTrackers() {
        trackerCache.entrySet().removeIf(entry -> {
            EntityTracker tracker = entry.getValue();
            if (tracker.isClosed() || tracker.playerCount() == 0) {
                tracker.close();
                return true;
            }
            return false;
        });
    }
    
    // BAD: Creating multiple trackers
    public void badExample(Entity entity) {
        // Don't do this - creates duplicate trackers
        BetterModel.model("model").ifPresent(r -> r.create(BaseEntity.of(entity)));
        BetterModel.model("model").ifPresent(r -> r.create(BaseEntity.of(entity)));
    }
}

import kr.toxicity.model.api.animation.AnimationModifier;
import kr.toxicity.model.api.tracker.Tracker;
import org.bukkit.entity.LivingEntity;

public class AnimationOptimization {
    
    // GOOD: Cache animation state
    private String currentAnimation = "idle";
    
    public void updateAnimation(Tracker tracker, LivingEntity entity) {
        String newAnimation = determineAnimation(entity);
        
        // Only update if animation changed
        if (!newAnimation.equals(currentAnimation)) {
            tracker.stopAnimation(currentAnimation);
            tracker.animate(newAnimation);
            currentAnimation = newAnimation;
        }
    }
    
    // GOOD: Use tick intervals instead of every frame
    public void setupOptimizedUpdates(Tracker tracker) {
        // Update every 5 ticks (250ms) instead of every frame (25ms)
        tracker.tick(5, (t, bundler) -> {
            // Update logic
        });
    }
    
    // GOOD: Use predicates for conditional animations
    public void setupConditionalAnimation(Tracker tracker, LivingEntity entity) {
        tracker.animate("special", AnimationModifier.builder()
            .predicate(() -> entity.getHealth() < entity.getMaxHealth() * 0.5)
            .build()
        );
    }
    
    // BAD: Updating animation every frame without checking
    public void badExample(Tracker tracker) {
        tracker.tick((t, bundler) -> {
            // Don't do this - wastes resources
            t.stopAnimation("idle");
            t.animate("idle");
        });
    }
    
    private String determineAnimation(LivingEntity entity) {
        if (entity.getVelocity().lengthSquared() > 0.01) return "walk";
        return "idle";
    }
}

import kr.toxicity.model.api.tracker.TrackerUpdateAction;
import kr.toxicity.model.api.util.function.BonePredicate;

public class UpdateOptimization {
    
    // GOOD: Composite updates
    public void applyMultipleUpdates(Tracker tracker) {
        tracker.update(TrackerUpdateAction.composite(
            TrackerUpdateAction.glow(true),
            TrackerUpdateAction.glowColor(0xFF0000),
            TrackerUpdateAction.brightness(15, 15),
            TrackerUpdateAction.enchant(true)
        ));
    }
    
    // GOOD: Use bone predicates efficiently
    public void targetSpecificBones(Tracker tracker) {
        // Cache predicate
        BonePredicate armPredicate = BonePredicate.name("left_arm")
            .or(BonePredicate.name("right_arm"));
        
        tracker.update(
            TrackerUpdateAction.glow(true),
            armPredicate
        );
    }
    
    // BAD: Multiple individual updates
    public void badExample(Tracker tracker) {
        // Don't do this - sends multiple packet bundles
        tracker.update(TrackerUpdateAction.glow(true));
        tracker.update(TrackerUpdateAction.glowColor(0xFF0000));
        tracker.update(TrackerUpdateAction.brightness(15, 15));
        tracker.update(TrackerUpdateAction.enchant(true));
    }
}

import kr.toxicity.model.api.BetterModel;
import org.bukkit.scheduler.BukkitRunnable;

public class AsyncOptimization {
    
    // GOOD: Load models asynchronously
    public void loadModelAsync(JavaPlugin plugin, String modelName, Consumer<ModelRenderer> callback) {
        new BukkitRunnable() {
            @Override
            public void run() {
                BetterModel.model(modelName).ifPresent(renderer -> {
                    // Switch back to main thread for tracker creation
                    new BukkitRunnable() {
                        @Override
                        public void run() {
                            callback.accept(renderer);
                        }
                    }.runTask(plugin);
                });
            }
        }.runTaskAsynchronously(plugin);
    }
    
    // GOOD: Use BetterModel's async scheduler
    public void asyncUpdate(Tracker tracker, Runnable heavyTask) {
        BetterModel.platform().scheduler().asyncTask(() -> {
            // Heavy computation
            heavyTask.run();
            
            // Update on main thread
            tracker.task(() -> {
                // Apply results
            });
        });
    }
}