rails-physics 1.3.2 → 1.3.4

package/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import {SegmentTree} from "./ranges/segmenttree.js";
+import {mapToRail} from "./transform.js";
 import Matter from "matter-js";
 
 export const Rails = {
@@ -13,34 +14,42 @@ export const Rails = {
             Rails.Body.createRail(this);
         });
 
-        base.before("Body.update", function(body, time) {
+        base.before("Body.update", function(body) {
             Rails.Body.alignRailBody(body);
         });
+
+        base.after("Body.update", function(body) {
+            Rails.Body.prepareRailBody(body);
+        });
     },
 
     Body: {
         createRail: function(body) {
             console.log(body);
             if(body.plugin.rails_granularity !== undefined) {
-                let transverse_axis = Matter.Vector.create(1, 0);
-                let slide_axis = Matter.Vector.create(0, 1);
-                if(body.plugin.transverse_axis !== undefined) {
-                    transverse_axis = body.plugin.transverse_axis;
-                }
-                if(body.plugin.slide_axis !== undefined) {
-                    slide_axis = body.plugin.slide_axis;
-                }
+                body.plugin.transverse_axis = body.plugin.transverse_axis ?? Matter.Vector.create(1, 0);
+                body.plugin.slide_axis = body.plugin.slide_axis ?? Matter.Vector.create(0, 1);
+                let transverse_axis = body.plugin.transverse_axis;
+                let slide_axis = body.plugin.slide_axis;
                 body.plugin.centre_finder = new SegmentTree(body, body.plugin.rails_granularity, transverse_axis, slide_axis);
-                body.plugin.old_centre = Matter.Vector.rotate(body.plugin.centre_finder.centreOfMass(), body.angle);
+                body.plugin.old_offset_multiplier = body.plugin.centre_finder.centreOfMass();
+
+                body.plugin.test_start = (1 << 16) - 1;
             }
         },
 
-        alignRailBody: function(body, time) {
-            console.log(body.deltaTime, time);
+        alignRailBody: function(body) {          
             if(body.plugin.centre_finder !== undefined) {
-                console.log("sigma");
+                let upcoming_offset_multiplier = body.plugin.centre_finder.centreOfMass();
+                let old_offset = mapToRail(body.plugin.old_offset_multiplier, transverse_axis, slide_axis);
+                let upcoming_offset = mapToRail(upcoming_offset_multiplier, transverse_axis, slide_axis);
+                Matter.Body.setCentre(body, Matter.Vector.add(Matter.Vector.sub(body.position, old_offset, Matter.Vector.create()), upcoming_offset, Matter.Vector.create()));
+                body.plugin.old_offset_multiplier = upcoming_offset_multiplier;
+                body.plugin.centre_finder.update((1 << 16), body.plugin.test_start, 0.001);
+                body.plugin.test_start = Math.max(body.plugin.test_start - 1, 0);
             }
         }
+
     }
             
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rails-physics",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "A plugin for the matter-js physics library designed to efficiently simulate objects moving in a one-dimensional space whose projection onto the 2-dimensional space of the screen changes over time",
   "keywords": [
     "typescript",
@@ -26,7 +26,8 @@
     "ranges/segment.js",
     "ranges/segmenttree.js",
     "rails-physics.d.ts",
-    "sliders/slider.js"
+    "sliders/slider.js",
+    "transform.js"
   ],
   "directories": {
     "test": "tests"

package/ranges/segment.js

@@ -1,4 +1,19 @@
-//test change
+export function updateMass(segment, frame_number, mass_change = 0) {
+    var _a, _b, _c, _d, _e;
+    segment.waiting_left = (_a = segment.waiting_left) !== null && _a !== void 0 ? _a : 0;
+    segment.waiting_right = (_b = segment.waiting_right) !== null && _b !== void 0 ? _b : 0;
+    if (segment.frame_number != frame_number) {
+        segment.my_change = 0;
+        segment.waiting_left = 0;
+        segment.waiting_right = 0;
+    }
+    segment.my_change = ((_c = segment.my_change) !== null && _c !== void 0 ? _c : 0) + mass_change;
+    segment.frame_number = frame_number;
+    let left_size = centre(segment) - segment.left;
+    let right_size = segment.right - centre(segment);
+    segment.waiting_left = ((_d = segment.waiting_left) !== null && _d !== void 0 ? _d : 0) + (mass_change / (left_size + right_size)) * left_size;
+    segment.waiting_right = ((_e = segment.waiting_right) !== null && _e !== void 0 ? _e : 0) + (mass_change / (left_size + right_size)) * right_size;
+}
 export function centre(segment) {
     return segment.left + ((segment.right - segment.left) >> 1); // + ((segment.right - segment.left) & 1);
 }

package/ranges/segmenttree.js

@@ -10,52 +10,101 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _SegmentTree_raw;
-import { centre, leftChild, rightChild, isLeaf } from "./segment.js";
+import { centre, leftChild, rightChild, isLeaf, updateMass } from "./segment.js";
 import Matter from "matter-js";
+const ROOT = -1;
 //Implement a segment tree for O(log(n)) updates and O(log(n)) location of center of mass
 export class SegmentTree {
-    constructor(container, element_count, transverse_axis, slide_axis) {
+    constructor(container, element_count, transverse_axis, slide_axis, gravity = Matter.Vector.create(0, 0)) {
         _SegmentTree_raw.set(this, void 0);
+        this.frame_number = 0;
+        this.air_resistance = container.frictionAir;
+        this.static_friction = container.frictionStatic;
+        this.dynamic_friction = container.friction;
+        this.gravity = gravity;
         this.element_count = element_count;
         this.slide_axis = slide_axis;
         this.transverse_axis = transverse_axis;
         element_count = Math.abs(Math.round(element_count));
-        let default_density = container.density;
-        __classPrivateFieldSet(this, _SegmentTree_raw, [{ mass: default_density * element_count, left: 0, right: element_count, parent: -1, waiting_changes: 0 }], "f");
+        let default_density = container.mass / element_count;
+        __classPrivateFieldSet(this, _SegmentTree_raw, [{ mass: default_density * element_count, left: 0, right: element_count, parent: ROOT }], "f");
         let index = 0;
         while (index < __classPrivateFieldGet(this, _SegmentTree_raw, "f").length) {
-            if (index < 20) {
-                console.log(index, __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left, __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right, __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].mass, default_density);
-            }
             if (!isLeaf(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])) {
                 let middle = centre(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]);
                 __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left_child = __classPrivateFieldGet(this, _SegmentTree_raw, "f").length;
-                __classPrivateFieldGet(this, _SegmentTree_raw, "f").push({ mass: default_density * (middle - __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left), left: __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left, right: middle, parent: index, waiting_changes: 0 });
+                __classPrivateFieldGet(this, _SegmentTree_raw, "f").push({ mass: default_density * (middle - __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left), left: __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left, right: middle, parent: index });
                 __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right_child = __classPrivateFieldGet(this, _SegmentTree_raw, "f").length;
-                __classPrivateFieldGet(this, _SegmentTree_raw, "f").push({ mass: default_density * (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right - middle), left: middle, right: __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right, parent: index, waiting_changes: 0 });
+                __classPrivateFieldGet(this, _SegmentTree_raw, "f").push({ mass: default_density * (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right - middle), left: middle, right: __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right, parent: index });
             }
             index++;
         }
     }
+    resolve(index) {
+        var _a;
+        if (!isLeaf(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]) && __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].frame_number == this.frame_number) {
+            updateMass(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])], this.frame_number, __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].waiting_left);
+            updateMass(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[rightChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])], this.frame_number, __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].waiting_right);
+            __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].waiting_left = 0;
+            __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].waiting_right = 0;
+        }
+        let base = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].mass;
+        if (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].frame_number == this.frame_number) {
+            base += (_a = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].my_change) !== null && _a !== void 0 ? _a : 0;
+        }
+        return __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].mass;
+    }
+    propagate(index, leaf_change) {
+        var _a;
+        if (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].parent != ROOT) {
+            let parent = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].parent;
+            if ((__classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].frame_number) != __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].frame_number) {
+                __classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].my_change = 0;
+                __classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].waiting_left = 0;
+                __classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].waiting_right = 0;
+                __classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].frame_number = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].frame_number;
+            }
+            __classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].my_change = ((_a = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[parent].my_change) !== null && _a !== void 0 ? _a : 0) + leaf_change;
+            this.propagate(parent, leaf_change);
+        }
+    }
+    update(start, end, amount, index = 0) {
+        if (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left == start && (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].right - 1) == end) {
+            updateMass(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index], this.frame_number, amount * (end - start));
+            this.propagate(index, amount * (end - start));
+        }
+        else {
+            let half = centre(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]);
+            if (start < half) {
+                this.update(start, Math.min(half, end), amount, leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]));
+            }
+            if (end > half) {
+                this.update(Math.max(half, start), end, amount, rightChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]));
+            }
+        }
+    }
+    //Get centre of mass and reset effects of slider
     centreOfMass() {
-        let target = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[0].mass / 2;
+        let target = this.resolve(0) / 2;
         let index = 0;
         while (!isLeaf(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])) {
-            console.log(target, index, leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]), __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].mass);
-            if (__classPrivateFieldGet(this, _SegmentTree_raw, "f")[leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])].mass > target) {
+            console.log(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]);
+            if (this.resolve(leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])) > target) {
                 index = leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]);
             }
             else {
-                target -= __classPrivateFieldGet(this, _SegmentTree_raw, "f")[leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index])].mass;
+                target -= this.resolve(leftChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]));
                 index = rightChild(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]);
