@makefully/platypus 4.1.4 → 4.1.6

package/src/TickerServer.js

@@ -0,0 +1,23 @@
+self.onmessage = ({data}) => {
+    let interval = 0;
+
+    if (data.begin) {
+        let time = performance.now();
+
+        clearInterval(interval);
+        interval = setInterval(() => {
+            const
+                newTime = performance.now();
+
+            self.postMessage({
+                deltaTime: newTime - time
+            });
+
+            time = newTime;
+        }, data.begin.delta);
+    }
+    if (data.stop) {
+        clearInterval(interval);
+    }
+};
+

package/src/TimeEvent.js

@@ -0,0 +1,50 @@
+import recycle from 'recycle';
+
+const
+    TimeEvent = function (event = '', time = 0, message = null, entity = null, interruptable = true) {
+        if (typeof event === 'object') {
+            this.event = event.event ?? '';
+            this.message = event.message ?? message;
+            this.time = (event.time ?? 0) + time;
+            this.entity = event.entity ?? entity;
+            this.interruptable = event.interruptable ?? interruptable;
+        } else {
+            this.event = event;
+            this.message = message;
+            this.time = time;
+            this.entity = entity;
+            this.interruptable = interruptable;
+        }
+    },
+    proto = TimeEvent.prototype;
+
+proto.toJSON = function () {
+    return {
+        event: this.event,
+        message: this.message,
+        time: this.time,
+        entity: this.entity?.id ?? this.entity,
+        interruptable: this.interruptable
+    };
+};
+
+/**
+ * Returns a TimeEvent from cache or creates a new one if none are available.
+ *
+ * @method platypus.TimeEvent.setUp
+ * @return {platypus.TimeEvent} The instantiated TimeEvent.
+ */
+/**
+ * Returns a TimeEvent back to the cache.
+ *
+ * @method platypus.TimeEvent.recycle
+ * @param {platypus.TimeEvent} timeEvent The TimeEvent to be recycled.
+ */
+/**
+ * Relinquishes properties of the TimeEvent and recycles it.
+ *
+ * @method platypus.TimeEvent#recycle
+ */
+recycle.add(TimeEvent, 'TimeEvent', TimeEvent, null, true);
+
+export default TimeEvent;

package/src/TimeEventList.js

@@ -0,0 +1,100 @@
+import recycle from 'recycle';
+import { arrayCache } from './utils/array';
+import TimeEvent from './TimeEvent';
+
+const
+    TimeEventList = function (list = [], time = 0) {
+        if (!this.list) {
+            this.list = arrayCache.setUp();
+        }
+
+        this.addEvents(list);
+        this.time = time;
+    },
+    sortByTime = function (a, b) {
+        return a.time - b.time;
+    },
+    proto = TimeEventList.prototype;
+
+proto.clear = function (list) {
+    return this.getEvents(Infinity, list);
+};
+
+proto.addEvents = function (list, time = 0) {
+    const
+        {list: timeList} = this,
+        arr = arrayCache.setUp();
+
+    list.forEach((entry) => {
+        if (typeof entry === 'number') {
+            time += entry;
+        } else if (entry instanceof TimeEvent) {
+            timeList.push(entry);
+            arr.push(entry);
+        } else {
+            const
+                event = TimeEvent.setUp(entry, time);
+
+            timeList.push(event);
+            arr.push(event);
+        }
+    });
+
+    timeList.sort(sortByTime);
+
+    return arr;
+};
+
+proto.getEvents = function (time, limitToThese) {
+    const
+        arr = arrayCache.setUp(),
+        {list} = this;
+
+    this.time = time;
+
+    while (list.length && list[0].time <= time) {
+        if (!limitToThese || limitToThese.indexOf(list[0]) >= 0) {
+            arr.push(list.shift());
+        }
+    }
+
+    return arr;
+}
+
+proto.getDuration = function () {
+    const
+        {list} = this;
+
+    return list.length ? list[list.length - 1].time : 0;
+}
+
+proto.update = function (delta) {
+    return this.getEvents(this.time + delta);
+};
+
+proto.toJSON = function () {
+    return this.list.map((entry) => entry.toJSON());
+};
+
+/**
+ * Returns a TimeEventList from cache or creates a new one if none are available.
+ *
+ * @method platypus.TimeEventList.setUp
+ * @return {platypus.TimeEventList} The instantiated TimeEventList.
+ */
+/**
+ * Returns a TimeEventList back to the cache.
+ *
+ * @method platypus.TimeEventList.recycle
+ * @param {platypus.TimeEventList} timeEvent The TimeEventList to be recycled.
+ */
+/**
+ * Relinquishes properties of the TimeEventList and recycles it.
+ *
+ * @method platypus.TimeEventList#recycle
+ */
+recycle.add(TimeEventList, 'TimeEventList', TimeEventList, function () {
+        this.list.length = 0;
+    }, true);
+
+export default TimeEventList;