Add files via upload

Author: Lapis256

src/axisAlignedBB.js

@@ -0,0 +1,3 @@
+export class AxisAlignedBB {
+     // TODO
+}

src/entity.js

@@ -0,0 +1,3 @@
+export class Entity {
+    // TODO
+}

src/errors.js

@@ -0,0 +1,25 @@
+class Error {
+    name = "Error";
+    constructor(message) {
+        this.message = message;
+    }
+    toString() {
+        return this.message;
+    }
+}
+
+export class EventNotDefined extends Error {
+    name = "EventNotDefined";
+    constructor(eventName) {
+        super(`${eventName} event is not defined.`);
+    }
+}
+
+export class CommandExecutionError extends Error {
+    name = "CommandExecutionError";
+    constructor(command, { statusMessage, statusCode }) {
+        super(statusMessage);
+        this.code = statusCode;
+        this.command = command;
+    }
+}

src/event.js

@@ -0,0 +1,31 @@
+import { World } from "Minecraft";
+import { EventNotDefined } from "./errors.js";
+import { print } from "./utils.js";
+
+
+export const Event = new (class {
+    on(eventName, callback) {
+        const event = World.events[eventName];
+        if(!event) {
+            throw new EventNotDefined(eventName);
+        }
+        const newCallback = eventData => {
+            try {
+                callback(eventData);
+            }
+            catch(e) {
+                print("Event Running Error: " + e);
+            }
+        }
+        event.subscribe(newCallback);
+        return newCallback;
+    }
+
+    off(eventName, callback) {
+        const event = World.events[eventName];
+        if(!event) {
+            throw new EventNotDefined(eventName);
+        }
+        event.unsubscribe(callback);
+    }
+})();

src/gamerule.js

