sapdon 3.0.2 → 3.1.0

package/dist/core/ui/systems/guidebook.js

@@ -0,0 +1,206 @@
+import { ButtonMapping } from "../buttonMapping.js";
+import { DataBindingObject } from "../dataBindingObject.js";
+import { Button } from "../elements/button.js";
+import { Image } from "../elements/image.js";
+import { Label } from "../elements/label.js";
+import { Panel } from "../elements/panel.js";
+import { StackPanel } from "../elements/stackPanel.js";
+import { UIElement } from "../elements/uiElement.js";
+import { Control } from "../properties/control.js";
+import { Input } from "../properties/input.js";
+import { Layout } from "../properties/layout.js";
+import { Sprite } from "../properties/sprite.js";
+import { Text } from "../properties/text.js";
+import { ServerUISystem } from "./serverForm.js";
+import { UISystem } from "./system.js";
+//表单按钮模板
+const form_button_template = new Button("form_button_template", "common.button");
+form_button_template.addVariable("default_texture|default", "");
+form_button_template.addVariable("hover_texture|default", "");
+form_button_template.addVariable("pressed_texture|default", "");
+form_button_template.addVariable("binding_button_text|default", "");
+form_button_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("collection_details")
+    .setBindingCollectionName("form_buttons"));
+form_button_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("collection")
+    .setBindingCollectionName("form_buttons")
+    .setBindingName("#form_button_text"));
+form_button_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("view")
+    .setSourcePropertyName("($binding_button_text = #form_button_text)")
+    .setTargetPropertyName("#visible"));
+form_button_template.addControls([
+    new Image("default").setSprite(new Sprite().setTexture("$default_texture")),
+    new Image("hover").setSprite(new Sprite().setTexture("$hover_texture")),
+    new Image("pressed").setSprite(new Sprite().setTexture("$pressed_texture"))
+]);
+//f
+const form_button_panel = new Panel("form_button_factory").enableDebug();
+form_button_panel.addProp("type", "collection_panel");
+form_button_panel.factory.setName("buttons").setControlName("$button_control");
+form_button_panel.addProp("collection_name", "form_buttons");
+form_button_panel.dataBinding.addDataBinding(new DataBindingObject().setBindingName("#form_button_length")
+    .setBindingNameOverride("#collection_length"));
+const page_template = new StackPanel("page_template").setOrientation("horizontal")
+    .addVariable("page_left_content | default", "")
+    .addVariable("page_right_content | default", "")
+    .setLayout(new Layout().setSize(["90%", "90%"]))
+    .addStack(["50%", "100%"], new UIElement("page_left", undefined, "$page_left_content").serialize())
+    .addStack(["50%", "100%"], new UIElement("page_right", undefined, "$page_right_content").serialize());
+page_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("view")
+    .setSourcePropertyName("($binding_text = #form_text)")
+    .setTargetPropertyName("#visible"));
+export class Guidebook {
+    #bindingList = [];
+    constructor(identifier, path) {
+        this.system = new UISystem(identifier, path);
+        //init
+        this.#binding();
+        this.#addTemplate();
+        this.#updateSystem();
+    }
+    addPageBinding(page_name, left_control_name, right_control_name) {
+        this.#bindingList.push({
+            page_name: page_name,
+            left_control_name: left_control_name,
+            right_control_name: right_control_name
+        });
+        //更新系统
+        this.#updateSystem();
+        return this;
+    }
+    addPage(page_name, left_control, right_control) {
+        this.addPageBinding(page_name, left_control.name, right_control.name);
+        //添加元素
+        this.addElement(left_control);
+        this.addElement(right_control);
+        //更新系统
+        this.#updateSystem();
+        return this;
+    }
+    addElement(element) {
+        this.system.addElement(element);
+        return this;
+    }
+    #binding() {
+        ServerUISystem.bindingTitlewithContent(this.system.name, `${this.system.namespace}.guidebook_root_panel`);
+    }
+    #addTemplate() {
+        this.addElement(form_button_template);
+        this.addElement(form_button_panel);
+        this.addElement(page_template);
+        //
+        this.#updateSystem();
+    }
+    #updateSystem() {
+        const guidebook_root_panel = new Panel("guidebook_root_panel");
+        //开启调试框
+        //guidebook_root_panel.enableDebug()
+        //设置布局属性
+        guidebook_root_panel.setLayout(new Layout().setSize([320, 207]));
+        //添加子元素
+        guidebook_root_panel.addControls([
+            //添加背景
+            new UIElement("book_background", undefined, "book.book_background"),
+            //添加书页
+            new StackPanel("book_page_stack_panel").setOrientation("horizontal")
+                .setLayout(new Layout().setSize([320, 207]))
+                .addVariable("page_size", [160, 207])
+                .addStack("$page_size", new Panel("book_left_panel").addControls([
+                {
+                    "page_crease_image@book.page_crease_left_image": {
+                        "size": ["100% - 40px", "100% - 14px"],
+                        "offset": [0, -2]
+                    }
+                },
+                {
+                    "page_edge_image@book.page_edge_left_image": {
+                        "size": ["100% - 7px", "100% - 16px"],
+                        "offset": [7, -1]
+                    }
+                }
+            ]).serialize())
+                .addStack("$page_size", new Panel("book_right_panel").addControls([
+                {
+                    "page_crease_image@book.page_crease_right_image": {
+                        "size": ["100% - 40px", "100% - 14px"],
+                        "offset": [0, -2]
+                    }
+                },
+                {
+                    "page_edge_image@book.page_edge_right_image": {
+                        "size": ["100% - 7px", "100% - 16px"],
+                        "offset": [-7, -1]
+                    }
+                }
+            ]).serialize()),
+            //添加书页内容
+            new Panel("page_content_root")
+                .setControl(new Control().setLayer(5))
+                .setLayout(new Layout().setSize(["90%", "90%"]))
+                .addControls([
+                new Panel("label_text_panel").setLayout(new Layout().setSize([32, 8]).setAnchorFrom("bottom_middle")
+                    .setAnchorTo("bottom_middle")).addControl(new Label("page_content").setText(new Text().setText("#form_text").setColor([0, 0, 0]))),
+                ...this.#bindingList.map(({ page_name, left_control_name, right_control_name }, index) => {
+                    return new UIElement(`page_index_${index}`, undefined, "page_template")
+                        .addVariable("binding_text", page_name)
+                        .addVariable("page_left_content", left_control_name)
+                        .addVariable("page_right_content", right_control_name);
+                })
+                /*
+                new UIElement("page_1",undefined,"page_template")
+                .addVariable("binding_text","page_index1")
+                .addVariable("page_left_content","page_left_content")
+                .addVariable("page_right_content","page_right_content"),
+                new UIElement("page_2",undefined,"page_template")
+                .addVariable("binding_text","page_index2")
+                .addVariable("page_left_content","page_left_content")
+                .addVariable("page_right_content","page_right_content"),
+                new UIElement("page_3",undefined,"page_template")
+                .addVariable("binding_text","page_index3")
+                .addVariable("page_left_content","page_left_content")
+                .addVariable("page_right_content","page_right_content")*/
+            ]),
+            //添加关闭按钮
+            new Button("close_button").setLayout(new Layout().setSize([14, 14])
+                .setAnchorFrom("top_right")
+                .setAnchorTo("top_right"))
+                .setInput(new Input().setButtonMappings([
+                new ButtonMapping().setMappingType("pressed")
+                    .setFromButtonId("button.menu_select")
+                    .setToButtonId("button.menu_exit")
+            ]))
+                .addControls([
+                new UIElement("default", undefined, "book.close_button_default"),
+                new UIElement("hover", undefined, "book.close_button_hover"),
+                new UIElement("pressed", undefined, "book.close_button_pressed"),
+            ]),
+            //添加下一页按钮
+            new Panel("prev_button_panel").enableDebug()
+                .setControl(new Control().setLayer(5))
+                .setLayout(new Layout().setSize([24, 24])
+                .setOffset([7, -9])
+                .setAnchorFrom("bottom_left")
+                .setAnchorTo("bottom_left"))
+                .addControl(new UIElement("prev_button", undefined, "form_button_factory")
+                .addVariable("binding_button_text", "test1")
+                .addVariable("button_control", `${this.system.namespace}.form_button_template`)
+                .addVariable("pressed_button_name", "button.form_button_click")
+                .addVariable("default_texture", "textures/ui/book_pageleft_default")
+                .addVariable("hover_texture", "textures/ui/book_pageleft_hover")
+                .addVariable("pressed_texture", "textures/ui/book_pageleft_pressed")),
+            new Panel("next_button_panel").enableDebug()
+                .setControl(new Control().setLayer(5))
+                .setLayout(new Layout().setSize([24, 24])
+                .setOffset([-7, -9])
+                .setAnchorFrom("bottom_right")
+                .setAnchorTo("bottom_right"))
+                .addControl(new UIElement("next_button", undefined, "form_button_factory")
+                .addVariable("binding_button_text", "test2")
+                .addVariable("button_control", "sapdon_guidebook.form_button_template")
+                .addVariable("pressed_button_name", "button.form_button_click")
+                .addVariable("default_texture", "textures/ui/book_pageright_default")
+                .addVariable("hover_texture", "textures/ui/book_pageright_hover")
+                .addVariable("pressed_texture", "textures/ui/book_pageright_pressed"))
+        ]);
+        this.addElement(guidebook_root_panel);
+    }
+}