+                this.resolve(index);
             }
         }
+        console.log(__classPrivateFieldGet(this, _SegmentTree_raw, "f")[index]);
         let center = __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].left;
-        if (target > 0 && __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].mass > target) {
-            center += (1.0 * target) / __classPrivateFieldGet(this, _SegmentTree_raw, "f")[index].mass;
+        if (target > 0 && this.resolve(index) > target) {
+            center += (1.0 * target) / this.resolve(index);
         }
-        let result = Matter.Vector.mult(this.slide_axis, center / this.element_count);
-        return Matter.Vector.add(result, this.transverse_axis);
+        this.frame_number++;
+        return center / this.element_count;
     }
 }
 _SegmentTree_raw = new WeakMap();

package/sliders/slider.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var Slider = /** @class */ (function () {
-    function Slider(mass, length_below, length_above, air_resistance, static_friction, dynamic_friction, initial_velocity, position) {
-        if (initial_velocity === void 0) { initial_velocity = 0; }
-        if (position === void 0) { position = 0; }
+export default class Slider {
+    constructor(mass, length_below, length_above, air_resistance, static_friction, dynamic_friction, initial_velocity = 0, position = 0) {
         this.mass = mass;
         this.length_below = length_below;
         this.length_above = length_above;
@@ -14,6 +10,4 @@ var Slider = /** @class */ (function () {
         this.dynamic_friction = dynamic_friction;
         this.position = position;
     }
-    return Slider;
-}());
-exports.default = Slider;
+}

package/transform.js

@@ -0,0 +1,4 @@
+import Matter from "matter-js";
+export function mapToRail(scale, transverse_axis, slide_axis) {
+    return Matter.Vector.add(Matter.Vector.mult(slide_axis, scale), transverse_axis, Matter.Vector.create());
+}