sapdon 3.0.0 → 3.0.2

package/dist/core/entity/behavior/randomStroll.js

@@ -1,63 +0,0 @@
-export class RandomStrollBehavior {
-    /**
-     * 随机漫步行为
-     * @param {number} priority 优先级
-     * @param {number} interval 间隔
-     * @param {number} speed_multiplier 速度倍数
-     */
-    constructor(priority, interval, speed_multiplier) {
-        // 参数验证
-        if (typeof priority !== "number" || priority < 0) {
-            throw new Error("priority 必须是一个非负数");
-        }
-        if (typeof interval !== "number" || interval <= 0) {
-            throw new Error("interval 必须是一个正数");
-        }
-        if (typeof speed_multiplier !== "number" || speed_multiplier <= 0) {
-            throw new Error("speed_multiplier 必须是一个正数");
-        }
-        // 初始化属性
-        this.priority = priority;
-        this.interval = interval;
-        this.speed_multiplier = speed_multiplier;
-        this.xz_dist = 10; // 默认水平距离
-        this.y_dist = 7; // 默认垂直距离
-    }
-    /**
-     * 设置水平距离
-     * @param {number} xz_dist 水平距离
-     * @returns {EntityBehaviorRandomStroll} 返回当前实例以支持链式调用
-     */
-    setXZDist(xz_dist) {
-        if (typeof xz_dist !== "number" || xz_dist < 1) {
-            throw new Error("xz_dist 必须是一个至少为 1 的整数");
-        }
-        this.xz_dist = xz_dist;
-        return this;
-    }
-    /**
-     * 设置垂直距离
-     * @param {number} y_dist 垂直距离
-     * @returns {EntityBehaviorRandomStroll} 返回当前实例以支持链式调用
-     */
-    setYDist(y_dist) {
-        if (typeof y_dist !== "number" || y_dist < 1) {
-            throw new Error("y_dist 必须是一个至少为 1 的整数");
-        }
-        this.y_dist = y_dist;
-        return this;
-    }
-    /**
-     * 将组件转换为 JSON 对象
-     * @returns {Object} minecraft:behavior.random_stroll 组件的 JSON 对象
-     */
-    toJSON() {
-        return new Map().set("minecraft:behavior.random_stroll", {
-            priority: this.priority,
-            interval: this.interval,
-            speed_multiplier: this.speed_multiplier,
-            xz_dist: this.xz_dist,
-            y_dist: this.y_dist,
-        });
-    }
-}

package/dist/core/entity/behavior/tempt.d.ts

@@ -1,73 +0,0 @@
-export class TemptBehavior {
-    /**
-     * 创建 minecraft:behavior.tempt 组件。
-     * @param {number} priority 行为的优先级
-     */
-    constructor(priority: number);
-    priority: number;
-    can_get_scared: boolean;
-    can_tempt_vertically: boolean;
-    can_tempt_while_ridden: boolean;
-    items: any[];
-    sound_interval: {
-        range_min: number;
-        range_max: number;
-    };
-    speed_multiplier: number;
-    tempt_sound: string;
-    within_radius: number;
-    /**
-     * 设置是否会被吓跑。
-     * @param {boolean} canGetScared 是否会被吓跑
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canGetScared(canGetScared: boolean): Tempt;
-    /**
-     * 设置是否考虑垂直距离。
-     * @param {boolean} canTemptVertically 是否考虑垂直距离
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canTemptVertically(canTemptVertically: boolean): Tempt;
-    /**
-     * 设置是否在被骑乘时被吸引。
-     * @param {boolean} canTemptWhileRidden 是否在被骑乘时被吸引
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canTemptWhileRidden(canTemptWhileRidden: boolean): Tempt;
-    /**
-     * 设置吸引实体的物品列表。
-     * @param {Array} items 吸引实体的物品列表
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setItems(items: any[]): Tempt;
-    /**
-     * 设置播放吸引声音的随机间隔时间。
-     * @param {number} min 最小间隔时间
-     * @param {number} max 最大间隔时间
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setSoundInterval(min: number, max: number): Tempt;
-    /**
-     * 设置移动速度倍数。
-     * @param {number} speedMultiplier 移动速度倍数
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setSpeedMultiplier(speedMultiplier: number): Tempt;
-    /**
-     * 设置吸引时播放的声音。
-     * @param {string} temptSound 吸引时播放的声音
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setTemptSound(temptSound: string): Tempt;
-    /**
-     * 设置吸引的最大距离。
-     * @param {number} withinRadius 吸引的最大距离
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setWithinRadius(withinRadius: number): Tempt;
-    /**
-     * 将组件转换为 JSON 对象。
-     * @returns {Object} minecraft:behavior.tempt 组件的 JSON 对象
-     */
-    toJSON(): any;
-}