package/dist/core/ui/systems/serverForm.d.ts

@@ -0,0 +1,13 @@
+export const ServerFormSystem: UISystem;
+export const form_button_panel: Panel;
+export class ServerUISystem {
+    static "__#4@#binding_map": Map<any, any>;
+    static "__#4@#binding_title_list": any[];
+    static addBindingTitle(title_name: any): void;
+    static getBindingTitleList(): any[];
+    static getBindingContentList(): any[];
+    static bindingTitlewithContent(title_name: any, content: any): void;
+    static "__#4@#updateServerFormSystem"(): void;
+}
+import { UISystem } from "./system.js";
+import { Panel } from "../elements/panel.js";

package/dist/core/ui/systems/serverForm.js

@@ -0,0 +1,116 @@
+import { Modifications, UIElement } from "../elements/uiElement.js";
+import { DataBindingObject } from "../dataBindingObject.js";
+import { UISystem } from "./system.js";
+import { Panel } from "../elements/panel.js";
+import { Button } from "../elements/button.js";
+import { Image } from "../elements/image.js";
+import { Sprite } from "../properties/sprite.js";
+export const ServerFormSystem = new UISystem("server_form:server_form", "ui/");
+//表单按钮模板
+const form_button_template = new Button("sapdon_form_button_template", "common.button");
+form_button_template.addVariable("pressed_button_name", "button.form_button_click");
+form_button_template.addVariable("default_texture|default", "textures/gui/newgui/buttons/borderless/light");
+form_button_template.addVariable("hover_texture|default", "textures/gui/newgui/buttons/borderless/lighthover");
+form_button_template.addVariable("pressed_texture|default", "textures/gui/newgui/buttons/borderless/lightpressed");
+form_button_template.addVariable("binding_button_text|default", "");
+form_button_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("collection_details")
+    .setBindingCollectionName("form_buttons"));
+form_button_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("collection")
+    .setBindingCollectionName("form_buttons")
+    .setBindingName("#form_button_text"));
+form_button_template.dataBinding.addDataBinding(new DataBindingObject().setBindingType("view")
+    .setSourcePropertyName("($binding_button_text = #form_button_text)")
+    .setTargetPropertyName("#visible"));
+form_button_template.addControls([
+    new Image("default").setSprite(new Sprite().setTexture("$default_texture")),
+    new Image("hover").setSprite(new Sprite().setTexture("$hover_texture")),
+    new Image("pressed").setSprite(new Sprite().setTexture("$pressed_texture"))
+]);
+//f
+export const form_button_panel = new Panel("sapdon_form_button_factory");
+form_button_panel.addProp("type", "collection_panel");
+form_button_panel.factory.setName("buttons").setControlName("sapdon_form_button_template");
+form_button_panel.addProp("collection_name", "form_buttons");
+form_button_panel.dataBinding.addDataBinding(new DataBindingObject().setBindingName("#form_button_length")
+    .setBindingNameOverride("#collection_length"));
+ServerFormSystem.addElement(form_button_template);
+ServerFormSystem.addElement(form_button_panel);
+export class ServerUISystem {
+    static #binding_map = new Map();
+    static #binding_title_list = [];
+    static addBindingTitle(title_name) {
+        this.#binding_title_list.push(title_name);
+    }
+    static getBindingTitleList() {
+        //console.log("arrr:",Array.from(this.#binding_map.keys()))
+        return this.#binding_title_list.concat(Array.from(this.#binding_map.keys()));
+    }
+    static getBindingContentList() {
+        return Array.from(this.#binding_map.values());
+    }
+    static bindingTitlewithContent(title_name, content) {
+        //添加绑定
+        this.#binding_map.set(title_name, content);
+        this.#updateServerFormSystem();
+    }
+    static #updateServerFormSystem() {
+        //文本化处理
+        //console.log("ttttt:",this.getBindingTitleList())
+        const user_custom_ui_text = this.getBindingTitleList().map((title_name) => {
+            console.log("title_name", title_name);
+            return `'${title_name}'`;
+        }).join('-');
+        const long_form = new UIElement("long_form")
+            .addModification({
+            array_name: "bindings",
+            operation: Modifications.OPERATION.INSERT_BACK,
+            value: [
+                new DataBindingObject().setBindingName("#title_text"),
+                new DataBindingObject().setBindingType("view")
+                    .setSourcePropertyName(`((#title_text - ${user_custom_ui_text}) = #title_text)`)
+                    .setTargetPropertyName("#visible")
+            ]
+        });
+        const custom_server_form_factory = new Panel("custom_server_form_factory");
+        custom_server_form_factory.factory.setName("server_form_factory") //工程名被绑定至表单，不可改动
+            .setControlIds({ "long_form": "@server_form.custom_root_panel" });
+        //加入自定义表单内容
+        const main_screen_content = new UIElement("main_screen_content")
+            .addModification({
+            array_name: "controls",
+            operation: Modifications.OPERATION.INSERT_BACK,
+            value: [
+                custom_server_form_factory.serialize()
+            ]
+        });
+        //自定义ui模板
+        const custom_ui_template = new Panel("custom_ui_template");
+        custom_ui_template.dataBinding.addDataBinding(new DataBindingObject().setBindingName("#title_text")).addDataBinding(new DataBindingObject().setBindingType("view")
+            .setSourcePropertyName("(#title_text = $binding_text)")
+            .setTargetPropertyName("#visible"));
+        custom_ui_template.control.addControl(new UIElement("main", undefined, "$main_content").serialize());
+        //类似于 root ，决定什么时候加载自定义界面 ，不可改动
+        const custom_form_root = new Panel("custom_form_root");
+        //custom_form_root.addVariable("title_needs_to_contain",user_custom_ui_text)
+        custom_form_root.dataBinding.addDataBinding(new DataBindingObject().setBindingType("view")
+            .setSourceControlName("custom_root_panel")
+            .setSourcePropertyName(`(not ((#title_text - ${user_custom_ui_text}) = #title_text))`)
+            .setTargetPropertyName("#visible"));
+        //用户自定义ui内容绑定
+        this.#binding_map.forEach((content, key) => {
+            //加入 root
+            custom_form_root.control.addControl(new UIElement("custom_ui_" + key, undefined, "custom_ui_template")
+                .addVariable("main_content", content)
+                .addVariable("binding_text", key).serialize());
+        });
+        //类似于 sreen，必要，不可改动
+        const custom_root_panel = new Panel("custom_root_panel");
+        custom_root_panel.dataBinding.addDataBinding(new DataBindingObject().setBindingName("#title_text"));
+        custom_root_panel.control.addControl(custom_form_root.serialize());
+        ServerFormSystem
+            .addElement(custom_ui_template)
+            .addElement(long_form)
+            .addElement(custom_root_panel)
+            .addElement(main_screen_content);
+    }
+}

