@woosh/meep-engine/src/core/model/ObservedInteger.js

Pure JavaScript game engine. Fully featured and production ready.

import { assert } from "../assert.js";
import { anyOf, isInfinite, isInteger } from "../debug/matchers/matchers.js";
import Signal from "../events/signal/Signal.js";

class ObservedInteger extends Number {
    /**
     * @readonly
     * @type {Signal}
     */
    onChanged = new Signal();

    /**
     *
     * @param {number} [value=0]
     * @constructor
     */
    constructor(value = 0) {
        super();

        assert.isNumber(value, 'value');
        assert.that(value,'value',anyOf(isInfinite(),isInteger()))

        /**
         *
         * @type {number}
         * @private
         */
        this.__value = value;

    }

    /**
     *
     * @returns {number}
     */
    valueOf() {
        return this.getValue();
    }

    toString() {
        return this.getValue().toString();
    }

    /**
     *
     * @param {number} value
     * @returns {this}
     */
    set(value) {
        assert.isNumber(value, 'value');
        assert.that(value,'value',anyOf(isInfinite(),isInteger()))


        const oldValue = this.__value;
        if (oldValue !== value) {
            this.__value = value;
            this.onChanged.send2(value, oldValue);
        }

        return this;
    }

    /**
     * Set value without dispatching change notification
     * @param {number} value
     */
    setSilent(value) {
        assert.isNumber(value, 'value');
        assert.that(value,'value',anyOf(isInfinite(),isInteger()))

        this.__value = value;
    }

    /**
     *
     * @return {boolean}
     */
    isZero() {
        return this.getValue() === 0;
    }

    /**
     *
     * @param {ObservedInteger} other
     */
    subtract(other) {
        this._add(-other.getValue());
    }

    /**
     *
     * @param {number} value
     */
    _subtract(value) {
        this.set(this.getValue() - value);
    }

    /**
     *
     * @param {ObservedInteger} other
     */
    add(other) {
        this._add(other.getValue());
    }

    /**
     *
     * @param {number} value
     */
    _add(value) {
        this.set(this.getValue() + value);
    }

    /**
     * Increment the stored value by 1, same as adding 1
     */
    increment() {
        this.set(this.getValue() + 1);
    }

    /**
     * Decrement the stored value by 1, same as subtracting 1
     */
    decrement() {
        this.set(this.getValue() - 1);
    }

    /**
     *
     * @returns {number}
     */
    getValue() {
        return this.__value;
    }

    /**
     *
     * @param {ObservedInteger} other
     */
    copy(other) {
        this.set(other.__value);
    }

    /**
     *
     * @param {ObservedInteger} other
     * @returns {boolean}
     */
    equals(other) {
        return this.__value === other.__value;
    }

    /**
     *
     * @returns {number}
     */
    hash() {
        return this.__value;
    }

    toJSON() {
        return this.__value;
    }

    fromJSON(obj) {
        this.set(obj);
    }

    /**
     *
     * @param {BinaryBuffer} buffer
     */
    toBinaryBuffer(buffer) {
        const v = this.__value;

        if (v === Infinity) {
            buffer.writeInt32(2147483647);
        } else if (v === -Infinity) {
            buffer.writeInt32(-2147483648);
        } else {
            //TODO it's possible to write encoded Infinity values by accident
            buffer.writeInt32(v);
        }
    }

    /**
     *
     * @param {BinaryBuffer} buffer
     */
    fromBinaryBuffer(buffer) {
        const value = buffer.readInt32();

        if (value === 2147483647) {
            this.set(Infinity);
        } else if (value === -2147483648) {
            this.set(-Infinity);
        } else {
            this.set(value);
        }
    }
}


/**
 * @readonly
 * @type {boolean}
 */
ObservedInteger.prototype.isObservedInteger = true;

export default ObservedInteger;