package/dist/core/entity/behavior/tempt.js

@@ -1,134 +0,0 @@
-export class TemptBehavior {
-    /**
-     * 创建 minecraft:behavior.tempt 组件。
-     * @param {number} priority 行为的优先级
-     */
-    constructor(priority) {
-        if (typeof priority !== "number" || priority < 0) {
-            throw new Error("priority 必须是一个非负数");
-        }
-        this.priority = priority;
-        this.can_get_scared = false;
-        this.can_tempt_vertically = false;
-        this.can_tempt_while_ridden = false;
-        this.items = [];
-        this.sound_interval = { range_min: 0.0, range_max: 0.0 };
-        this.speed_multiplier = 1.0;
-        this.tempt_sound = null;
-        this.within_radius = 0.0;
-    }
-    /**
-     * 设置是否会被吓跑。
-     * @param {boolean} canGetScared 是否会被吓跑
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canGetScared(canGetScared) {
-        if (typeof canGetScared !== "boolean") {
-            throw new Error("canGetScared 必须是布尔类型");
-        }
-        this.can_get_scared = canGetScared;
-        return this;
-    }
-    /**
-     * 设置是否考虑垂直距离。
-     * @param {boolean} canTemptVertically 是否考虑垂直距离
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canTemptVertically(canTemptVertically) {
-        if (typeof canTemptVertically !== "boolean") {
-            throw new Error("canTemptVertically 必须是布尔类型");
-        }
-        this.can_tempt_vertically = canTemptVertically;
-        return this;
-    }
-    /**
-     * 设置是否在被骑乘时被吸引。
-     * @param {boolean} canTemptWhileRidden 是否在被骑乘时被吸引
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    canTemptWhileRidden(canTemptWhileRidden) {
-        if (typeof canTemptWhileRidden !== "boolean") {
-            throw new Error("canTemptWhileRidden 必须是布尔类型");
-        }
-        this.can_tempt_while_ridden = canTemptWhileRidden;
-        return this;
-    }
-    /**
-     * 设置吸引实体的物品列表。
-     * @param {Array} items 吸引实体的物品列表
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setItems(items) {
-        if (!Array.isArray(items) || items.length === 0) {
-            throw new Error("items 必须是一个非空数组");
-        }
-        this.items = items;
-        return this;
-    }
-    /**
-     * 设置播放吸引声音的随机间隔时间。
-     * @param {number} min 最小间隔时间
-     * @param {number} max 最大间隔时间
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setSoundInterval(min, max) {
-        if (typeof min !== "number" || typeof max !== "number" || min < 0 || max < 0) {
-            throw new Error("min 和 max 必须是非负数");
-        }
-        this.sound_interval = { range_min: min, range_max: max };
-        return this;
-    }
-    /**
-     * 设置移动速度倍数。
-     * @param {number} speedMultiplier 移动速度倍数
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setSpeedMultiplier(speedMultiplier) {
-        if (typeof speedMultiplier !== "number" || speedMultiplier <= 0) {
-            throw new Error("speedMultiplier 必须是一个正数");
-        }
-        this.speed_multiplier = speedMultiplier;
-        return this;
-    }
-    /**
-     * 设置吸引时播放的声音。
-     * @param {string} temptSound 吸引时播放的声音
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setTemptSound(temptSound) {
-        if (typeof temptSound !== "string") {
-            throw new Error("temptSound 必须是字符串");
-        }
-        this.tempt_sound = temptSound;
-        return this;
-    }
-    /**
-     * 设置吸引的最大距离。
-     * @param {number} withinRadius 吸引的最大距离
-     * @returns {Tempt} 返回当前实例以支持链式调用
-     */
-    setWithinRadius(withinRadius) {
-        if (typeof withinRadius !== "number" || withinRadius < 0) {
-            throw new Error("withinRadius 必须是一个非负数");
-        }
-        this.within_radius = withinRadius;
-        return this;
-    }
-    /**
-     * 将组件转换为 JSON 对象。
-     * @returns {Object} minecraft:behavior.tempt 组件的 JSON 对象
-     */
-    toJSON() {
-        return new Map().set("minecraft:behavior.tempt", {
-            priority: this.priority,
-            can_get_scared: this.can_get_scared,
-            can_tempt_vertically: this.can_tempt_vertically,
-            can_tempt_while_ridden: this.can_tempt_while_ridden,
-            items: this.items,
-            sound_interval: this.sound_interval,
-            speed_multiplier: this.speed_multiplier,
-            tempt_sound: this.tempt_sound,
-            within_radius: this.within_radius,
-        });
-    }
-}