package/dist/core/ui/systems/system.d.ts

@@ -0,0 +1,16 @@
+export class UISystem {
+    constructor(identifier: any, path: any);
+    identifier: any;
+    namespace: any;
+    name: any;
+    path: any;
+    elements: Map<any, any>;
+    animations: Map<any, any>;
+    addElement(element: any): this;
+    getElement(element_name: any): any;
+    addAnimation(name: any, value: any): void;
+    getAnimation(animation_name: any): any;
+    toJson(): {
+        namespace: any;
+    };
+}

package/dist/core/ui/systems/system.js

@@ -0,0 +1,37 @@
+import { UISystemRegistry } from "../registry/uiSystemRegistry.js";
+// UI 文件核心类
+export class UISystem {
+    constructor(identifier, path) {
+        this.identifier = identifier;
+        this.namespace = identifier.split(':')[0];
+        this.name = identifier.split(':')[1];
+        this.path = path;
+        this.elements = new Map();
+        this.animations = new Map();
+        UISystemRegistry.registerUISystem(this);
+    }
+    addElement(element) {
+        this.elements.set(element.id, element);
+        return this;
+    }
+    getElement(element_name) {
+        return this.elements.get(element_name);
+    }
+    addAnimation(name, value) {
+        this.animations.set(name, value);
+    }
+    getAnimation(animation_name) {
+        return this.animations.get(animation_name);
+    }
+    toJson() {
+        const ui = { namespace: this.namespace };
+        //序列化
+        this.elements.forEach((value, key) => {
+            //console.log("elements key:",key)
+            //console.log("elements value:",value);
+            ui[key] = value.serialize()[value.id];
+        });
+        //console.log("ui:",ui)
+        return ui;
+    }
+}

