omegga 0.1.85 → 1.0.2

package/dist/omegga/matchers/mapChange.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const map_1 = require("../../util/map");
+const mapChange = omegga => {
+    // LogLoad: Took 0.396473 seconds to LoadMap(/Game/Maps/Plate/Plate)
+    const mapChangeRegExp = /^Took .+ seconds to LoadMap\((?<map>.+)\)$/;
+    return {
+        // listen for commands messages
+        pattern(_line, logMatch) {
+            // line is not generic console log
+            if (!logMatch)
+                return;
+            const { generator, data } = logMatch.groups;
+            // check if log is a world log
+            if (generator !== 'LogLoad')
+                return;
+            // match the log to the map change finish pattern
+            const matchChange = data.match(mapChangeRegExp);
+            if (matchChange && matchChange.groups && matchChange.groups.map) {
+                return (0, map_1.brn2n)(matchChange.groups.map);
+            }
+            return null;
+        },
+        // when there's a match, emit the comand event
+        callback(map) {
+            // if the only argument is an empty string, ignore it
+            if (map) {
+                // dont emit on startup or when there is no current map
+                if (omegga.started && omegga.currentMap)
+                    omegga.emit('mapchange', { map });
+                // set omegga's current map
+                omegga.currentMap = map;
+            }
+        },
+    };
+};
+exports.default = mapChange;
+//# sourceMappingURL=mapChange.js.map

package/dist/omegga/matchers/mapChange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapChange.js","sourceRoot":"","sources":["../../../src/omegga/matchers/mapChange.ts"],"names":[],"mappings":";;AAAA,wCAAkC;AAGlC,MAAM,SAAS,GAA2B,MAAM,CAAC,EAAE;IACjD,oEAAoE;IACpE,MAAM,eAAe,GAAG,4CAA4C,CAAC;IAErE,OAAO;QACL,+BAA+B;QAC/B,OAAO,CAAC,KAAK,EAAE,QAAQ;YACrB,kCAAkC;YAClC,IAAI,CAAC,QAAQ;gBAAE,OAAO;YAEtB,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC5C,8BAA8B;YAC9B,IAAI,SAAS,KAAK,SAAS;gBAAE,OAAO;YAEpC,iDAAiD;YACjD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAChD,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,IAAI,WAAW,CAAC,MAAM,CAAC,GAAG,EAAE;gBAC/D,OAAO,IAAA,WAAK,EAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;aACtC;YAED,OAAO,IAAI,CAAC;QACd,CAAC;QACD,8CAA8C;QAC9C,QAAQ,CAAC,GAAG;YACV,qDAAqD;YACrD,IAAI,GAAG,EAAE;gBACP,uDAAuD;gBACvD,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,UAAU;oBACrC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;gBAEpC,2BAA2B;gBAC3B,MAAM,CAAC,UAAU,GAAG,GAAG,CAAC;aACzB;QACH,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,kBAAe,SAAS,CAAC"}

package/dist/omegga/matchers/types.d.ts

@@ -0,0 +1,5 @@
+import type Omegga from "../server";
+export declare type MatchGenerator<T> = (omegga: Omegga) => {
+    pattern(line: string, logMatch: RegExpMatchArray): T;
+    callback(match: T): void;
+};

package/dist/omegga/matchers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/omegga/matchers/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,kBAAuB;AACzC,oBAAY,cAAc,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,KAAK;IAClD,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,CAAC,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAC1B,CAAC"}

package/dist/omegga/matchers/types.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = __importDefault(require("../server"));
+//# sourceMappingURL=types.js.map

package/dist/omegga/matchers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/omegga/matchers/types.ts"],"names":[],"mappings":";;;;;AAAA,uDAAyC"}

package/dist/omegga/matchers/version.d.ts

@@ -0,0 +1,3 @@
+import { MatchGenerator } from './types';
+declare const version: MatchGenerator<number>;
+export default version;