package/dist/core/entity/bundles/basicBundle.d.ts

@@ -1,13 +0,0 @@
-export class BasicBundle {
-    /**
-     * 添加组件到捆绑包
-     * @param {Map} componentMap 组件
-     * @returns {BasicBundle} 返回捆绑包对象
-     */
-    addComponent(componentMap: Map<any, any>): BasicBundle;
-    addComponents(components: any): void;
-    removeComponent(name: any): this;
-    serialize(): Map<any, any>;
-    #private;
-}
-export const BasicMovementBundle: BasicBundle;

package/dist/core/entity/bundles/basicBundle.js

@@ -1,45 +0,0 @@
-import { EntityComponent } from "../componets/entityComponet.js";
-export class BasicBundle {
-    //私有属性 存储组件
-    #components = new Map();
-    /**
-     * 捆绑包 捆绑包是一个附带有一些实体组件的集合，能够方便地将这些组件添加到一个实体上。
-     */
-    constructor() {
-        //空构造函数
-    }
-    /**
-     * 添加组件到捆绑包
-     * @param {Map} componentMap 组件
-     * @returns {BasicBundle} 返回捆绑包对象
-     */
-    addComponent(componentMap) {
-        if (!(componentMap instanceof Map)) {
-            throw new Error("componentMap must be an instance of Map.");
-        }
-        for (const [key, value] of componentMap) {
-            this.#components.set(key, value);
-        }
-        return this; // 支持链式调用
-    }
-    addComponents(components) {
-        components.forEach(component_map => {
-            this.addComponent(component_map);
-        });
-    }
-    removeComponent(name) {
-        this.#components.delete(name);
-        return this;
-    }
-    //序列化
-    serialize() {
-        return this.#components;
-    }
-}
-//移动捆绑包
-export const BasicMovementBundle = new BasicBundle();
-MovementBundle.addComponents([
-    //speed
-    EntityComponent.setMovement(0.2),
-    EntityComponent.setMovementBasic()
-]);

package/dist/core/entity/clientEntity.d.ts

@@ -1,20 +0,0 @@
-/**
- * ClientEntity 类，用于表示客户端实体。
- * 继承自 AddonClientEntityDescription，并扩展了实体的数据加载和 JSON 序列化功能。
- */
-export class ClientEntity extends AddonClientEntityDescription {
-    /**
-     * 构造函数，用于创建一个客户端实体实例。
-     *
-     * @param {string} identifier - 实体的唯一标识符。
-     * @param {Object} data - 实体的初始数据，默认为空对象。
-     */
-    constructor(identifier: string, data?: any);
-    /**
-     * 将当前实体实例转换为 JSON 格式。
-     *
-     * @returns {Object} - 表示实体的 JSON 对象。
-     */
-    toJson(): any;
-}
-import { AddonClientEntityDescription } from "../addon/entity/clientEntity.js";

package/dist/core/entity/clientEntity.js

