multyx-client 0.1.0

package/dist/items/list.js

@@ -0,0 +1,250 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const object_1 = require("./object");
+class MultyxClientList extends object_1.default {
+    get value() {
+        const parsed = [];
+        for (let i = 0; i < this.length; i++)
+            parsed[i] = this.get(i).value;
+        return parsed;
+    }
+    constructor(multyx, list, propertyPath = [], editable) {
+        super(multyx, {}, propertyPath, editable);
+        this.toString = () => this.value.toString();
+        this.valueOf = () => this.value;
+        this[_a] = () => this.value;
+        this.length = 0;
+        this.push(...(list instanceof utils_1.EditWrapper ? list.value.map(x => new utils_1.EditWrapper(x)) : list));
+        return new Proxy(this, {
+            has: (o, p) => {
+                if (p in o)
+                    return true;
+                return o.has(p);
+            },
+            get: (o, p) => {
+                if (p in o)
+                    return o[p];
+                return o.get(p);
+            },
+            set: (o, p, v) => {
+                if (p in o) {
+                    o[p] = v;
+                    return true;
+                }
+                return o.set(p, v);
+            },
+            deleteProperty: (o, p) => {
+                return o.delete(p, false);
+            }
+        });
+    }
+    set(index, value) {
+        if (typeof index == 'string')
+            index = parseInt(index);
+        if (value === undefined)
+            return this.delete(index, false);
+        if (value instanceof utils_1.EditWrapper && value.value === undefined)
+            return this.delete(index, true);
+        const result = super.set(index, value);
+        if (result && index >= this.length)
+            this.length = index + 1;
+        return result;
+    }
+    delete(index, native = false) {
+        if (typeof index == 'string')
+            index = parseInt(index);
+        const res = super.delete(index, native);
+        if (res)
+            this.length = this.reduce((a, c, i) => c !== undefined ? i + 1 : a, 0);
+        return res;
+    }
+    /**
+     * Create a callback function that gets called for any current or future element in list
+     * @param callbackfn Function to call for every element
+     */
+    forAll(callbackfn) {
+        for (let i = 0; i < this.length; i++) {
+            callbackfn(this.get(i), i);
+        }
+        super.forAll((key, value) => callbackfn(value, key));
+    }
+    /* All general array methods */
+    push(...items) {
+        for (const item of items)
+            this.set(this.length, item);
+        return this.length;
+    }
+    pop() {
+        if (this.length === 0)
+            return null;
+        const res = this.get(this.length);
+        this.delete(this.length);
+        return res;
+    }
+    unshift(...items) {
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (i >= items.length) {
+                this.set(i, this.get(i - items.length));
+            }
+            else {
+                this.set(i, items[i]);
+            }
+        }
+        return this.length;
+    }
+    shift() {
+        if (this.length == 0)
+            return undefined;
+        this.length--;
+        const res = this.get(0);
+        for (let i = 0; i < this.length; i++) {
+            this.set(i, this.get(i + 1));
+        }
+        return res;
+    }
+    splice(start, deleteCount, ...items) {
+        if (deleteCount === undefined) {
+            deleteCount = this.length - start;
+        }
+        // Move elements in front of splice forward or backward
+        let move = items.length - deleteCount;
+        if (move > 0) {
+            for (let i = this.length - 1; i >= start + deleteCount; i--) {
+                this.set(i + move, this.get(i));
+            }
+        }
+        else if (move < 0) {
+            for (let i = start + deleteCount; i < this.length; i++) {
+                this.set(i + move, this.get(i));
+            }
+            // Delete elements past end of new list
+            const originalLength = this.length;
+            for (let i = originalLength + move; i < originalLength; i++) {
+                this.set(i, undefined);
+            }
+        }
+        // Insert new elements starting at start
+        for (let i = start; i < items.length; i++) {
+            this.set(i, items[i]);
+        }
+    }
+    filter(predicate) {
+        const keep = [];
+        for (let i = 0; i < this.length; i++) {
+            keep.push(predicate(this.get(i), i, this));
+        }
+        let negativeOffset = 0;
+        for (let i = 0; i < keep.length; i++) {
+            if (keep[i] && negativeOffset)
+                this.set(i - negativeOffset, this.get(i));
+            if (!keep[i])
+                negativeOffset--;
+        }
+    }
+    map(callbackfn) {
+        for (let i = 0; i < this.length; i++) {
+            this.set(i, callbackfn(this.get(i), i, this));
+        }
+    }
+    flat() {
+        for (let i = 0; i < this.length; i++) {
+            const item = this.get(i);
+            if (item instanceof MultyxClientList) {
+                for (let j = 0; j < item.length; j++) {
+                    i++;
+                    this.set(i, item[j]);
+                }
+            }
+        }
+    }
+    reduce(callbackfn, startingAccumulator) {
+        for (let i = 0; i < this.length; i++) {
+            startingAccumulator = callbackfn(startingAccumulator, this.get(i), i, this);
+        }
+        return startingAccumulator;
+    }
+    reduceRight(callbackfn, startingAccumulator) {
+        for (let i = this.length - 1; i >= 0; i--) {
+            startingAccumulator = callbackfn(startingAccumulator, this.get(i), i, this);
+        }
+        return startingAccumulator;
+    }
+    reverse() {
+        let right = this.length - 1;
+        for (let left = 0; left < right; left++) {
+            const a = this.get(left);
+            const b = this.get(right);
+            this.set(left, b);
+            this.set(right, a);
+        }
+        return this;
+    }
+    forEach(callbackfn) {
+        for (let i = 0; i < this.length; i++) {
+            callbackfn(this.get(i), i, this);
+        }
+    }
+    every(predicate) {
+        for (let i = 0; i < this.length; i++) {
+            if (!predicate(this.get(i), i, this))
+                return false;
+        }
+        return true;
+    }
+    some(predicate) {
+        for (let i = 0; i < this.length; i++) {
+            if (predicate(this.get(i), i, this))
+                return true;
+        }
+        return false;
+    }
+    find(predicate) {
+        for (let i = 0; i < this.length; i++) {
+            if (predicate(this.get(i), i, this))
+                return this.get(i);
+        }
+        return undefined;
+    }
+    findIndex(predicate) {
+        for (let i = 0; i < this.length; i++) {
+            if (predicate(this.get(i), i, this))
+                return i;
+        }
+        return -1;
+    }
+    deorder() {
+        const values = [];
+        for (const index in this.object) {
+            values.push(this.get(index));
+        }
+        return values;
+    }
+    deorderEntries() {
+        const values = [];
+        for (const index in this.object) {
+            values.push([parseInt(index), this.get(index)]);
+        }
+        return values;
+    }
+    entries() {
+        const entryList = [];
+        for (let i = 0; i < this.length; i++) {
+            entryList.push([this.get(i), i]);
+        }
+        return entryList;
+    }
+    keys() {
+        return Array(this.length).fill(0).map((_, i) => i);
+    }
+    /* Native methods to allow MultyxClientList to be treated as array */
+    [Symbol.iterator]() {
+        const values = [];
+        for (let i = 0; i < this.length; i++)
+            values[i] = this.get(i);
+        return values[Symbol.iterator]();
+    }
+}
+_a = Symbol.toPrimitive;
+exports.default = MultyxClientList;