package/dist/omegga/matchers/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/omegga/matchers/version.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,QAAA,MAAM,OAAO,EAAE,cAAc,CAAC,MAAM,CA2CnC,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/omegga/matchers/version.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const softconfig_1 = __importDefault(require("../../softconfig"));
+const version = omegga => {
+    const versionRegExp = /^Using libcurl (?<curlversion>.+)$/;
+    let version;
+    return {
+        pattern(_line, logMatch) {
+            var _a, _b;
+            // if the version has already been found - ignore this matcher
+            if (version || !logMatch)
+                return;
+            const { generator, data } = logMatch.groups;
+            // check if log is a command log
+            if (generator !== 'LogInit')
+                return;
+            const match = data.match(versionRegExp);
+            const branch = (_b = (_a = omegga.config.server) === null || _a === void 0 ? void 0 : _a.branch) !== null && _b !== void 0 ? _b : 'main-server';
+            const configPath = path_1.default.join(softconfig_1.default.BRICKADIA_INSTALLS, branch.split(':')[0] + '.json');
+            // base game version on curl version
+            if (match) {
+                try {
+                    version = Number(JSON.parse(fs_1.default.readFileSync(configPath).toString()).version.substring(2));
+                }
+                catch (e) {
+                    console.error('!>'.red, 'Unable to read branch config file: ', e);
+                    version = -1;
+                }
+                return version;
+            }
+        },
+        // when there's a match, emit the chat message event
+        callback(version) {
+            omegga.emit('version', version);
+            omegga.version = version;
+        },
+    };
+};
+exports.default = version;
+//# sourceMappingURL=version.js.map

package/dist/omegga/matchers/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../src/omegga/matchers/version.ts"],"names":[],"mappings":";;;;;AAAA,4CAAoB;AACpB,gDAAwB;AACxB,kEAAsC;AAGtC,MAAM,OAAO,GAA2B,MAAM,CAAC,EAAE;IAC/C,MAAM,aAAa,GAAG,oCAAoC,CAAC;IAC3D,IAAI,OAAe,CAAC;IAEpB,OAAO;QACL,OAAO,CAAC,KAAK,EAAE,QAAQ;;YACrB,8DAA8D;YAC9D,IAAI,OAAO,IAAI,CAAC,QAAQ;gBAAE,OAAO;YAEjC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC;YAE5C,gCAAgC;YAChC,IAAI,SAAS,KAAK,SAAS;gBAAE,OAAO;YAEpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YAExC,MAAM,MAAM,GAAG,MAAA,MAAA,MAAM,CAAC,MAAM,CAAC,MAAM,0CAAE,MAAM,mCAAI,aAAa,CAAC;YAC7D,MAAM,UAAU,GAAG,cAAI,CAAC,IAAI,CAC1B,oBAAU,CAAC,kBAAkB,EAC7B,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAC/B,CAAC;YAEF,oCAAoC;YACpC,IAAI,KAAK,EAAE;gBACT,IAAI;oBACF,OAAO,GAAG,MAAM,CACd,IAAI,CAAC,KAAK,CACR,YAAE,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE,CACvC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CACvB,CAAC;iBACH;gBAAC,OAAO,CAAC,EAAE;oBACV,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,qCAAqC,EAAE,CAAC,CAAC,CAAC;oBAClE,OAAO,GAAG,CAAC,CAAC,CAAC;iBACd;gBACD,OAAO,OAAO,CAAC;aAChB;QACH,CAAC;QACD,oDAAoD;QACpD,QAAQ,CAAC,OAAO;YACd,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YAChC,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;QAC3B,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF,kBAAe,OAAO,CAAC"}

package/dist/omegga/player.d.ts