@@ -1,37 +0,0 @@
-import { AddonClientEntity, AddonClientEntityDefinition, AddonClientEntityDescription } from "../addon/entity/clientEntity.js";
-/**
- * ClientEntity 类，用于表示客户端实体。
- * 继承自 AddonClientEntityDescription，并扩展了实体的数据加载和 JSON 序列化功能。
- */
-export class ClientEntity extends AddonClientEntityDescription {
-    /**
-     * 构造函数，用于创建一个客户端实体实例。
-     *
-     * @param {string} identifier - 实体的唯一标识符。
-     * @param {Object} data - 实体的初始数据，默认为空对象。
-     */
-    constructor(identifier, data = {}) {
-        // 调用父类构造函数，初始化实体的标识符
-        super(identifier);
-        // 遍历传入的数据对象，将属性赋值到当前实例
-        const keys = Object.keys(data);
-        keys.forEach((key) => {
-            // 跳过 "identifier" 属性，因为已经在父类中处理
-            if (key === "identifier")
-                return;
-            // 将数据对象的属性赋值到当前实例
-            this[key] = data[key];
-        });
-    }
-    /**
-     * 将当前实体实例转换为 JSON 格式。
-     *
-     * @returns {Object} - 表示实体的 JSON 对象。
-     */
-    toJson() {
-        // 创建一个 AddonClientEntity 实例，包含实体定义和版本信息
-        return new AddonClientEntity("1.10.0", // 版本号
-        new AddonClientEntityDefinition(this) // 实体定义
-        ).toJson(); // 调用 toJson 方法，返回 JSON 格式的数据
-    }
-}

package/dist/core/entity/componets/entityComponet.d.ts