@@ -0,0 +1,49 @@
+import { Commands } from "Minecraft";
+import { Command } from "./command.js";
+import { print } from "./utils.js";
+
+
+export const GameRule = new (class {
+    #gameruleValueConverter(value) {
+        switch(value) {
+            case "true":
+                return true;
+            case "false":
+                return false;
+            default:
+                return Number(rawValue);
+        }
+    }    
+    
+    #gameruleParser(text) {
+        const [ key, rawValue ] = text.split(" = ");
+        return [ key, this.#gameruleValueConverter(rawValue) ];
+    }
+    
+    get(ruleName) {
+        try {
+            const { statusMessage } = Command.run("gamerule " + ruleName);
+            const [ _, value ] = this.#gameruleParser(statusMessage);
+            return value;
+        }
+        catch {
+            return;
+        }
+    }
+    
+    set(ruleName, value) {
+        try {
+            Command.run(`gamerule ${ruleName} ${value}`);
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+    
+    all() {
+        const { statusMessage } = Command.run("gamerule");
+        const gamerules = statusMessage.split(", ").map(this.#gameruleParser);
+        return Object.fromEntries(gamerules);
+    }
+})();

src/player.js

@@ -0,0 +1,42 @@
+import { World } from "Minecraft";
+import { Command } from "./command.js";
+import { Tag } from "./tag.js";
+
+
+export class Player {
+    #player;
+    #tagSelector;
+
+    constructor(player) {
+        this.#player = player;
+        this.#tagSelector = Command.selectorBuilder(player.name);
+        
+        for(const attr in player) {
+            this[attr] = player[attr];
+        }
+    }
+
+    static getAll() {
+        return World.getPlayers().map(Player.get);
+    }
+
+    getAllTags() {
+        return Tag.getAllTags(this.#tagSelector);
+    }
+
+    hasTag(tag) {
+        return Tag.hasTag(this.#tagSelector, tag);
+    }
+
+    addTag(tag) {
+        return Tag.addTag(this.#tagSelector, tag);
+    }
+
+    removeAllTags() {
+        return Tag.removeAllTags(this.#tagSelector);
+    }
+
+    removeTag(tag) {
+        return Tag.removeTag(this.#tagSelector, tag);
+    }
+}

src/scoreboard.js

@@ -0,0 +1,25 @@
+import { Command } from "./command.js";
+
+
+export const Scoreboard = new (class {
+    #ListRegex = /-\s(?<name>.*?):\s/g;
+
+    addObjective(name, displayName) {
+        const _displayName = displayName ? displayName : name;
+        Command.runSafe(`scoreboard objectives add "${name}" dummy "${_displayName}"`);
+    }
+
+    getAllObjectives() {
+        try {
+            const { statusMessage } = Command.run(`scoreboard objectives list`);
+            return [...statusMessage.matchAll(this.#ListRegex)].map(m => m.groups.name);
+        }
+        catch {
+            return [];
+        }
+    }
+
+    isExistObjective(name) {
+        return getAllObjectives().includes(name);
+    }
+})();

src/tag.js

@@ -0,0 +1,43 @@
+import { Player, Entity } from "Minecraft";
+import { Command } from "./command.js";
+
+
+export const Tag = new (class {
+    #TagRegex = /§a(?<tag>.*?)§r(?:,\s|$)/g;
+
+    getAllTags(selector) {
+        const { statusMessage } = Command.run(`tag ${selector} list`);
+        return [...statusMessage.matchAll(this.#TagRegex)].map(m => m.groups.tag);
+    }
+
+    hasTag(selector, tag) {
+        return this.getAllTags(selector).includes(tag);
+    }
+
+    addTag(selector, tag) {
+        if(this.hasTag(selector, tag)) return false;
+        try {
+            Command.run(`tag ${selector} add "${tag}"`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+
+    removeAllTags(selector) {
+        this.getAllTags(selector).forEach(t => this.removeTag(selector, t));
+        return true;
+    }
+
+    removeTag(selector, tag) {
+        if(!this.hasTag(selector, tag)) return false;
+        try {
+            Command.run(`tag ${selector} remove "${tag}"`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+})();

src/tick.js

@@ -0,0 +1,72 @@
+import { Event } from "./event.js";
+import { print } from "./utils.js";
+
+
+class Interval {
+    totalTick = 1;
+    executed = false;
+    constructor(callback, interval, once) {
+        this.callback = callback;
+        this.interval = interval;
+        this.once = once;
+    }
+    isRemovable() {
+        return this.once && this.executed;
+    }
+    tick() {
+        if(this.totalTick++ % this.interval === 0) {
+            this.callback();
+            this.executed = true;
+        }
+    }
+}
+
+class IntervalHandler {
+    intervals = {};
+    intervalID = 0;
+    tick() {
+        for(const id in this.intervals) {
+            const interval = this.intervals[id];
+            interval.tick();
+            if(interval.isRemovable()) {
+                this.remove(id);
+            }
+        }
+    }
+    add(interval) {
+        const id = this.intervalID++;
+        this.intervals[id] = interval;
+        return id;
+    }
+    remove(id) {
+        delete this.intervals[id];
+    }
+}
+
+export const Tick = new (class {
+    #intervalHandler = new IntervalHandler();
+
+    constructor() {
+        Event.on("tick", _ => this.#intervalHandler.tick());
+    }
+
+    setInterval(callback, interval) {
+        return intervalHandler.add(
+            new Interval(callback, interval, false)
+        );
+    }
+
+    clearInterval(id) {
+        intervalHandler.remove(id);
+    }
+
+    setTimeout(callback, timeout) {
+        return intervalHandler.add(
+            new Interval(callback, timeout, true)
+        );
+    }
+
+    clearTimeout(id) {
+        intervalHandler.remove(id);
+    }
+})();

src/utils.js

@@ -0,0 +1,17 @@
+import { Command } from "./command.js";
+
+
+export function print(text) {
+    // TODO
+
+    //Commands.run(`tellraw @a {"rawtext":[{"text":"${text}"}]}`);
+    // Commands.run(`say {"rawtext":[{"text":"${text}"}]}`);
+    //Commands.run(`tellraw @a {"rawtext":[{"text":"${escape(text)}"}]}`);
+    // const rawText = JSON.stringify({rawtext: [{text: text}]});
+    // commandRun("tellraw @a " + rawText);
+    Command.run(`say Debug: ${text}`);
+}
+
+export function pjson(json) {
+    print(JSON.stringify(json));
+}