package/dist/oc/actor.js

@@ -0,0 +1,44 @@
+export class Actor {
+    target;
+    manager;
+    constructor(target, manager) {
+        this.target = target;
+        this.manager = manager;
+    }
+    static from(target, manager) {
+        return new Actor(target, manager);
+    }
+    /**
+     * 优先使用 `Actor.getComponent`
+     * @param ctors
+     * @returns
+     */
+    getMinecraftComponent(...ids) {
+        return ids.map(id => this.target.getComponent(id));
+    }
+    /**
+     * 优先使用 `Actor.getComponent`
+     * @param ctors
+     * @returns
+     */
+    getCustomComponent(...ctors) {
+        return this.manager.getComponents(...ctors);
+    }
+    getComponent(...descs) {
+        return descs.map(desc => {
+            if (typeof desc === 'string') {
+                return this.target.getComponent(desc);
+            }
+            return this.manager.getComponentUnsafe(desc);
+        });
+    }
+    addComponent(...components) {
+        return this.manager.attachComponent(...components);
+    }
+    removeComponent(ctor) {
+        return this.manager.detachComponent(ctor);
+    }
+    updateComponent(ctor, fn) {
+        return this.manager.update(ctor, fn);
+    }
+}

package/dist/oc/core.js

@@ -0,0 +1,201 @@
+import { system, world } from '@minecraft/server';
+import { Optional } from './optional.js';
+const REFLECT_MANAGER = Symbol('reflect-manager');
+const REFLECT_ENTITY = Symbol('reflect-entity');
+export class CustomComponent {
+    [REFLECT_MANAGER];
+    [REFLECT_ENTITY] = Optional.none();
+    onTick(manager, en) { }
+    detach(manager) {
+        const ctor = Object.getPrototypeOf(this).constructor;
+        return manager.detachComponent(ctor);
+    }
+    getManager() {
+        return this[REFLECT_MANAGER];
+    }
+    getEntity() {
+        return this[REFLECT_ENTITY];
+    }
+}
+export class BaseComponent extends CustomComponent {
+    onAttach(manager) { }
+    onDetach(manager) { }
+}
+export class ComponentManager {
+    static profilerEnable = false;
+    static global = new ComponentManager();
+    #components = new Map();
+    #prependTicks = [];
+    #nextTicks = [];
+    getComponentUnsafe(ctor) {
+        return this.#components.get(ctor);
+    }
+    getComponent(ctor) {
+        return Optional.some(this.#components.get(ctor));
+    }
+    getComponents(...ctor) {
+        return ctor.map(c => this.#components.get(c));
+    }
+    async #attachComponent(ctor, component, shouldRebuild = true) {
+        let init = !this.#components.get(ctor);
+        if (!init && shouldRebuild) {
+            await this.detachComponent(ctor);
+            init = true;
+        }
+        if (REQUIRED_COMPONENTS in component) {
+            //@ts-ignore
+            for (const [ctor, comp] of component[REQUIRED_COMPONENTS]) {
+                this.#attachComponent(ctor, comp, false);
+            }
+        }
+        if (init && 'onAttach' in component) {
+            await component.onAttach(this);
+        }
+        this.#components.set(ctor, component);
+        return Optional.some(component);
+    }
+    async attachComponent(...component) {
+        const components = [];
+        for (const obj of component) {
+            components.push(await this.#attachComponent(Object.getPrototypeOf(obj).constructor, obj));
+        }
+        return components;
+    }
+    async getOrCreate(ctor, ...args) {
+        let component = this.#components.get(ctor);
+        if (component) {
+            return Optional.some(component);
+        }
+        return this.#attachComponent(ctor, new ctor(...args));
+    }
+    async detachComponent(ctor) {
+        const component = this.#components.get(ctor);
+        if (component && 'onDetach' in component) {
+            await component.onDetach(this);
+        }
+        return this.#components.delete(ctor);
+    }
+    clear() {
+        this.#components.clear();
+    }
+    getComponentKeys() {
+        return this.#components.keys();
+    }
+    has(ctor) {
+        return this.#components.has(ctor);
+    }
+    afterTick(fn) {
+        this.#nextTicks.push(fn);
+    }
+    beforeTick(fn) {
+        this.#prependTicks.unshift(fn);
+    }
+    handleTicks(en) {
+        for (const prependTick of this.#prependTicks) {
+            this.profiler(() => prependTick.call(null, Optional.some(en)));
+            // prependTick.call(null, Optional.some(en))
+        }
+        this.#prependTicks.length = 0;
+        for (const component of this.#components.values()) {
+            //@ts-ignore
+            if (!component[REFLECT_ENTITY]) {
+                //@ts-ignore
+                component[REFLECT_ENTITY] = Optional.some(en);
+            }
+            //@ts-ignore
+            if (!component[REFLECT_MANAGER]) {
+                //@ts-ignore
+                component[REFLECT_MANAGER] = this;
+            }
+            const { onTick } = component;
+            if (onTick) {
+                this.profiler(() => onTick.call(component, this, Optional.some(en)), component);
+                // onTick.call(component, this, Optional.some(en))
+            }
+        }
+        for (const afterTick of this.#nextTicks) {
+            this.profiler(() => afterTick.call(null, Optional.some(en)));
+            // afterTick.call(null, Optional.some(en))
+        }
+        this.#nextTicks.length = 0;
+    }
+    update(ctor, fn) {
+        const component = this.#components.get(ctor);
+        if (component) {
+            fn(component);
+            return true;
+        }
+        return false;
+    }
+    profiler(fn, component, name) {
+        if (!ComponentManager.profilerEnable) {
+            return fn();
+        }
+        const conponentName = component ? Object.getPrototypeOf(component).constructor.name : '';
+        const profileName = name ? name
+            : conponentName ? (`${conponentName}.${fn.name}`)
+                : fn.name;
+        const now = performance.now();
+        const val = fn();
+        console.log(`[Profiler] ${profileName} took ${performance.now() - now}ms`);
+        return val;
+    }
+}
+const REQUIRED_COMPONENTS = Symbol('REQUIRED_COMPONENTS');
+export function RequireComponents(...params) {
+    return class CRequiredComponent extends BaseComponent {
+        [REQUIRED_COMPONENTS] = new Map();
+        constructor() {
+            super();
+            for (const param of params) {
+                if (Array.isArray(param)) {
+                    const [Ctor, ...args] = param;
+                    this[REQUIRED_COMPONENTS].set(Ctor, Reflect.construct(Ctor, args));
+                    continue;
+                }
+                this[REQUIRED_COMPONENTS].set(param, Reflect.construct(param, []));
+            }
+        }
+        getComponent(ctor) {
+            return this[REQUIRED_COMPONENTS].get(ctor);
+        }
+    };
+}
+export var oc;
+(function (oc) {
+    const table = new Map();
+    function addEntity(entityId) {
+        const manager = new ComponentManager();
+        table.set(entityId, manager);
+        return manager;
+    }
+    oc.addEntity = addEntity;
+    function removeEntity(entityId) {
+        const uid = entityId;
+        const manager = table.get(uid);
+        manager?.clear();
+        table.delete(uid);
+    }
+    oc.removeEntity = removeEntity;
+    function getManager(entityId) {
+        return table.get(entityId) ?? addEntity(entityId);
+    }
+    oc.getManager = getManager;
+    function tick() {
+        for (const [id, manager] of table.entries()) {
+            const entity = world.getEntity(id);
+            if (entity) {
+                manager.handleTicks(entity);
+            }
+        }
+    }
+    oc.tick = tick;
+    function start() {
+        system.runInterval(tick);
+    }
+    oc.start = start;
+    function toPlayer(entity) {
+        return Optional.some(world.getAllPlayers().find(p => p.id === entity.id));
+    }
+    oc.toPlayer = toPlayer;
+})(oc || (oc = {}));