@block_factory/lib 0.0.2 → 0.0.3

package/util/System.ts

@@ -0,0 +1,21 @@
+export namespace System {
+    export const ProxyConstructor = ((_instance: any, source: any) => {
+        return new Proxy(_instance, {
+            get: (target, prop) => {
+                if (prop in target) return (target as any)[prop];
+                const v = (source as any)[prop];
+                return typeof v === "function" ? v.bind(source) : v;
+            },
+
+            set: (target, prop, value) => {
+                if (prop in target) { (target as any)[prop] = value; return true; }
+                (source as any)[prop] = value;
+                return true;
+            },
+
+            has: (target, prop) => prop in target || prop in source,
+            ownKeys: () => [...Reflect.ownKeys(source), ...Reflect.ownKeys(_instance)],
+            getOwnPropertyDescriptor: (_t, prop) => Object.getOwnPropertyDescriptor((prop in _instance ? _instance : source) as any, prop)
+        }) as any;
+    })
+}

package/util/Wrapper/Container.d.ts

@@ -0,0 +1,9 @@
+import { Container } from "@minecraft/server";
+export type Inventory = ContainerWrapper & Container;
+export declare class ContainerWrapper {
+    readonly source: Container;
+    private constructor();
+    static wrap(source: Container): Inventory;
+    reduce(slot: number, amount?: number): void;
+}
+//# sourceMappingURL=Container.d.ts.map

package/util/Wrapper/Container.ts

@@ -0,0 +1,34 @@
+import { Container, ItemStack} from "@minecraft/server";
+import { System } from "../System";
+
+export type Inventory = ContainerWrapper & Container;
+
+export class ContainerWrapper {
+   public readonly source: Container;
+
+    private constructor(source: Container) {
+        this.source = source;
+        return System.ProxyConstructor(this, source);
+    }
+
+    public static wrap(source: Container): Inventory {
+        return new ContainerWrapper(source) as Inventory;
+    }
+
+    //======================== Interal ========================
+    public reduce(slot: number, amount: number = 1) {
+        let itemStack: ItemStack | undefined = this.source.getItem(slot);
+        let currentAmount: number = itemStack?.amount || 0;
+        currentAmount -= amount;
+        
+        if (itemStack != undefined && currentAmount > 0) {
+            const newItemStack: ItemStack = itemStack;
+            newItemStack.amount = currentAmount;
+            itemStack = newItemStack
+
+        } else itemStack = undefined;
+
+        this.source.setItem(slot, itemStack);
+    }
+
+}

package/util/Wrapper/IEntity.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from "@minecraft/server";
+import { Inventory } from "./Container";
+export type IEntity = IEntityWrapper & Entity;
+export declare class IEntityWrapper {
+    readonly source: Entity;
+    private constructor();
+    static wrap(source: Entity): IEntity;
+    isAlive: boolean;
+    get inventory(): Inventory;
+    test(): void;
+}
+//# sourceMappingURL=IEntity.d.ts.map

package/util/Wrapper/IEntity.ts

@@ -0,0 +1,34 @@
+import { Entity, EntityInventoryComponent } from "@minecraft/server";
+import { ContainerWrapper, Inventory } from "./Container";
+import { System } from "../System";
+
+export type IEntity = IEntityWrapper & Entity;
+
+export class IEntityWrapper {
+    public readonly source: Entity;
+
+    private constructor(source: Entity) {
+        this.source = source;
+        return System.ProxyConstructor(this, source);
+    }
+
+    public static wrap(source: Entity): IEntity {
+        return new IEntityWrapper(source) as IEntity;
+    }
+
+    //======================== Interal ========================
+    public isAlive: boolean = false;
+
+    public get inventory(): Inventory {
+        const i = this.source.getComponent(
+            EntityInventoryComponent.componentId
+        ) as EntityInventoryComponent;
+
+        return ContainerWrapper.wrap(i.container);
+    }
+
+    public test(): void {
+        //this.source.sendMessage(`${this.source.name} was tested`);
+    }
+
+}

package/util/Wrapper/IPlayer.d.ts

@@ -0,0 +1,12 @@
+import { Player } from "@minecraft/server";
+import { Inventory } from "./Container";
+export type IPlayer = IPlayerWrapper & Player;
+export declare class IPlayerWrapper {
+    readonly source: Player;
+    private constructor();
+    static wrap(player: Player): IPlayer;
+    isAlive: boolean;
+    get inventory(): Inventory;
+    test(): void;
+}
+//# sourceMappingURL=IPlayer.d.ts.map

package/util/Wrapper/IPlayer.ts