package/dist/items/object.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const message_1 = require("../message");
+const utils_1 = require("../utils");
+const router_1 = require("./router");
+const value_1 = require("./value");
+class MultyxClientObject {
+    get value() {
+        const parsed = {};
+        for (const prop in this.object)
+            parsed[prop] = this.object[prop];
+        return parsed;
+    }
+    constructor(multyx, object, propertyPath = [], editable) {
+        this.object = {};
+        this.propertyPath = propertyPath;
+        this.multyx = multyx;
+        this.editable = editable;
+        this.setterListeners = [];
+        if (object instanceof MultyxClientObject)
+            object = object.value;
+        for (const prop in (object instanceof utils_1.EditWrapper ? object.value : object)) {
+            this.set(prop, object instanceof utils_1.EditWrapper
+                ? new utils_1.EditWrapper(object.value[prop])
+                : object[prop]);
+        }
+        if (this.constructor !== MultyxClientObject)
+            return;
+        return new Proxy(this, {
+            has: (o, p) => {
+                return o.has(p);
+            },
+            get: (o, p) => {
+                if (p in o)
+                    return o[p];
+                return o.get(p);
+            },
+            set: (o, p, v) => {
+                if (p in o) {
+                    o[p] = v;
+                    return true;
+                }
+                return o.set(p, v);
+            },
+            deleteProperty: (o, p) => {
+                return o.delete(p, false);
+            }
+        });
+    }
+    has(property) {
+        return property in this.object;
+    }
+    get(property) {
+        return this.object[property];
+    }
+    set(property, value) {
+        if (value === undefined)
+            return this.delete(property);
+        // Only create new MultyxClientItem when needed
+        if (this.object[property] instanceof value_1.default)
+            return this.object[property].set(value);
+        // If value was deleted by the server
+        if (value instanceof utils_1.EditWrapper && value.value === undefined)
+            return this.delete(property, true);
+        // Attempting to edit property not editable to client
+        if (!(value instanceof utils_1.EditWrapper) && !this.editable) {
+            if (this.multyx.options.verbose) {
+                console.error(`Attempting to set property that is not editable. Setting '${this.propertyPath.join('.') + '.' + property}' to ${value}`);
+            }
+            return false;
+        }
+        // Creating a new value
+        this.object[property] = new ((0, router_1.default)(value instanceof utils_1.EditWrapper ? value.value : value))(this.multyx, value, [...this.propertyPath, property], this.editable);
+        // We have to push into queue, since object may not be fully created
+        // and there may still be more updates to parse
+        for (const listener of this.setterListeners) {
+            this.multyx[utils_1.Add](() => {
+                if (this.has(property))
+                    listener(property, this.get(property));
+            });
+        }
+        // Relay change to server if not edit wrapped
+        if (!(value instanceof utils_1.EditWrapper))
+            this.multyx.ws.send(message_1.Message.Native({
+                instruction: 'edit',
+                path: this.propertyPath,
+                value: this.object[property].value
+            }));
+        return true;
+    }
+    delete(property, native = false) {
+        // Attempting to edit property not editable by client
+        if (!this.editable && !native) {
+            if (this.multyx.options.verbose) {
+                console.error(`Attempting to delete property that is not editable. Deleting '${this.propertyPath.join('.') + '.' + property}'`);
+            }
+            return false;
+        }
+        delete this.object[property];
+        if (!native) {
+            this.multyx.ws.send(message_1.Message.Native({
+                instruction: 'edit',
+                path: [...this.propertyPath, property],
+                value: undefined
+            }));
+        }
+        return true;
+    }
+    /**
+     * Create a callback function that gets called for any current or future property in object
+     * @param callbackfn Function to call for every property
+     */
+    forAll(callbackfn) {
+        for (let prop in this.object) {
+            callbackfn(prop, this.get(prop));
+        }
+        this.setterListeners.push(callbackfn);
+    }
+    keys() {
+        return Object.keys(this.object);
+    }
+    values() {
+        return Object.values(this.object);
+    }
+    entries() {
+        const entryList = [];
+        for (let prop in this.object) {
+            entryList.push([prop, this.get(prop)]);
+        }
+        return entryList;
+    }
+    /**
+     * Unpack constraints from server
+     * @param constraints Packed constraints object mirroring MultyxClientObject shape
+     */
+    [utils_1.Unpack](constraints) {
+        for (const prop in constraints) {
+            this.object[prop][utils_1.Unpack](constraints[prop]);
+        }
+    }
+}
+exports.default = MultyxClientObject;