@@ -0,0 +1,71 @@
+import { WriteSaveObject } from 'brs-js';
+import { IBrickBounds } from "../util/brick";
+import type { OmeggaPlayer, OmeggaLike } from "../plugin";
+declare class Player implements OmeggaPlayer {
+    #private;
+    name: string;
+    id: string;
+    controller: string;
+    state: string;
+    static getRoles(omegga: OmeggaLike, id: string): readonly string[];
+    static getPermissions(omegga: OmeggaLike, id: string): Record<string, boolean>;
+    static kill(omegga: OmeggaLike, target: string | OmeggaPlayer): void;
+    static damage(omegga: OmeggaLike, target: string | OmeggaPlayer, amount: number): void;
+    static heal(omegga: OmeggaLike, target: string | OmeggaPlayer, amount: number): void;
+    static giveItem(omegga: OmeggaLike, target: string | OmeggaPlayer, item: string): void;
+    static takeItem(omegga: OmeggaLike, target: string | OmeggaPlayer, item: string): void;
+    /**
+     * players are not to be constructed
+     * @constructor
+     * @param omegga Omegga Instance
+     * @param name Player Name
+     * @param id Player Id
+     * @param controller Player Controller
+     * @param state Player State
+     */
+    constructor(omegga: OmeggaLike, name: string, id: string, controller: string, state: string);
+    getOmegga(): OmeggaLike;
+    clone(): OmeggaPlayer;
+    raw(): [string, string, string, string];
+    isHost(): boolean;
+    clearBricks(quiet?: boolean): void;
+    getRoles(): readonly string[];
+    getPermissions(): Record<string, boolean>;
+    getNameColor(): string;
+    getPawn(): Promise<string>;
+    getPosition(): Promise<[number, number, number]>;
+    getGhostBrick(): Promise<{
+        targetGrid: string;
+        location: number[];
+        orientation: string;
+    }>;
+    getPaint(): Promise<{
+        materialIndex: string;
+        materialAlpha: string;
+        material: string;
+        color: number[];
+    }>;
+    isCrouched(pawn?: string): Promise<boolean>;
+    isDead(pawn?: string): Promise<boolean>;
+    getTemplateBounds(): Promise<IBrickBounds>;
+    getTemplateBoundsData(): Promise<import("brs-js").ReadSaveObject>;
+    loadBricks(saveName: string): void;
+    loadSaveData(saveData: WriteSaveObject, { offX, offY, offZ }?: {
+        offX?: number;
+        offY?: number;
+        offZ?: number;
+    }): Promise<void>;
+    loadDataAtGhostBrick(saveData: WriteSaveObject, { rotate, offX, offY, offZ, quiet }?: {
+        rotate?: boolean;
+        offX?: number;
+        offY?: number;
+        offZ?: number;
+        quiet?: boolean;
+    }): Promise<void>;
+    kill(): void;
+    damage(amount: number): void;
+    heal(amount: number): void;
+    giveItem(item: string): void;
+    takeItem(item: string): void;
+}
+export default Player;

package/dist/omegga/player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.d.ts","sourceRoot":"","sources":["../../src/omegga/player.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAS,KAAK,IAAI,UAAU,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAS,eAAe,EAAE,MAAM,QAAQ,CAAC;AAsChD,cAAM,MAAM;;IAEV,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;OAQG;gBAED,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM;IASf;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,KAAK,IAAI,MAAM;IAUf;;OAEG;IACH,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAIvC;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,WAAW,CAAC,KAAK,UAAQ;IAIzB;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE;IAK9D;;OAEG;IACH,QAAQ,IAAI,SAAS,MAAM,EAAE;IAI7B;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAuF1E;;;OAGG;IACH,cAAc;IAId;;;OAGG;IACH,YAAY;IAgCZ;;;OAGG;IACG,WAAW;IA+CjB;;;OAGG;IACG,aAAa;;;;;IA6CnB;;OAEG;IACG,QAAQ;;;;;;IAiEd;;;OAGG;IACG,iBAAiB;IAkEvB;;;OAGG;IACG,qBAAqB;IAyB3B;;;OAGG;IACG,oBAAoB,CACxB,QAAQ,EAAE,eAAe,EACzB,EAAE,MAAa,EAAE,IAAQ,EAAE,IAAQ,EAAE,IAAQ,EAAE,KAAY,EAAE;;;;;;KAAK;CAwCrE;AAID,eAAe,MAAM,CAAC"}

package/dist/omegga/player.js