@@ -0,0 +1,34 @@
+import { EntityInventoryComponent, Player } from "@minecraft/server";
+import { ContainerWrapper, Inventory } from "./Container";
+import { System } from "../System";
+
+export type IPlayer = IPlayerWrapper & Player;
+
+export class IPlayerWrapper {
+    public readonly source: Player;
+
+    private constructor(source: Player) {
+        this.source = source;
+        return System.ProxyConstructor(this, source);
+    }
+
+    public static wrap(player: Player): IPlayer {
+        return new IPlayerWrapper(player) as IPlayer;
+    }
+
+    //======================== Interal ========================
+    public isAlive: boolean = false;
+
+    public get inventory(): Inventory {
+        const i = this.source.getComponent(
+            EntityInventoryComponent.componentId
+        ) as EntityInventoryComponent;
+
+        return ContainerWrapper.wrap(i.container);
+    }
+
+    public test(): void {
+        this.source.sendMessage(`${this.source.name} was tested`);
+    }
+
+}

package/util/Form.d.ts

@@ -1,10 +0,0 @@
-import { Player, RawMessage } from "@minecraft/server";
-
-export declare abstract class Form {
-    private static readonly occupiedPlayers: Set<string>;
-    static returnText: RawMessage | string;
-
-    static isOccupied(player: Player): boolean;
-
-    protected setOccupied(player: Player, occupied: boolean): void;
-}

package/util/Form.ts

@@ -1,15 +0,0 @@
-import { Player, RawMessage } from "@minecraft/server";
-
-export abstract class Form {
-    private static readonly occupiedPlayers: Set<string> = new Set();
-    public static returnText: RawMessage | string = "Back";
-
-    public static isOccupied(player: Player): boolean {
-        return Form.occupiedPlayers.has(player.id);
-    }
-
-    protected setOccupied(player: Player, occupied: boolean): void {
-        if (occupied) Form.occupiedPlayers.add(player.id);
-        else Form.occupiedPlayers.delete(player.id);
-    }
-}

package/util/_Form.ts