package/dist/items/router.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = MultyxClientItemRouter;
+function MultyxClientItemRouter(data) {
+    return Array.isArray(data) ? require('./list').default
+        : typeof data == 'object' ? require('./object').default
+            : require('./value').default;
+}

package/dist/items/value.js

@@ -0,0 +1,131 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const message_1 = require("../message");
+const utils_1 = require("../utils");
+class MultyxClientValue {
+    get value() {
+        if (this.interpolator)
+            return this.interpolator.get();
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        if (this.interpolator)
+            this.interpolator.set();
+    }
+    constructor(multyx, value, propertyPath = [], editable) {
+        /* Native methods to allow MultyxValue to be treated as primitive */
+        this.toString = () => this.value.toString();
+        this.valueOf = () => this.value;
+        this[_a] = () => this.value;
+        this.propertyPath = propertyPath;
+        this.editable = editable;
+        this.multyx = multyx;
+        this.constraints = {};
+        this.set(value);
+    }
+    set(value) {
+        if (value instanceof utils_1.EditWrapper) {
+            this.value = value.value;
+            return true;
+        }
+        // Attempting to edit property not editable to client
+        if (!this.editable) {
+            if (this.multyx.options.verbose) {
+                console.error(`Attempting to set property that is not editable. Setting '${this.propertyPath.join('.')}' to ${value}`);
+            }
+            return false;
+        }
+        let nv = value;
+        for (const constraint in this.constraints) {
+            const fn = this.constraints[constraint];
+            nv = fn(nv);
+            if (nv === null) {
+                if (this.multyx.options.verbose) {
+                    console.error(`Attempting to set property that failed on constraint. Setting '${this.propertyPath.join('.')}' to ${value}, stopped by constraint '${constraint}'`);
+                }
+                return false;
+            }
+        }
+        if (this.value === nv) {
+            this.value = nv;
+            return true;
+        }
+        this.value = nv;
+        this.multyx.ws.send(message_1.Message.Native({
+            instruction: 'edit',
+            path: this.propertyPath,
+            value: nv
+        }));
+        return true;
+    }
+    /**
+     * Unpack constraints sent from server and store
+     * @param constraints Packed constraints from server
+     */
+    [utils_1.Unpack](constraints) {
+        for (const [cname, args] of Object.entries(constraints)) {
+            const constraint = (0, utils_1.BuildConstraint)(cname, args);
+            if (!constraint)
+                continue;
+            this.constraints[cname] = constraint;
+        }
+    }
+    /**
+     * Linearly interpolate value across frames
+     * Will run 1 frame behind on average
+     */
+    Lerp() {
+        this.interpolator = {
+            history: [
+                { value: this._value, time: Date.now() },
+                { value: this._value, time: Date.now() }
+            ],
+            get: () => {
+                const [e, s] = this.interpolator.history;
+                const ratio = Math.min(1, (Date.now() - e.time) / Math.min(250, e.time - s.time));
+                if (Number.isNaN(ratio) || typeof e.value != 'number' || typeof s.value != 'number')
+                    return e.value;
+                return e.value * ratio + s.value * (1 - ratio);
+            },
+            set: () => {
+                this.interpolator.history.pop();
+                this.interpolator.history.unshift({
+                    value: this._value,
+                    time: Date.now()
+                });
+            }
+        };
+    }
+    PredictiveLerp() {
+        this.interpolator = {
+            history: [
+                { value: this._value, time: Date.now() },
+                { value: this._value, time: Date.now() },
+                { value: this._value, time: Date.now() }
+            ],
+            get: () => {
+                const [e, s, p] = this.interpolator.history;
+                const ratio = Math.min(1, (Date.now() - e.time) / (e.time - s.time));
+                if (Number.isNaN(ratio) || typeof p.value != 'number')
+                    return e.value;
+                if (typeof e.value != 'number' || typeof s.value != 'number')
+                    return e.value;
+                // Speed changed too fast, don't interpolate, return new value
+                if (Math.abs((e.value - s.value) / (s.value - p.value) - 1) > 0.2)
+                    return e.value;
+                return e.value * (1 + ratio) - s.value * ratio;
+            },
+            set: () => {
+                this.interpolator.history.pop();
+                this.interpolator.history.unshift({
+                    value: this._value,
+                    time: Date.now()
+                });
+            }
+        };
+    }
+}
+_a = Symbol.toPrimitive;
+exports.default = MultyxClientValue;