@@ -0,0 +1,442 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Player_omegga;
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/");
+const DEFAULT_PERMS = {
+    moderator: [
+        'Bricks.ClearAll',
+        'Minigame.AlwaysLeave',
+        'Players.Kick',
+        'Players.TPInMinigame',
+        'Players.TPOthers',
+        'Self.Ghost',
+    ],
+    admin: [
+        'Bricks.ClearAll',
+        'Bricks.ClearOwn',
+        'Bricks.IgnoreTrust',
+        'Bricks.Load',
+        'Map.Environment',
+        'Minigame.AlwaysEdit',
+        'Minigame.AlwaysLeave',
+        'Minigame.AlwaysSwitchTeam',
+        'Minigame.MakeDefault',
+        'Minigame.MakePersistent',
+        'Minigame.UseAllBricks',
+        'Players.Ban',
+        'Players.Kick',
+        'Players.TPInMinigame',
+        'Players.TPOthers',
+        'Roles.Grant',
+        'Self.Ghost',
+        'Server.ChangeRoles',
+        'Server.ChangeSettings',
+        'Server.FreezeCamera',
+        'Tools.Selector.BypassLimits',
+        'Tools.Selector.BypassTimeouts',
+    ],
+};
+class Player {
+    /**
+     * players are not to be constructed
+     * @constructor
+     * @param omegga Omegga Instance
+     * @param name Player Name
+     * @param id Player Id
+     * @param controller Player Controller
+     * @param state Player State
+     */
+    constructor(omegga, name, id, controller, state) {
+        _Player_omegga.set(this, void 0);
+        __classPrivateFieldSet(this, _Player_omegga, omegga, "f");
+        this.name = name;
+        this.id = id;
+        this.controller = controller;
+        this.state = state;
+    }
+    static getRoles(omegga, id) {
+        const data = omegga.getRoleAssignments().savedPlayerRoles[id];
+        return Object.freeze(data && data.roles ? data.roles : []);
+    }
+    static getPermissions(omegga, id) {
+        const { roles, defaultRole } = omegga.getRoleSetup();
+        // if the player is the host, the player has every permission
+        if (omegga.host.id === id) {
+            return Object.freeze(Object.fromEntries([].concat(defaultRole.permissions.map(p => [p.name, true]), 
+            // sometimes the default role does not have every permission listed
+            ...roles.map(r => r.permissions.map(p => [p.name, true])))));
+        }
+        // get the player's roles
+        const playerRoles = Player.getRoles(omegga, id).map(r => r.toLowerCase());
+        // default player permissions
+        const permissions = {
+            'Bricks.ClearAll': false,
+            'Bricks.ClearOwn': true,
+            'Bricks.Delete': true,
+            'Bricks.Edit': true,
+            'Bricks.IgnoreTrust': false,
+            'Bricks.Paint': true,
+            'Bricks.Place': true,
+            'BricksItems.Spawn': true,
+            'Map.Change': false,
+            'Map.Environment': false,
+            'Map.SetSpawn': false,
+            'Minigame.AlwaysEdit': false,
+            'Minigame.AlwaysLeave': false,
+            'Minigame.AlwaysSwitchTeam': false,
+            'Minigame.Create': true,
+            'Minigame.MakePersistent': false,
+            'Minigame.UseAllBricks': false,
+            'Players.Ban': false,
+            'Players.TPInMinigame': false,
+            'Players.TPOthers': false,
+            'Players.TPSelf': true,
+            'Roles.Grant': false,
+            'Self.Flashlight': true,
+            'Self.Fly': true,
+            'Self.FreezeCamera': false,
+            'Self.Ghost': false,
+            'Self.Sprint': true,
+            'Self.Suicide': true,
+            'Tools.Selector.Use': true,
+        };
+        // apply all permissions from default role
+        for (const p of defaultRole.permissions) {
+            // technically this can never be Unchanged so it's always on enabled or allowed
+            permissions[p.name] =
+                p.state === 'Unchanged' ? permissions[p.name] : p.state === 'Allowed';
+        }
+        // loop through all the roles
+        for (const role of roles) {
+            // ignore ones the player does not have
+            if (!playerRoles.includes(role.name.toLowerCase()))
+                continue;
+            const defaultPerms = DEFAULT_PERMS[role.name.toLowerCase()] || [];
+            // iterate through default permissions
+            for (const perm of defaultPerms) {
+                // if they are not overriden, set it to true
+                if (!role.permissions.find(r => r.name === perm))
+                    permissions[perm] = true;
+            }
+            // add all the new permissions the player now has
+            for (const p of role.permissions) {
+                // permission is disabled on forbidden, persisted on unchanged, and enabled on bEnabled or Allowed
+                permissions[p.name] =
+                    p.state !== 'Forbidden' &&
+                        (p.state === 'Unchanged'
+                            ? permissions[p.name]
+                            : permissions[p.name] || p.state === 'Allowed');
+                permissions[p.name] = permissions[p.name];
+            }
+        }
+        return Object.freeze(permissions);
+    }
+    static kill(omegga, target) {
+        if (typeof target === 'string')
+            target = omegga.getPlayer(target);
+        if (target === null || target === void 0 ? void 0 : target.name)
+            omegga.writeln(`Server.Players.Kill "${target === null || target === void 0 ? void 0 : target.name}"`);
+    }
+    static damage(omegga, target, amount) {
+        if (typeof target === 'string')
+            target = omegga.getPlayer(target);
+        if (amount === 0)
+            return;
+        if (target === null || target === void 0 ? void 0 : target.name)
+            omegga.writeln(`Server.Players.Damage "${target === null || target === void 0 ? void 0 : target.name}" ${amount}`);
+    }
+    static heal(omegga, target, amount) {
+        if (amount === 0)
+            return;
+        Player.damage(omegga, target, -amount);
+    }
+    static giveItem(omegga, target, item) {
+        if (typeof target === 'string')
+            target = omegga.getPlayer(target);
+        if (!item)
+            return;
+        if (target === null || target === void 0 ? void 0 : target.name)
+            omegga.writeln(`Server.Players.GiveItem "${target === null || target === void 0 ? void 0 : target.name}" ${item}`);
+    }
+    static takeItem(omegga, target, item) {
+        if (typeof target === 'string')
+            target = omegga.getPlayer(target);
+        if (!item)
+            return;
+        if (target === null || target === void 0 ? void 0 : target.name)
+            omegga.writeln(`Server.Players.RemoveItem "${target === null || target === void 0 ? void 0 : target.name}" ${item}`);
+    }
+    getOmegga() {
+        return __classPrivateFieldGet(this, _Player_omegga, "f");
+    }
+    clone() {
+        return new Player(__classPrivateFieldGet(this, _Player_omegga, "f"), this.name, this.id, this.controller, this.state);
+    }
+    raw() {
+        return [this.name, this.id, this.controller, this.state];
+    }
+    isHost() {
+        return __classPrivateFieldGet(this, _Player_omegga, "f").host.id === this.id;
+    }
+    clearBricks(quiet = false) {
+        __classPrivateFieldGet(this, _Player_omegga, "f").clearBricks(this.id, quiet);
+    }
+    getRoles() {
+        return Player.getRoles(__classPrivateFieldGet(this, _Player_omegga, "f"), this.id);
+    }
+    getPermissions() {
+        return Player.getPermissions(__classPrivateFieldGet(this, _Player_omegga, "f"), this.id);
+    }
+    getNameColor() {
+        const { roles, defaultRole, ownerRoleColor, bOwnerRoleHasColor } = __classPrivateFieldGet(this, _Player_omegga, "f").getRoleSetup();
+        // host check if host has host color
+        if (this.isHost() && bOwnerRoleHasColor)
+            return util_1.color.rgbToHex(ownerRoleColor);
+        // get the player's role
+        const playerRoles = this.getRoles().map(r => r.toLowerCase());
+        // only if the player actually has roles...
+        if (playerRoles.length > 0) {
+            // check the role list in reverse for the player's role (highest tier first)
+            const found = roles
+                .slice()
+                .reverse()
+                .find(role => role.bHasColor && playerRoles.includes(role.name.toLowerCase()));
+            if (found)
+                return util_1.color.rgbToHex(found.color);
+        }
+        return util_1.color.rgbToHex(defaultRole.bHasColor
+            ? defaultRole.color
+            : { r: 255, g: 255, b: 255, a: 255 });
+    }
+    async getPawn() {
+        // given a player controller, match the player's pawn
+        const pawnRegExp = new RegExp(`^(?<index>\\d+)\\) BP_PlayerController_C .+?PersistentLevel\\.${this.controller}\\.Pawn = BP_FigureV2_C'.+?:PersistentLevel.(?<pawn>BP_FigureV2_C_\\d+)'`);
+        // wait for the pawn watcher to return a pawn
+        const [{ groups: { pawn }, },] = await __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_PlayerController_C Pawn Name=' + this.controller, pawnRegExp, { first: 'index', timeoutDelay: 500 });
+        return pawn;
+    }
+    async getPosition() {
+        // this is here because my text editor had weird syntax highlighting glitches when the other omeggas were replaced with this.#omegga...
+        // guess the code is "too new" :egg:
+        const omegga = __classPrivateFieldGet(this, _Player_omegga, "f");
+        // given a player controller, match the player's pawn
+        const pawnRegExp = new RegExp(`BP_PlayerController_C .+?PersistentLevel\\.${this.controller}\\.Pawn = BP_FigureV2_C'.+?:PersistentLevel.(?<pawn>BP_FigureV2_C_\\d+)'`);
+        // wait for the pawn watcher to return a pawn
+        const [{ groups: { pawn }, },] = await omegga.addWatcher(pawnRegExp, {
+            // request the pawn for this player's controller (should only be one)
+            exec: () => omegga.writeln(`GetAll BP_PlayerController_C Pawn Name=${this.controller}`),
+            timeoutDelay: 100,
+        });
+        // given a player's pawn, match the player's position
+        const posRegExp = new RegExp(`CapsuleComponent .+?PersistentLevel\\.${pawn}\\.CollisionCylinder\\.RelativeLocation = \\(X=(?<x>[\\d\\.-]+),Y=(?<y>[\\d\\.-]+),Z=(?<z>[\\d\\.-]+)\\)`);
+        // wait for the position promise
+        const [{ groups: { x, y, z }, },] = await omegga.addWatcher(posRegExp, {
+            // request the position for this player's pawn
+            exec: () => omegga.writeln(`GetAll SceneComponent RelativeLocation Name=CollisionCylinder Outer=${pawn}`),
+            timeoutDelay: 100,
+        });
+        // return the player's position as an array of numbers
+        return [Number(x), Number(y), Number(z)];
+    }
+    async getGhostBrick() {
+        const { controller } = this;
+        const ownerRegExp = /^(?<index>\d+)\) BrickGridPreviewActor (.+):PersistentLevel\.(?<actor>BrickGridPreviewActor_\d+)\.Owner = BP_PlayerController_C'(.+):PersistentLevel\.(?<controller>BP_PlayerController_C_\d+)'$/;
+        const transformParamsRegExp = /^(?<index>\d+)\) BrickGridPreviewActor (.+):PersistentLevel\.(?<actor>BrickGridPreviewActor_\d+)\.TransformParameters = \(TargetGrid=("(?<targetGrid>.+)"|None),Position=\(X=(?<x>.+),Y=(?<y>.+),Z=(?<z>.+)\),Orientation=(?<orientation>.+)\)$/;
+        const [owners, transformParams] = await Promise.all([
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BrickGridPreviewActor Owner', ownerRegExp, { first: 'index', timeoutDelay: 500 }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BrickGridPreviewActor TransformParameters', transformParamsRegExp, { first: 'index', timeoutDelay: 500 }),
+        ]);
+        // get BrickGridPreviewActor by controller
+        const owner = owners.find(owner => owner.groups.controller === controller);
+        if (!owner)
+            return;
+        const actor = owner.groups.actor;
+        // get transform parameters for the found actor
+        const transformParameters = transformParams.find(transformParameters => transformParameters.groups.actor === actor);
+        if (!transformParameters)
+            return;
+        return {
+            targetGrid: transformParameters.groups.targetGrid,
+            location: [
+                +transformParameters.groups.x,
+                +transformParameters.groups.y,
+                +transformParameters.groups.z,
+            ],
+            orientation: transformParameters.groups.orientation,
+        };
+    }
+    async getPaint() {
+        const { controller } = this;
+        const ownerRegExp = /^(?<index>\d+)\) BP_Item_PaintTool_C (.+):PersistentLevel\.(?<actor>BP_Item_PaintTool_C_\d+)\.Owner = BP_PlayerController_C'(.+):PersistentLevel\.(?<controller>BP_PlayerController_C_\d+)'$/;
+        const colorRegExp = /^(?<index>\d+)\) BP_Item_PaintTool_C (.+):PersistentLevel\.(?<actor>BP_Item_PaintTool_C_\d+)\.SelectedColor = \(B=(?<b>.+),G=(?<g>.+),R=(?<r>.+),A=(?<a>.+)\)$/;
+        const materialRegExp = /^(?<index>\d+)\) BP_Item_PaintTool_C (.+):PersistentLevel\.(?<actor>BP_Item_PaintTool_C_\d+)\.SelectedMaterialId = (?<materialIndex>\d+)$/;
+        const materialAlphaRegExp = /^(?<index>\d+)\) BP_Item_PaintTool_C (.+):PersistentLevel\.(?<actor>BP_Item_PaintTool_C_\d+)\.SelectedMaterialAlpha = (?<materialAlpha>\d+)$/;
+        const [owners, colorMatch, materialMatch, materialAlphaMatch] = await Promise.all([
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_Item_PaintTool_C Owner', ownerRegExp, { first: 'index', timeoutDelay: 500 }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_Item_PaintTool_C SelectedColor', colorRegExp, { first: 'index', timeoutDelay: 500 }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_Item_PaintTool_C SelectedMaterialId', materialRegExp, { first: 'index', timeoutDelay: 500 }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_Item_PaintTool_C SelectedMaterialAlpha', materialAlphaRegExp, { first: 'index', timeoutDelay: 500 }),
+        ]);
+        // get BrickGridPreviewActor by controller
+        const owner = owners.find(owner => owner.groups.controller === controller);
+        if (!owner)
+            return;
+        const actor = owner.groups.actor;
+        // get transform parameters for the found actor
+        const color = colorMatch.find(color => color.groups.actor === actor);
+        const material = materialMatch.find(material => material.groups.actor === actor);
+        const materialAlpha = materialAlphaMatch.find(materialAlpha => materialAlpha.groups.actor === actor);
+        if (!color || !material || !materialAlpha)
+            return;
+        const colorRaw = [+color.groups.r, +color.groups.g, +color.groups.b];
+        return {
+            materialIndex: material.groups.materialIndex,
+            materialAlpha: materialAlpha.groups.materialAlpha,
+            material: util_1.brick.BRICK_CONSTANTS.DEFAULT_MATERIALS[Number(material.groups.materialIndex)],
+            color: colorRaw,
+        };
+    }
+    async isCrouched(pawn) {
+        if (!pawn)
+            pawn = await this.getPawn();
+        const reg = /(?<index>\d+)\) BP_FigureV2_C .+?PersistentLevel\.(?<pawn>BP_FigureV2_C_\d+)\.bIsCrouched = (?<crouched>True|False)$/;
+        const resp = await __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_FigureV2_C bIsCrouched Name=' + pawn, reg, { first: 'index', timeoutDelay: 500 });
+        const me = resp.find(r => r.groups.pawn === pawn);
+        if (!me)
+            return false;
+        return me.groups.crouched == 'True';
+    }
+    async isDead(pawn) {
+        if (!pawn)
+            pawn = await this.getPawn();
+        const reg = /(?<index>\d+)\) BP_FigureV2_C .+?PersistentLevel\.(?<pawn>BP_FigureV2_C_\d+)\.bIsDead = (?<dead>True|False)$/;
+        const resp = await __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BP_FigureV2_C bIsDead Name=' + pawn, reg, { first: 'index', timeoutDelay: 500 });
+        const me = resp.find(r => r.groups.pawn === pawn);
+        if (!me)
+            return true;
+        return me.groups.dead == 'True';
+    }
+    async getTemplateBounds() {
+        const { controller } = this;
+        const brickTemplateRegExp = /^(?<index>\d+)\) BP_PlayerController_C (.+):PersistentLevel\.(?<controller>BP_PlayerController_C_\d+)\.TEMP_BrickTemplate_Server = BrickBuildingTemplate'(.+)Transient.(?<templateName>BrickBuildingTemplate_\d+)'$/;
+        const minBoundsRegExp = /^(?<index>\d+)\) BrickBuildingTemplate (.+)Transient\.(?<templateName>BrickBuildingTemplate_\d+)\.MinBounds = \(X=(?<x>.+),Y=(?<y>.+),Z=(?<z>.+)\)$/;
+        const maxBoundsRegExp = /^(?<index>\d+)\) BrickBuildingTemplate (.+)Transient\.(?<templateName>BrickBuildingTemplate_\d+)\.MaxBounds = \(X=(?<x>.+),Y=(?<y>.+),Z=(?<z>.+)\)$/;
+        const centerRegExp = /^(?<index>\d+)\) BrickBuildingTemplate (.+)Transient\.(?<templateName>BrickBuildingTemplate_\d+)\.Center = \(X=(?<x>.+),Y=(?<y>.+),Z=(?<z>.+)\)$/;
+        const [template, minBounds, maxBounds, centers] = await Promise.all([
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk(`GetAll BP_PlayerController_C TEMP_BrickTemplate_Server Name=${controller}`, brickTemplateRegExp, { first: 'index' }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BrickBuildingTemplate MinBounds', minBoundsRegExp, { first: 'index' }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BrickBuildingTemplate MaxBounds', maxBoundsRegExp, { first: 'index' }),
+            __classPrivateFieldGet(this, _Player_omegga, "f").watchLogChunk('GetAll BrickBuildingTemplate Center', centerRegExp, { first: 'index' }),
+        ]);
+        if (!template.length ||
+            !minBounds.length ||
+            !maxBounds.length ||
+            !centers.length)
+            return;
+        // get template name
+        const templateName = template[0].groups.templateName;
+        // find all values with matching template name
+        const minBound = minBounds.find(minBound => minBound.groups.templateName === templateName);
+        const maxBound = maxBounds.find(maxBound => maxBound.groups.templateName === templateName);
+        const center = centers.find(center => center.groups.templateName === templateName);
+        if (!minBound || !maxBound || !center)
+            return;
+        return {
+            minBound: [+minBound.groups.x, +minBound.groups.y, +minBound.groups.z],
+            maxBound: [+maxBound.groups.x, +maxBound.groups.y, +maxBound.groups.z],
+            center: [+center.groups.x, +center.groups.y, +center.groups.z],
+        };
+    }
+    async getTemplateBoundsData() {
+        const templateBounds = await this.getTemplateBounds();
+        if (!templateBounds)
+            return;
+        const saveData = await __classPrivateFieldGet(this, _Player_omegga, "f").getSaveData({
+            center: templateBounds.center,
+            extent: [
+                (templateBounds.maxBound[0] - templateBounds.minBound[0]) / 2,
+                (templateBounds.maxBound[1] - templateBounds.minBound[1]) / 2,
+                (templateBounds.maxBound[2] - templateBounds.minBound[2]) / 2,
+            ],
+        });
+        if (!saveData)
+            return;
+        // filter bricks outside the bounds
+        // no longer necessary thanks to Bricks.SaveRegion
+        /* saveData.bricks = (saveData.bricks as Brick[]).filter(brick => {
+          return brickUtils.checkBounds(
+            brick,
+            saveData.brick_assets,
+            templateBounds
+          );
+        }) as typeof saveData.bricks; */
+        if (saveData.bricks.length > 0) {
+            return saveData;
+        }
+        return undefined;
+    }
+    loadBricks(saveName) {
+        __classPrivateFieldGet(this, _Player_omegga, "f").loadBricksOnPlayer(saveName, this);
+    }
+    async loadSaveData(saveData, { offX = 0, offY = 0, offZ = 0 } = {}) {
+        await __classPrivateFieldGet(this, _Player_omegga, "f").loadSaveDataOnPlayer(saveData, this, {
+            offX,
+            offY,
+            offZ,
+        });
+    }
+    async loadDataAtGhostBrick(saveData, { rotate = true, offX = 0, offY = 0, offZ = 0, quiet = true } = {}) {
+        const ghostBrickData = await this.getGhostBrick();
+        if (!ghostBrickData || !saveData)
+            return;
+        // get bounds of the bricks
+        const bounds = util_1.brick.getBounds(saveData);
+        if (rotate) {
+            const orientation = util_1.brick.BRICK_CONSTANTS.orientationMap[ghostBrickData.orientation];
+            saveData.bricks = saveData.bricks.map(brick => util_1.brick.rotate(brick, orientation));
+            // rotate bounds, if we dont use the original bounds they are off by 1 sometimes >:(
+            bounds.minBound = util_1.brick.BRICK_CONSTANTS.translationTable[util_1.brick.d2o(...orientation)](bounds.minBound);
+            bounds.maxBound = util_1.brick.BRICK_CONSTANTS.translationTable[util_1.brick.d2o(...orientation)](bounds.maxBound);
+            bounds.center = util_1.brick.BRICK_CONSTANTS.translationTable[util_1.brick.d2o(...orientation)](bounds.center);
+        }
+        // calculate offset from bricks center to ghost brick center
+        const offset = bounds.center.map((center, index) => ghostBrickData.location[index] - center);
+        // load at offset location
+        await __classPrivateFieldGet(this, _Player_omegga, "f").loadSaveData(saveData, {
+            offX: offX + offset[0],
+            offY: offY + offset[1],
+            offZ: offZ + offset[2],
+            quiet,
+        });
+    }
+    kill() {
+        Player.kill(__classPrivateFieldGet(this, _Player_omegga, "f"), this);
+    }
+    damage(amount) {
+        Player.damage(__classPrivateFieldGet(this, _Player_omegga, "f"), this, amount);
+    }
+    heal(amount) {
+        Player.heal(__classPrivateFieldGet(this, _Player_omegga, "f"), this, amount);
+    }
+    giveItem(item) {
+        Player.giveItem(__classPrivateFieldGet(this, _Player_omegga, "f"), this, item);
+    }
+    takeItem(item) {
+        Player.takeItem(__classPrivateFieldGet(this, _Player_omegga, "f"), this, item);
+    }
+}
+_Player_omegga = new WeakMap();
+global.Player = Player;
+exports.default = Player;
+//# sourceMappingURL=player.js.map