@starktma/minecraft-utils 1.3.25 → 1.4.0

package/dist/minecraft/effectsAPI.js

@@ -1,23 +1,22 @@
-import { MolangVariableMap, Player, system, world } from "@minecraft/server";
+import { EntityItemComponent, MolangVariableMap, system, world, } from "@minecraft/server";
 import { MinecraftItemTypes } from "@minecraft/vanilla-data";
-import { SimpleDatabase } from "@starktma/minecraft-utils/database";
 import { getNamespace } from "../constants";
-class EffectEntityDatabase extends SimpleDatabase {
-    static instance;
-    constructor() {
-        super("effect_entities");
-    }
-    static getInstance() {
-        if (!EffectEntityDatabase.instance) {
-            EffectEntityDatabase.instance = new EffectEntityDatabase();
-        }
-        return EffectEntityDatabase.instance;
+import { SimpleDatabase } from "../database";
+class EffectDatabase extends SimpleDatabase {
+    constructor(entity) {
+        super("effects", entity);
     }
 }
+// ============================= EffectManager =================================
 class EffectManager {
-    configs = new Map();
-    entityDB = null;
     static instance;
+    effectConfigs = new Map();
+    potionConfigs = new Map();
+    areaEffectClouds = new Map();
+    cloudIdCounter = 0;
+    trackedEntities = new Map();
+    // Entity databases: entityId -> EffectDatabase
+    entityDatabases = new Map();
     static getInstance() {
         if (!EffectManager.instance) {
             EffectManager.instance = new EffectManager();
@@ -25,119 +24,69 @@ class EffectManager {
         return EffectManager.instance;
     }
     constructor() { }
-    getEntityDatabase() {
-        if (!this.entityDB) {
-            this.entityDB = EffectEntityDatabase.getInstance();
-        }
-        return this.entityDB;
-    }
-    /**
-     * Track an entity as having effects
-     * @param entity - The entity to track
-     */
-    trackEntity(entity) {
-        const db = this.getEntityDatabase();
-        const tracker = {
-            id: entity.id,
-        };
-        if (!db.hasObject(entity.id)) {
-            db.addObject(tracker);
+    // ============================= Database Helpers ==========================
+    // Get or create database for an entity
+    getEntityDatabase(entity) {
+        let db = this.entityDatabases.get(entity.id);
+        if (!db) {
+            db = new EffectDatabase(entity);
+            this.entityDatabases.set(entity.id, db);
         }
+        return db;
     }
-    /**
-     * Stop tracking an entity (when it has no more effects)
-     * @param entity - The entity to stop tracking
-     */
-    untrackEntity(entity) {
-        const db = this.getEntityDatabase();
-        if (db.hasObject(entity.id)) {
-            db.removeObject(entity.id);
-        }
+    getEffect(entity, effectType) {
+        const db = this.getEntityDatabase(entity);
+        return db.getObject(effectType) || null;
     }
-    /**
-     * Check if an entity has any effect tags
-     * @param entity - The entity to check
-     * @returns True if entity has any effect tags
-     */
-    entityHasEffectTags(entity) {
-        return entity.getTags().some((tag) => tag.includes("starkteffects"));
+    getAllEffects(entity) {
+        const db = this.getEntityDatabase(entity);
+        return db.getAllObjects();
     }
-    /**
-     * Parse effect data from entity tags regardless of namespace
-     * @param entity - The entity to get effects from
-     * @returns Array of effect objects parsed from all effect tags
-     */
-    getEffectsFromTags(entity) {
-        return entity
-            .getTags()
-            .filter((tag) => tag.includes("starkteffects"))
-            .map((tag) => {
-            const parts = tag.split("_");
-            if (parts.length < 4)
-                return null;
-            // Find the namespace and effects parts
-            const effectsIndex = parts.findIndex((part) => part === "starkteffects");
-            if (effectsIndex === -1 || effectsIndex === 0 || effectsIndex >= parts.length - 2)
-                return null;
-            const namespace = parts.slice(0, effectsIndex).join("_");
-            const effectType = parts.slice(effectsIndex + 1, -2).join("_");
-            const amplifier = parseInt(parts[parts.length - 2]);
-            const duration = parseInt(parts[parts.length - 1]);
-            const config = this.configs.get(effectType);
-            return {
-                id: `${entity.id}_${effectType}`,
-                entityId: entity.id,
-                effectType,
-                amplifier,
-                duration,
-                color: config?.color || { red: 1, green: 1, blue: 1, alpha: 1 },
-            };
-        })
-            .filter((effect) => effect !== null);
+    // Check if entity has any active effects and should be tracked
+    hasActiveEffects(entity) {
+        const db = this.getEntityDatabase(entity);
+        return db.getAllObjects().length > 0;
     }
-    /**
-     * Parse ALL effect data from entity tags regardless of namespace
-     * @param entity - The entity to get effects from
-     * @returns Array of effect objects parsed from all effect tags
-     */
-    getAllEffectsFromTags(entity) {
-        return entity
-            .getTags()
-            .filter((tag) => tag.includes("starkteffects"))
-            .map((tag) => {
-            const parts = tag.split("_");
-            if (parts.length < 4)
-                return null;
-            // Find the namespace and effects parts
-            const effectsIndex = parts.findIndex((part) => part === "starkteffects");
-            if (effectsIndex === -1 || effectsIndex === 0 || effectsIndex >= parts.length - 2)
-                return null;
-            const namespace = parts.slice(0, effectsIndex).join("_");
-            const effectType = parts.slice(effectsIndex + 1, -2).join("_");
-            const amplifier = parseInt(parts[parts.length - 2]);
-            const duration = parseInt(parts[parts.length - 1]);
-            const config = this.configs.get(effectType);
-            return {
-                id: `${entity.id}_${effectType}`,
-                entityId: entity.id,
-                effectType,
-                amplifier,
-                duration,
-                color: config?.color || { red: 1, green: 1, blue: 1, alpha: 1 },
-            };
-        })
-            .filter((effect) => effect !== null);
+    debug() {
+        for (const player of world.getAllPlayers()) {
+            const effects = this.getAllEffects(player);
+            if (effects.length === 0) {
+                player.onScreenDisplay.setActionBar("§8[§7Effects§8] §7No active effects");
+                continue;
+            }
+            const effectMap = new Map();
+            for (const effect of effects) {
+                const existing = effectMap.get(effect.effectType);
+                if (!existing || effect.duration > existing.duration) {
+                    effectMap.set(effect.effectType, effect);
+                }
+            }
+            const sorted = Array.from(effectMap.values()).sort((a, b) => b.duration - a.duration);
+            const display = sorted.map((effect) => {
+                const seconds = Math.ceil(effect.duration / 20);
+                const minutes = Math.floor(seconds / 60);
+                const remainingSeconds = seconds % 60;
+                const timeString = seconds > 60
+                    ? `§a${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
+                    : seconds > 10
+                        ? `§e${seconds}s`
+                        : `§c${seconds}s`;
+                const name = effect.effectType
+                    .split("_")
+                    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                    .join(" ");
+                const amp = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X"][effect.amplifier] || effect.amplifier + 1;
+                return `§6${name}§r §7${amp}§r §8(${timeString}§8)§r`;
+            });
+            player.onScreenDisplay.setActionBar(`§8[§bActive Effects§8]§r\n${display.join("\n")}`);
+        }
     }
-    /**
-     * Register a effect effect with full configuration
-     * @param config - Complete effect configuration including effect type, color, sounds, particle type, and handler
-     * @returns Helper functions for adding, removing, and applying the effect
-     */
+    // ============================= Effect API ================================
     registerEffect(config) {
-        this.configs.set(config.effectType, config);
+        this.effectConfigs.set(config.effectType, config);
         return {
-            addEffect: (entity, amplifier, duration) => {
-                this.addEffect(entity, config.effectType, amplifier, duration);
+            addEffect: (entity, amplifier, durationTicks) => {
+                this.addEffect(entity, config.effectType, amplifier, durationTicks);
             },
             removeEffect: (entity) => {
                 this.removeEffect(entity, config.effectType);
@@ -146,293 +95,347 @@ class EffectManager {
         };
     }
     addEffect(entity, effectType, amplifier, duration) {
-        // Get config if registered
-        const config = this.configs.get(effectType);
-        const currentNamespace = getNamespace();
-        // Find existing effect from tags
-        const existingTag = entity
-            .getTags()
-            .find((tag) => tag.startsWith(`${currentNamespace}_starkteffects_${effectType}_`));
-        if (existingTag) {
-            // Parse existing effect
-            const parts = existingTag.split("_");
-            if (parts.length >= 4) {
-                const existingAmplifier = parseInt(parts[parts.length - 2]);
-                const existingDuration = parseInt(parts[parts.length - 1]);
-                // Update if stronger or longer
-                if (amplifier > existingAmplifier || (amplifier === existingAmplifier && duration * 20 > existingDuration)) {
-                    // Remove old tag and add new one
-                    entity.removeTag(existingTag);
-                    entity.addTag(`${currentNamespace}_starkteffects_${effectType}_${amplifier}_${duration * 20}`);
-                }
-            }
-        }
-        else {
-            // New effect - add tag
-            entity.addTag(`${currentNamespace}_starkteffects_${effectType}_${amplifier}_${duration * 20}`);
-            // Play start sound if configured
-            if (config?.sounds?.start) {
+        const config = this.effectConfigs.get(effectType);
+        const db = this.getEntityDatabase(entity);
+        const existing = db.getObject(effectType);
+        // Determine which effect to keep (stronger one)
+        if (!existing ||
+            amplifier > existing.amplifier ||
+            (amplifier === existing.amplifier && duration > existing.duration)) {
+            const effect = {
+                id: effectType,
+                namespace: getNamespace(),
+                effectType,
+                amplifier,
+                duration,
+                color: config?.color || { red: 1, green: 1, blue: 1, alpha: 1 },
+            };
+            db.updateObject(effect);
+            // Play start sound only for new effects
+            if (!existing && config?.sounds?.start) {
                 try {
                     entity.dimension.playSound(config.sounds.start, entity.location);
                 }
-                catch (error) { }
+                catch { }
             }
         }
-        // Track this entity as having effects
-        this.trackEntity(entity);
+        // Track entity for effect updates
+        this.trackedEntities.set(entity.id, entity);
     }
     removeEffect(entity, effectType) {
-        const currentNamespace = getNamespace();
-        // Find and remove effect tags
-        const effectTags = entity
-            .getTags()
-            .filter((tag) => tag.startsWith(`${currentNamespace}_starkteffects_${effectType}_`));
-        if (effectTags.length > 0) {
-            // Play end sound if configured
-            const config = this.configs.get(effectType);
-            if (config?.sounds?.end) {
-                try {
-                    entity.dimension.playSound(config.sounds.end, entity.location);
-                }
-                catch (error) { }
-            }
-            // Remove effect tags
-            effectTags.forEach((tag) => {
-                entity.removeTag(tag);
-            });
-            // Check if entity still has any effects, untrack if not
-            if (!this.entityHasEffectTags(entity)) {
-                this.untrackEntity(entity);
+        const db = this.getEntityDatabase(entity);
+        const hasEffect = db.hasObject(effectType);
+        const config = this.effectConfigs.get(effectType);
+        // Remove from database
+        db.removeObject(effectType);
+        // Play end sound only if effect existed
+        if (hasEffect && config?.sounds?.end) {
+            try {
+                entity.dimension.playSound(config.sounds.end, entity.location);
             }
+            catch { }
+        }
+        // Untrack entity if no effects remain
+        if (!this.hasActiveEffects(entity)) {
+            this.entityDatabases.delete(entity.id);
+            this.trackedEntities.delete(entity.id);
         }
     }
     removeAllEffects(entity) {
-        const currentNamespace = getNamespace();
-        // Get all effect tags
-        const effectTags = entity.getTags().filter((tag) => tag.startsWith(`${currentNamespace}_starkteffects_`));
-        // Play end sounds for each effect type
-        const effectTypes = new Set();
-        effectTags.forEach((tag) => {
-            const parts = tag.split("_");
-            if (parts.length >= 4) {
-                const effectType = parts.slice(2, -2).join("_");
-                effectTypes.add(effectType);
-            }
-        });
-        effectTypes.forEach((effectType) => {
-            const config = this.configs.get(effectType);
+        const db = this.getEntityDatabase(entity);
+        const effects = db.getAllObjects();
+        entity
+            .getTags()
+            .filter((tag) => tag.startsWith("starkeffects|pause_effect"))
+            .forEach((tag) => entity.removeTag(tag));
+        // Play end sounds for each effect
+        for (const effect of effects) {
+            const config = this.effectConfigs.get(effect.effectType);
             if (config?.sounds?.end) {
                 try {
                     entity.dimension.playSound(config.sounds.end, entity.location);
                 }
-                catch (error) { }
+                catch { }
             }
-        });
-        // Remove all effect tags
-        effectTags.forEach((tag) => {
-            entity.removeTag(tag);
-        });
-        // Untrack this entity since it has no more effects
-        this.untrackEntity(entity);
-    }
-    extendEffect(entity, effectType, additionalDuration) {
-        // Debug: Show all tags on the entity
-        const allTags = entity.getTags();
-        // Find effect tags of any namespace
-        const effectTags = entity.getTags().filter((tag) => {
-            // Tag format: {namespace}_starkteffects_{effectType}_{amplifier}_{duration}
-            // We need to find the "_starkteffects_" marker and work from there
-            const effectsIndex = tag.indexOf("_starkteffects_");
-            if (effectsIndex === -1)
-                return false;
-            // Extract parts after "_starkteffects_"
-            const afterEffects = tag.substring(effectsIndex + 15); // 15 = "_starkteffects_".length
-            const parts = afterEffects.split("_");
-            // Need at least 3 parts: effectType, amplifier, duration
-            // But effectType might contain underscores, so amplifier and duration are the last 2 parts
-            if (parts.length < 3)
-                return false;
-            // Extract effect type (everything except the last 2 parts which are amplifier and duration)
-            const tagEffectType = parts.slice(0, -2).join("_");
-            return tagEffectType === effectType;
-        });
-        if (effectTags.length === 0)
-            return false;
-        // For each matching effect tag, extend its duration
-        effectTags.forEach((tag) => {
-            // Tag format: {namespace}_starkteffects_{effectType}_{amplifier}_{duration}
-            const effectsIndex = tag.indexOf("_starkteffects_");
-            const namespace = tag.substring(0, effectsIndex);
-            const afterEffects = tag.substring(effectsIndex + 15); // 15 = "_starkteffects_".length
-            const parts = afterEffects.split("_");
-            // Last two parts are always amplifier and duration
-            const amplifier = parseInt(parts[parts.length - 2]);
-            const currentDuration = parseInt(parts[parts.length - 1]);
-            const newDuration = currentDuration + additionalDuration;
-            // Remove old tag and add new one with extended duration
-            entity.removeTag(tag);
-            const newTag = `${namespace}_starkteffects_${effectType}_${amplifier}_${newDuration}`;
-            entity.addTag(newTag);
-        });
-        return true;
+        }
+        // Clear database and untrack
+        db.eraseAllObjects();
+        this.entityDatabases.delete(entity.id);
+        this.trackedEntities.delete(entity.id);
     }
     hasEffect(entity, effectType) {
-        const currentNamespace = getNamespace();
-        return entity.getTags().some((tag) => tag.startsWith(`${currentNamespace}_starkteffects_${effectType}_`));
+        const db = this.getEntityDatabase(entity);
+        return db.hasObject(effectType);
     }
     getEffects(entity) {
-        return this.getAllEffectsFromTags(entity);
+        const db = this.getEntityDatabase(entity);
+        return db.getAllObjects();
     }
-    /**
-     * Debug function to display all active effects for an entity in the action bar
-     * @param entity - The entity to display effects for (must be a Player)
-     */
-    debugShowEffects(entity) {
-        // Only works for players
-        if (!(entity instanceof Player)) {
-            return;
-        }
-        const currentNamespace = getNamespace();
-        // Get effects from tags instead of database
-        const effectTags = entity.getTags().filter((tag) => tag.includes(`starkteffects`));
-        if (effectTags.length === 0) {
-            entity.onScreenDisplay.setActionBar("§8[§7Effects§8] §7No active effects");
-            return;
-        }
-        // Parse effect data from tags
-        const effects = effectTags
-            .map((tag) => {
-            // Format: namespace_starkteffects_${effectType}_${amplifier}_${duration}
-            const parts = tag.split("_");
-            if (parts.length < 4)
-                return null;
-            const effectType = parts.slice(2, -2).join("_"); // Handle effect types with underscores
-            const amplifier = parseInt(parts[parts.length - 2]);
-            const duration = parseInt(parts[parts.length - 1]);
-            return { effectType, amplifier, duration };
-        })
-            .filter((effect) => effect !== null);
-        if (effects.length === 0) {
-            entity.onScreenDisplay.setActionBar("§8[§7Effects§8] §7No active effects");
-            return;
-        }
-        // Sort effects by remaining duration (longest first)
-        const sortedEffects = effects.sort((a, b) => b.duration - a.duration);
-        const effectStrings = sortedEffects.map((effect) => {
-            const seconds = Math.ceil(effect.duration / 20);
-            const minutes = Math.floor(seconds / 60);
-            const remainingSeconds = seconds % 60;
-            // Format time with different colors based on urgency
-            let timeString;
-            let timeColor;
-            if (seconds > 60) {
-                timeString = `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`;
-                timeColor = "§a"; // Green for long duration
-            }
-            else if (seconds > 10) {
-                timeString = `${seconds}s`;
-                timeColor = "§e"; // Yellow for medium duration
-            }
-            else {
-                timeString = `${seconds}s`;
-                timeColor = "§c"; // Red for short duration
-            }
-            // Format effect name with proper capitalization
-            const effectName = effect.effectType.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1))[1];
-            // Format amplifier with Roman numerals for style
-            const romanNumerals = ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X"];
-            const amplifierDisplay = effect.amplifier < romanNumerals.length ? romanNumerals[effect.amplifier] : (effect.amplifier + 1).toString();
-            return `§6${effectName}§r §7${amplifierDisplay}§r §8(${timeColor}${timeString}§8)§r`;
-        });
-        // Create a formatted display with header and effects
-        const header = "§8[§bActive Effects§8]§r";
-        const effectsDisplay = effectStrings.join("\n");
-        const displayText = `${header}\n${effectsDisplay}`;
-        entity.onScreenDisplay.setActionBar(displayText);
+    // ============================= Potion API ================================
+    registerPotion(config) {
+        const fullConfig = {
+            splashRange: 4,
+            lingeringMaxRadius: 3,
+            lingeringLifetime: 600,
+            lingeringDurationMultiplier: 0.25,
+            ...config,
+        };
+        this.potionConfigs.set(`${config.namespace}:${config.effectKey}`, fullConfig);
+        return { handler: config.handler };
     }
-    start() {
-        if (!EffectManager.instance)
-            return;
+    // ============================= System ====================================
+    start(startup, debug) {
+        if (startup) {
+            for (const [, config] of this.potionConfigs.entries()) {
+                const componentId = `${config.namespace}:${config.effectKey}_potion_effect`;
+                startup.itemComponentRegistry.registerCustomComponent(componentId, {
+                    onConsume: (event, params) => {
+                        const p = params.params;
+                        const color = {
+                            red: p.potion_color[0],
+                            green: p.potion_color[1],
+                            blue: p.potion_color[2],
+                            alpha: p.potion_color[3],
+                        };
+                        config.handler(event.source, p.amplifier, p.duration * 20, color);
+                    },
+                });
+            }
+            world.afterEvents.projectileHitBlock.subscribe((event) => this.handleProjectileHit(event.projectile));
+            world.afterEvents.projectileHitEntity.subscribe((event) => this.handleProjectileHit(event.projectile));
+        }
         system.runInterval(() => {
-            const entityDB = this.getEntityDatabase();
-            const trackedEntityIds = entityDB.getAllObjects();
-            for (const tracker of trackedEntityIds) {
-                const entity = world.getEntity(tracker.id);
-                // If entity doesn't exist, clean up tracking
-                if (!entity)
+            //if (debug) {
+            //	this.debug();
+            //}
+            // Process effects on tracked entities only
+            for (const [entityId, entity] of this.trackedEntities.entries()) {
+                if (!entity.isValid) {
+                    this.entityDatabases.delete(entityId);
+                    this.trackedEntities.delete(entityId);
                     continue;
-                // Check if entity still has effect tags (cleanup orphaned tracking)
-                if (!this.entityHasEffectTags(entity)) {
-                    entityDB.removeObject(tracker.id);
+                }
+                const allTags = entity.getTags();
+                const pauseEffects = allTags.filter((tag) => tag.startsWith(`starkeffects|pause_effect`));
+                const db = this.getEntityDatabase(entity);
+                const effects = db.getAllObjects();
+                if (effects.length === 0) {
+                    this.entityDatabases.delete(entityId);
+                    this.trackedEntities.delete(entityId);
                     continue;
                 }
-                this.debugShowEffects(entity);
-                const effects = this.getEffectsFromTags(entity).filter((effect) => {
-                    // Only process effects from current namespace
-                    const currentNamespace = getNamespace();
-                    return entity
-                        .getTags()
-                        .some((tag) => tag.startsWith(`${currentNamespace}_starkteffects_${effect.effectType}_`));
-                });
+                // Store original durations to detect handler modifications
+                const originalDurations = new Map();
+                for (const effect of effects) {
+                    originalDurations.set(effect.effectType, effect.duration);
+                }
+                // Apply handlers and update effects
                 for (const effect of effects) {
-                    // Get config for this effect
-                    const config = this.configs.get(effect.effectType);
-                    // Apply effect handler
+                    const config = this.effectConfigs.get(effect.effectType);
+                    // Run effect handler
                     if (config?.handler) {
                         config.handler(entity, effect);
                     }
-                    // Play ambient sound periodically (every 2 seconds)
+                    // Get current effect from database (handler may have modified it)
+                    const currentEffect = db.getObject(effect.effectType);
+                    if (!currentEffect)
+                        continue;
+                    // Check if handler modified the duration
+                    const originalDuration = originalDurations.get(effect.effectType);
+                    if (currentEffect.duration !== originalDuration) {
+                        // Handler modified it, skip countdown
+                        continue;
+                    }
+                    // Play ambient sounds
                     if (config?.sounds?.ambient && system.currentTick % 40 === 0) {
                         try {
                             entity.dimension.playSound(config.sounds.ambient, entity.location, { volume: 0.5 });
                         }
-                        catch (error) { }
+                        catch { }
                     }
                     // Spawn particles
-                    if (system.currentTick % 2 === 0) {
-                        const particleLocation = entity.location;
-                        particleLocation.y++;
+                    if (system.currentTick % 20 === 0) {
+                        const loc = { ...entity.location, y: entity.location.y + 1 };
                         const variables = new MolangVariableMap();
-                        variables.setColorRGBA("color", effect.color);
-                        const particleType = config?.particleType || "minecraft:mobspell_emitter";
+                        variables.setColorRGBA("color", currentEffect.color);
                         try {
-                            entity.dimension.spawnParticle(particleType, particleLocation, variables);
+                            entity.dimension.spawnParticle(config?.particleType || "minecraft:mobspell_emitter", loc, variables);
                         }
-                        catch (error) { }
+                        catch { }
                     }
-                    // Update duration
-                    const newDuration = effect.duration - 1;
-                    if (newDuration <= 0) {
-                        // Play end sound when effect expires naturally
+                    if (pauseEffects.length > 0) {
+                        const excludeEffects = pauseEffects.map((tag) => tag.split("|")[2]);
+                        if (!excludeEffects.includes(effect.effectType))
+                            continue;
+                    }
+                    // Countdown duration
+                    const newDuration = currentEffect.duration - 1;
+                    if (newDuration > 0) {
+                        db.updateObject({ ...currentEffect, duration: newDuration });
+                    }
+                    else {
+                        db.removeObject(effect.effectType);
                         if (config?.sounds?.end) {
                             try {
                                 entity.dimension.playSound(config.sounds.end, entity.location);
                             }
-                            catch (error) { }
+                            catch { }
                         }
-                        // Remove expired effect tag
-                        const currentNamespace = getNamespace();
-                        entity.removeTag(`${currentNamespace}_starkteffects_${effect.effectType}_${effect.amplifier}_${effect.duration}`);
-                    }
-                    else {
-                        // Update tag with new duration
-                        const currentNamespace = getNamespace();
-                        entity.removeTag(`${currentNamespace}_starkteffects_${effect.effectType}_${effect.amplifier}_${effect.duration}`);
-                        entity.addTag(`${currentNamespace}_starkteffects_${effect.effectType}_${effect.amplifier}_${newDuration}`);
                     }
                 }
-                // Clean up tracking if entity has no more effects
-                if (!this.entityHasEffectTags(entity)) {
-                    entityDB.removeObject(tracker.id);
+                // Untrack if no effects remain
+                if (!this.hasActiveEffects(entity)) {
+                    this.entityDatabases.delete(entityId);
+                    this.trackedEntities.delete(entityId);
                 }
             }
+            for (const cloud of this.areaEffectClouds.values()) {
+                this.updateCloud(cloud);
+            }
+        }, 1);
+        // Track entities that spawn with active effects
+        world.afterEvents.entitySpawn.subscribe((event) => {
+            if (!event.entity || !event.entity.isValid)
+                return;
+            if (event.entity.hasComponent(EntityItemComponent.componentId))
+                return;
+            if (this.hasActiveEffects(event.entity)) {
+                this.trackedEntities.set(event.entity.id, event.entity);
+            }
+        });
+        world.afterEvents.playerJoin.subscribe((event) => {
+            const player = world.getEntity(event.playerId);
+            if (this.hasActiveEffects(player)) {
+                this.trackedEntities.set(player.id, player);
+            }
+        });
+        // Clean up when entities die
+        world.afterEvents.entityDie.subscribe((event) => {
+            this.entityDatabases.delete(event.deadEntity.id);
+            this.trackedEntities.delete(event.deadEntity.id);
         });
         world.afterEvents.itemCompleteUse.subscribe((event) => {
             if (event.itemStack.typeId === MinecraftItemTypes.MilkBucket) {
                 this.removeAllEffects(event.source);
             }
         });
+        world.afterEvents.worldLoad.subscribe(() => {
+            world.getAllPlayers().forEach((player) => {
+                if (this.hasActiveEffects(player)) {
+                    this.trackedEntities.set(player.id, player);
+                }
+            });
+        });
+    }
+    // ============================= Potion Projectiles ========================
+    handleProjectileHit(projectile) {
+        const configs = Array.from(this.potionConfigs.values());
+        for (const config of configs) {
+            if (projectile.typeId !== `${config.namespace}:potion_projectile`)
+                continue;
+            const effectId = projectile.getProperty(`${config.namespace}:effect_id`);
+            if (effectId !== config.effectId)
+                continue;
+            const potionType = projectile.getProperty(`${config.namespace}:type`);
+            if (potionType === 1) {
+                this.handleSplash(projectile, config);
+            }
+            else if (potionType === 2) {
+                this.handleLingering(projectile, config);
+            }
+            else {
+                projectile.remove();
+            }
+            return;
+        }
+    }
+    handleSplash(projectile, config) {
+        const location = { ...projectile.location, y: projectile.location.y + 0.1 };
+        const color = this.getColorFromEntity(projectile, config.namespace);
+        const amplifier = projectile.getProperty(`${config.namespace}:amplifier`);
+        const duration = projectile.getProperty(`${config.namespace}:duration`) * 20;
+        const variables = new MolangVariableMap();
+        variables.setFloat("splash_range", config.splashRange);
+        variables.setFloat("splash_power", 1);
+        variables.setColorRGBA("color", color);
+        projectile.dimension.spawnParticle("minecraft:splash_spell_emitter", location, variables);
+        const nearbyEntities = projectile.dimension.getEntities({
+            excludeTypes: ["minecraft:item", "minecraft:arrow"],
+            location: projectile.location,
+            maxDistance: config.splashRange,
+        });
+        for (const entity of nearbyEntities) {
+            if (entity.id !== projectile.id) {
+                config.handler(entity, amplifier, duration, color);
+            }
+        }
+        projectile.remove();
+    }
+    handleLingering(projectile, config) {
+        const location = { ...projectile.location, y: projectile.location.y + 0.1 };
+        const color = this.getColorFromEntity(projectile, config.namespace);
+        const amplifier = projectile.getProperty(`${config.namespace}:amplifier`);
+        const duration = projectile.getProperty(`${config.namespace}:duration`) * 20;
+        const cloud = {
+            id: `aoe_cloud_${this.cloudIdCounter++}`,
+            dimension: projectile.dimension.id,
+            location,
+            color,
+            amplifier,
+            duration,
+            currentRadius: config.lingeringMaxRadius,
+            maxRadius: config.lingeringMaxRadius,
+            createdTick: system.currentTick,
+            maxLifetime: config.lingeringLifetime,
+            affectedEntities: new Set(),
+            handler: config.handler,
+        };
+        this.areaEffectClouds.set(cloud.id, cloud);
+        projectile.remove();
+    }
+    updateCloud(cloud) {
+        const dimension = world.getDimension(cloud.dimension);
+        const age = system.currentTick - cloud.createdTick;
+        const ageProgress = Math.min(age / cloud.maxLifetime, 1);
+        cloud.currentRadius = Math.max(0, cloud.maxRadius * (1 - ageProgress));
+        if (age >= cloud.maxLifetime || cloud.currentRadius <= 0) {
+            this.areaEffectClouds.delete(cloud.id);
+            return;
+        }
+        const variables = new MolangVariableMap();
+        variables.setFloat("cloud_lifetime", cloud.maxLifetime / 20);
+        variables.setFloat("cloud_radius", cloud.currentRadius);
+        variables.setFloat("particle_multiplier", cloud.currentRadius / cloud.maxRadius);
+        variables.setColorRGBA("color", cloud.color);
+        dimension.spawnParticle("minecraft:mobspell_lingering", cloud.location, variables);
+        if (age < 20)
+            return;
+        const nearbyEntities = dimension.getEntities({
+            location: cloud.location,
+            maxDistance: cloud.currentRadius + 1,
+            excludeTypes: ["minecraft:item", "minecraft:arrow", "minecraft:xp_orb"],
+        });
+        for (const entity of nearbyEntities) {
+            if (cloud.affectedEntities.has(entity.id))
+                continue;
+            cloud.handler(entity, cloud.amplifier, Math.floor(cloud.duration), cloud.color);
+            cloud.currentRadius = Math.max(0, cloud.currentRadius - 0.5);
+            cloud.maxLifetime = Math.max(0, cloud.maxLifetime - 100);
+            cloud.affectedEntities.add(entity.id);
+            system.runTimeout(() => {
+                cloud.affectedEntities.delete(entity.id);
+            }, 60);
+        }
+    }
+    getColorFromEntity(entity, namespace) {
+        return {
+            red: entity.getProperty(`${namespace}:color_r`),
+            green: entity.getProperty(`${namespace}:color_g`),
+            blue: entity.getProperty(`${namespace}:color_b`),
+            alpha: entity.getProperty(`${namespace}:color_a`),
+        };
     }
 }
-export { EffectManager };
+const effectManager = EffectManager.getInstance();
+export { EffectManager, effectManager };
 //# sourceMappingURL=effectsAPI.js.map