@@ -1,246 +0,0 @@
-/*  
-**************************************************
- Copyright (c) Block Factory - All rights reserved.
-**************************************************
- Author: Donthedev <https://github.com/voxeldon> 
-**************************************************
-*/
-import { Player, RawMessage } from "@minecraft/server";
-import { ActionFormData, ActionFormResponse, ModalFormData, ModalFormDataDropdownOptions, ModalFormDataSliderOptions, ModalFormDataTextFieldOptions, ModalFormDataToggleOptions, ModalFormResponse } from "@minecraft/server-ui";
-
-const occupiedPlayers: Set<string> = new Set();
-
-class Form {
-    public readonly isOccupied = ((player: Player): boolean => {
-        return occupiedPlayers.has(player.id);
-    })
-}
-
-export interface Button {
-    indexId: string | number;
-    text: string | RawMessage;
-    iconPath?: string;
-}
-
-export interface FormActionData {
-    response: ActionFormResponse;
-    indexId?: string | number;
-}
-
-export class ActionForm extends Form {
-    private readonly actionForm: ActionFormData = new ActionFormData();
-    private buttonMap: Map<number, string | number> = new Map<number, string | number>();
-    private buttons: Button[] = [];
-    private titleText: string | RawMessage | undefined;
-    private bodyText: string | RawMessage | undefined;
-
-    public title(title: string | RawMessage): void {
-        this.titleText = title;
-    }
-
-    public body(body: string | RawMessage): void {
-        this.bodyText = body;
-    }
-
-    public button(indexId: string, text: string | RawMessage, iconPath?: string): void {
-        this.buttons.push({ indexId, text, iconPath });
-    }
-
-    public async showForm(player: Player): Promise<FormActionData> {
-        if (this.titleText === undefined || this.bodyText === undefined) {
-            throw Error('Title and body must be set before showing the form');
-        }
-        this.actionForm.title(this.titleText);
-        this.actionForm.body(this.bodyText);
-        this.generateButtons();
-
-        occupiedPlayers.add(player.id);
-
-        const response: ActionFormResponse = await this.actionForm.show(player).finally(() => {
-            occupiedPlayers.delete(player.id);
-        });
-
-        const return_data: FormActionData = {
-            response: response,
-            indexId: undefined
-        };
-        if (response.selection !== undefined && response.selection !== null) {
-            const selection: string | number | undefined = this.buttonMap.get(response.selection);
-            return_data.indexId = selection;
-        }
-
-        return return_data;
-    }
-
-    private generateButtons() {
-        let buttonIndex: number = 0;
-        this.buttons.forEach(button => {
-            if (button.iconPath) {
-                this.actionForm.button(button.text, button.iconPath);
-            } else {
-                this.actionForm.button(button.text);
-            }
-            this.buttonMap.set(buttonIndex, button.indexId);
-            buttonIndex++;
-        });
-    }
-}
-
-enum WidgetType {
-    TextField = 'textField',
-    Dropdown = 'dropdown',
-    Slider = 'slider',
-    Toggle = 'toggle'
-}
-
-interface Widget {
-    typeId: string,
-    widget: any
-};
-
-export interface TextField {
-    indexId: string,
-    label: string | RawMessage,
-    placeholder: string | RawMessage,
-    defaultValue?: string
-}
-
-export interface Dropdown {
-    indexId: string,
-    label: string | RawMessage,
-    options: string[],
-    defaultValueIndex?: number
-}
-
-export interface Slider {
-    indexId: string,
-    label: string | RawMessage,
-    min: number,
-    max: number,
-    step: number,
-    defaultValue?: number
-}
-
-export interface Toggle {
-    indexId: string,
-    label: string | RawMessage,
-    defaultValue?: boolean
-}
-
-export type FormValue = string | boolean | number | undefined;
-
-export interface FormModalData {
-    response: ModalFormResponse;
-    indexMap?: Map<string, FormValue>;
-}
-
-export class ModalForm extends Form {
-    private readonly modalForm: ModalFormData = new ModalFormData();
-    private widgitMap: Map<number, string> = new Map<number, string>();
-    private indexMap: Map<string, FormValue> = new Map<string, FormValue>();
-    private widgets: Widget[] = [];
-
-    public title(title: string | RawMessage): void {
-        this.modalForm.title(title);
-    }
-
-    public label(label: string | RawMessage): void {
-        this.modalForm.label(label);
-    }
-
-    public header(header: string | RawMessage): void {
-        this.modalForm.header(header);
-    }
-
-    public divider(): void {
-        this.modalForm.divider();
-    }
-
-    public textField(indexId: string, label: string | RawMessage, placeholder: string | RawMessage, defaultValue?: string): void {
-        this.widgets.push({ typeId: WidgetType.TextField, widget: { indexId, label, placeholder, defaultValue } });
-    }
-    public dropdown(indexId: string, label: string | RawMessage, options: string[], defaultValueIndex?: number): void {
-        this.widgets.push({ typeId: WidgetType.Dropdown, widget: { indexId, label, options, defaultValueIndex } });
-    }
-
-    public slider(indexId: string, label: string | RawMessage, min: number, max: number, step: number, defaultValue?: number): void {
-        this.widgets.push({ typeId: WidgetType.Slider, widget: { indexId, label, min, max, step, defaultValue } });
-    }
-
-    public toggle(indexId: string, label: string | RawMessage, defaultValue?: boolean): void {
-        this.widgets.push({ typeId: WidgetType.Toggle, widget: { indexId, label, defaultValue } });
-    }
-
-    public async showForm(player: Player): Promise<FormModalData> {
-        this.processWidgets();
-        occupiedPlayers.add(player.id);
-
-        const response: ModalFormResponse = await this.modalForm.show(player).finally(() => {
-            occupiedPlayers.delete(player.id);
-        });
-
-        const return_data: FormModalData = {
-            response: response,
-            indexMap: undefined
-        }
-
-        if (response.formValues !== null && response.formValues !== undefined) {
-            this.processValues(response.formValues);
-            return_data.indexMap = this.indexMap;
-        }
-
-        return return_data;
-    }
-
-    private processWidgets(): void {
-        let widgitIndex: number = 0;
-
-        for (const widget of this.widgets) {
-            if (widget.typeId === WidgetType.TextField) {
-                const textField: TextField = widget.widget;
-                const options: ModalFormDataTextFieldOptions = {
-                    defaultValue: textField?.defaultValue
-                };
-                this.modalForm.textField(textField.label, textField.placeholder, options);
-                this.widgitMap.set(widgitIndex, textField.indexId);
-            }
-            else if (widget.typeId === WidgetType.Dropdown) {
-                const dropdown: Dropdown = widget.widget;
-                const options: ModalFormDataDropdownOptions = {
-                    defaultValueIndex: dropdown?.defaultValueIndex
-                };
-                this.modalForm.dropdown(dropdown.label, dropdown.options, options);
-                this.widgitMap.set(widgitIndex, dropdown.indexId);
-
-            }
-            else if (widget.typeId === WidgetType.Slider) {
-                const slider: Slider = widget.widget;
-                const options: ModalFormDataSliderOptions = {
-                    defaultValue: slider?.defaultValue,
-                    valueStep: slider.step
-                };
-                this.modalForm.slider(slider.label, slider.min, slider.max, options);
-                this.widgitMap.set(widgitIndex, slider.indexId);
-            }
-            else if (widget.typeId === WidgetType.Toggle) {
-                const toggle: Toggle = widget.widget;
-                const options: ModalFormDataToggleOptions = {
-                    defaultValue: toggle?.defaultValue
-                }
-                this.modalForm.toggle(toggle.label, options);
-                this.widgitMap.set(widgitIndex, toggle.indexId);
-            }
-            widgitIndex += 1;
-        }
-    }
-
-    private processValues(formValues: FormValue[]): void {
-        let widgitIndex: number = 0;
-        for (const i of formValues) {
-            const value: FormValue = i?.valueOf();
-            const indexId: string | undefined = this.widgitMap.get(widgitIndex);
-            if (indexId) this.indexMap.set(indexId, value);
-            widgitIndex++;
-        }
-    }
-}