sapdon 2.0.2 → 3.0.0

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,202 @@
+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>;
+}