@@ -1,202 +0,0 @@
-export class EntityComponent {
-    static setMovement(speed: any): Map<any, any>;
-    static setCollisionBox(width: any, height: any): Map<any, any>;
-    /**
-       * 将多个组件集合合并为一个。
-       * @param {...Map} componentMaps - 多个组件集合。
-       * @returns {Map} - 合并后的组件集合。
-       */
-    static combineComponents(...componentMaps: Map<any, any>[]): Map<any, any>;
-    /**
-       * 创建 minecraft:health 组件。
-       * @param {Object} options 配置选项
-       * @param {number} options.max 实体的最大生命值
-       * @param {number|Object} options.value 实体的初始生命值（可以是固定值或范围值）
-       * @returns {Map} 包含 minecraft:health 组件的 Map 对象
-       * @throws {Error} 如果参数无效。
-       */
-    static setHealth(options?: {
-        max: number;
-        value: number | any;
-    }): Map<any, any>;
-    /**
-     * 验证 minecraft:health 组件的参数。
-     * @param {number} max 最大生命值
-     * @param {number|Object} value 初始生命值
-     * @throws {Error} 如果参数无效。
-     */
-    static validateHealthParameters(max: number, value: number | any): void;
-    /**
-     * 创建 minecraft:physics 组件。
-     * @param {boolean} has_collision 是否碰撞（默认：true）
-     * @param {boolean} has_gravity 是否受重力影响（默认：true）
-     * @param {boolean} push_towards_closest_space 是否在卡住时推向最近空间（默认：false）
-     * @returns {Map} 包含 minecraft:physics 组件的 Map 对象
-     * @throws {Error} 如果参数不是布尔类型。
-     */
-    static setPhysics(has_collision?: boolean, has_gravity?: boolean, push_towards_closest_space?: boolean): Map<any, any>;
-    /**
-   * 创建 minecraft:scale 组件。
-   * @param {number} value 实体的缩放比例（默认：1.0）
-   * @returns {Map} 包含 minecraft:scale 组件的 Map 对象
-   * @throws {Error} 如果参数无效。
-   */
-    static setScale(value?: number): Map<any, any>;
-    /**
-   * 创建默认的 minecraft:nameable 组件（不填写参数）。
-   * @returns {Map} 包含 minecraft:nameable 组件的 Map 对象
-   */
-    static setDefaultNameable(): Map<any, any>;
-    /**
-     * 创建自定义的 minecraft:nameable 组件（填写参数）。
-     * @param {boolean} allowNameTagRenaming 是否允许使用命名牌重命名（默认：true）
-     * @param {boolean} alwaysShow 是否始终显示名称（默认：false）
-     * @param {Object} defaultTrigger 默认触发事件（可选）
-     * @param {Array} nameActions 特殊名称及其对应的事件（可选）
-     * @returns {Map} 包含 minecraft:nameable 组件的 Map 对象
-     * @throws {Error} 如果参数无效。
-     */
-    static setCustomNameable(allowNameTagRenaming?: boolean, alwaysShow?: boolean, defaultTrigger?: any, nameActions?: any[]): Map<any, any>;
-    /**
-     * 创建 minecraft:pushable 组件。
-     * @param {boolean} isPushable 是否可以被其他实体推动（默认：true）
-     * @param {boolean} isPushableByPiston 是否可以被活塞推动（默认：true）
-     * @returns {Map} 包含 minecraft:pushable 组件的 Map 对象
-     * @throws {Error} 如果参数无效。
-     */
-    static setPushable(isPushable?: boolean, isPushableByPiston?: boolean): Map<any, any>;
-    /**
-       * 创建 minecraft:jump.static 组件。
-       * @param {number} jumpPower 跳跃的初始垂直速度（默认：0.42）
-       * @returns {Map} 包含 minecraft:jump.static 组件的 Map 对象
-       * @throws {Error} 如果参数无效。
-       */
-    static setJumpStatic(jumpPower?: number): Map<any, any>;
-    /**
-    * 创建 minecraft:navigation.walk 组件。
-    * @param {Object} options 配置选项
-    * @param {boolean} options.avoidDamageBlocks 是否避免伤害性方块（默认：false）
-    * @param {boolean} options.avoidPortals 是否避免传送门（默认：false）
-    * @param {boolean} options.avoidSun 是否避免阳光下的方块（默认：false）
-    * @param {boolean} options.avoidWater 是否避免水（默认：false）
-    * @param {Array} options.blocksToAvoid 需要避免的方块列表（默认：[]）
-    * @param {boolean} options.canBreach 是否可以跳出水面（默认：false）
-    * @param {boolean} options.canBreakDoors 是否可以破坏门（默认：false）
-    * @param {boolean} options.canFloat 是否可以漂浮（默认：false）
-    * @param {boolean} options.canJump 是否可以跳跃（默认：true）
-    * @param {boolean} options.canOpenDoors 是否可以开门（默认：false）
-    * @param {boolean} options.canOpenIronDoors 是否可以开铁门（默认：false）
-    * @param {boolean} options.canPassDoors 是否可以穿过门（默认：true）
-    * @param {boolean} options.canPathFromAir 是否可以在空中开始路径规划（默认：false）
-    * @param {boolean} options.canPathOverLava 是否可以在熔岩表面行走（默认：false）
-    * @param {boolean} options.canPathOverWater 是否可以在水面上行走（默认：false）
-    * @param {boolean} options.canSink 是否会在水中下沉（默认：true）
-    * @param {boolean} options.canSwim 是否可以游泳（默认：false）
-    * @param {boolean} options.canWalk 是否可以在地面上行走（默认：true）
-    * @param {boolean} options.canWalkInLava 是否可以在熔岩中行走（默认：false）
-    * @param {boolean} options.isAmphibious 是否可以在水下行走（默认：false）
-    * @returns {Map} 包含 minecraft:navigation.walk 组件的 Map 对象
-    * @throws {Error} 如果参数无效。
-    */
-    static setNavigationWalk(options?: {
-        avoidDamageBlocks: boolean;
-        avoidPortals: boolean;
-        avoidSun: boolean;
-        avoidWater: boolean;
-        blocksToAvoid: any[];
-        canBreach: boolean;
-        canBreakDoors: boolean;
-        canFloat: boolean;
-        canJump: boolean;
-        canOpenDoors: boolean;
-        canOpenIronDoors: boolean;
-        canPassDoors: boolean;
-        canPathFromAir: boolean;
-        canPathOverLava: boolean;
-        canPathOverWater: boolean;
-        canSink: boolean;
-        canSwim: boolean;
-        canWalk: boolean;
-        canWalkInLava: boolean;
-        isAmphibious: boolean;
-    }): Map<any, any>;
-    /**
-     * 创建 minecraft:movement.basic 组件。
-     * @param {number} maxTurn 实体每 tick 可以转向的最大角度（默认：30.0）
-     * @returns {Map} 包含 minecraft:movement.basic 组件的 Map 对象
-     * @throws {Error} 如果参数无效。
-     */
-    static setMovementBasic(maxTurn?: number): Map<any, any>;
-    /**
-     * 创建 minecraft:projectile 组件。
-     * @param {Object} options 配置选项
-     * @param {number} options.anchor 发射锚点（默认：0）
-     * @param {number} options.angleOffset 角度偏移（默认：0.0）
-     * @param {boolean} options.catchFire 是否点燃目标（默认：false）
-     * @param {boolean} options.critParticleOnHurt 是否生成暴击粒子（默认：false）
-     * @param {boolean} options.destroyOnHurt 是否在击中时销毁（默认：false）
-     * @param {string} options.filter 过滤的实体（可选）
-     * @param {boolean} options.fireAffectedByGriefing 是否受游戏规则影响（默认：false）
-     * @param {number} options.gravity 重力值（默认：0.05）
-     * @param {string} options.hitSound 击中声音（可选）
-     * @param {string} options.hitGroundSound 击中地面声音（可选）
-     * @param {boolean} options.homing 是否追踪目标（默认：false）
-     * @param {number} options.inertia 空气惯性（默认：0.99）
-     * @param {boolean} options.isDangerous 是否对玩家危险（默认：false）
-     * @param {boolean} options.knockback 是否击退目标（默认：true）
-     * @param {boolean} options.lightning 是否召唤闪电（默认：false）
-     * @param {number} options.liquidInertia 水中惯性（默认：0.6）
-     * @param {boolean} options.multipleTargets 是否可击中多个目标（默认：true）
-     * @param {number[]} options.offset 发射偏移量（默认：[0, 0, 0]）
-     * @param {number} options.onFireTime 着火时间（默认：0.0）
-     * @param {Object} options.onHit 击中时的行为（可选）
-     * @param {string} options.particle 碰撞粒子（默认："ironcrack"）
-     * @param {number} options.power 初始速度（默认：1.3）
-     * @param {number} options.reflectImmunity 反射免疫时间（默认：0.0）
-     * @param {boolean} options.reflectOnHurt 是否反射（默认：false）
-     * @param {string} options.shootSound 发射声音（可选）
-     * @param {boolean} options.shootTarget 是否朝向目标发射（默认：true）
-     * @param {boolean} options.shouldBounce 是否反弹（默认：false）
-     * @param {boolean} options.splashPotion 是否为喷溅药水（默认：false）
-     * @param {number} options.splashRange 喷溅范围（默认：4）
-     * @param {boolean} options.stopOnHurt 是否在击中时停止（默认：false）
-     * @param {number} options.uncertaintyBase 基础精度（默认：0）
-     * @param {number} options.uncertaintyMultiplier 精度倍数（默认：0）
-     * @returns {Map} 包含 minecraft:projectile 组件的 Map 对象
-     * @throws {Error} 如果参数无效。
-     */
-    static setProjectile(options?: {
-        anchor: number;
-        angleOffset: number;
-        catchFire: boolean;
-        critParticleOnHurt: boolean;
-        destroyOnHurt: boolean;
-        filter: string;
-        fireAffectedByGriefing: boolean;
-        gravity: number;
-        hitSound: string;
-        hitGroundSound: string;
-        homing: boolean;
-        inertia: number;
-        isDangerous: boolean;
-        knockback: boolean;
-        lightning: boolean;
-        liquidInertia: number;
-        multipleTargets: boolean;
-        offset: number[];
-        onFireTime: number;
-        onHit: any;
-        particle: string;
-        power: number;
-        reflectImmunity: number;
-        reflectOnHurt: boolean;
-        shootSound: string;
-        shootTarget: boolean;
-        shouldBounce: boolean;
-        splashPotion: boolean;
-        splashRange: number;
-        stopOnHurt: boolean;
-        uncertaintyBase: number;
-        uncertaintyMultiplier: number;
-    }): Map<any, any>;
-}