package/dist/message.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+class Message {
+    constructor(name, data, native = false) {
+        this.name = name;
+        this.data = data;
+        this.time = Date.now();
+        this.native = native;
+    }
+    static BundleOperations(deltaTime, operations) {
+        if (!Array.isArray(operations))
+            operations = [operations];
+        return JSON.stringify(new Message('_', { operations, deltaTime }));
+    }
+    static Native(update) {
+        return JSON.stringify(new Message('_', update, true));
+    }
+    static Parse(str) {
+        const parsed = JSON.parse(str);
+        if (parsed.name[0] == '_')
+            parsed.name = parsed.name.slice(1);
+        return new Message(parsed.name, parsed.data, parsed.name == '');
+    }
+    static Create(name, data) {
+        if (name.length == 0)
+            throw new Error('Multyx message cannot have empty name');
+        if (name[0] == '_')
+            name = '_' + name;
+        if (typeof data === 'function') {
+            throw new Error('Multyx data must be JSON storable');
+        }
+        return JSON.stringify(new Message(name, data));
+    }
+}
+exports.Message = Message;

package/dist/options.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOptions = void 0;
+exports.DefaultOptions = {
+    port: 443,
+    secure: false,
+    uri: 'localhost',
+    verbose: false,
+    logUpdateFrame: false,
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditWrapper = exports.Add = exports.Done = exports.Unpack = void 0;
+exports.Interpolate = Interpolate;
+exports.BuildConstraint = BuildConstraint;
+exports.Unpack = Symbol("unpack");
+exports.Done = Symbol("done");
+exports.Add = Symbol("add");
+class EditWrapper {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.EditWrapper = EditWrapper;
+/**
+ * Set a customized interpolation curve for values to follow
+ * @param values Slices to interpolate through. Time must be between 0 and 1, while progress is the percentage between the old value and new value at the respective time, where 0 represents old value and 1 represents new value
+ * @example
+ * ```js
+ * car.get('speed').interpolate([
+ *  { time: 0, progress: 0 },
+ *  { time: 0.2, progress: 0.6 },
+ *  { time: 0.4, progress: 1.2 },
+ *  { time: 0.6, progress: 1.4 },
+ *  { time: 0.8, progress: 1.2 },
+ *  { time: 1, progress: 1 }
+ * ]);
+ * ```
+ */
+function Interpolate(object, property, interpolationCurve) {
+    let start = { value: object[property], time: Date.now() };
+    let end = { value: object[property], time: Date.now() };
+    Object.defineProperty(object, property, {
+        get: () => {
+            const time = end.time - start.time;
+            let lower = interpolationCurve[0];
+            let upper = interpolationCurve[0];
+            for (const slice of interpolationCurve) {
+                if (time > slice.time && slice.time > lower.time)
+                    lower = slice;
+                if (time < slice.time && slice.time < upper.time)
+                    upper = slice;
+            }
+            const sliceTime = (time - lower.time) / (upper.time - lower.time);
+            const ratio = lower.progress + sliceTime * (upper.progress - lower.progress);
+            if (Number.isNaN(ratio))
+                return start.value;
+            return end.value * ratio + start.value * (1 - ratio);
+        },
+        set: (value) => {
+            // Don't lerp between edit requests sent in same frame
+            if (Date.now() - end.time < 10) {
+                end.value = value;
+                return true;
+            }
+            start = Object.assign({}, end);
+            end = { value, time: Date.now() };
+            return true;
+        }
+    });
+}
+function BuildConstraint(name, args) {
+    if (name == 'min')
+        return n => n >= args[0] ? n : args[0];
+    if (name == 'max')
+        return n => n <= args[0] ? n : args[0];
+    if (name == 'int')
+        return n => Math.floor(n);
+    if (name == 'ban')
+        return n => args.includes(n) ? null : n;
+    if (name == 'disabled')
+        return n => args[0] ? null : n;
+    return I => I;
+}