lr-core/line-rider-engine/constraints/index.js

Line Rider core library

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DirectedChain = exports.BindJoint = exports.BindStick = exports.RepelStick = exports.Stick = undefined;

var _v = require('../../v2');

var _v2 = _interopRequireDefault(_v);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function stickResolve(p1, p2, diff) {
  let delta = (0, _v2.default)(p1.pos).sub(p2.pos).mul(diff);

  return [p1.setPosition((0, _v2.default)(p1.pos).sub(delta)), p2.setPosition(delta.add(p2.pos))];
}

function getDiff(restLength, length) {
  return length === 0 ? 0 : (length - restLength) / length;
}

class Stick {
  get iterating() {
    return true;
  }
  constructor({ id, p1, p2, length, lengthFactor = 1 }, initialStateMap) {
    length = length != null ? length : _v2.default.dist(initialStateMap.get(p1).pos, initialStateMap.get(p2).pos);
    length *= lengthFactor;
    Object.assign(this, { id, p1, p2, length });
  }

  getDiff(length) {
    return getDiff(this.length, length) * 0.5;
  }

  resolve(stateMap) {
    let p1 = stateMap.get(this.p1);
    let p2 = stateMap.get(this.p2);
    let length = _v2.default.dist(p1.pos, p2.pos);
    return stickResolve(p1, p2, this.getDiff(length));
  }
}
exports.Stick = Stick;
class RepelStick extends Stick {
  resolve(stateMap) {
    let p1 = stateMap.get(this.p1);
    let p2 = stateMap.get(this.p2);
    let length = _v2.default.dist(p1.pos, p2.pos);
    if (length >= this.length) {
      return [];
    }
    return stickResolve(p1, p2, this.getDiff(length));
  }
}

exports.RepelStick = RepelStick;
class BindStick extends Stick {
  constructor({ id, p1, p2, length, binding, endurance }, initialStateMap) {
    super({ id, p1, p2, length }, initialStateMap);
    endurance = endurance * this.length * 0.5;
    Object.assign(this, { binding, endurance });
  }
  resolve(stateMap) {
    let binding = stateMap.get(this.binding);
    if (!binding.isBinded()) {
      return [];
    }
    let p1 = stateMap.get(this.p1);
    let p2 = stateMap.get(this.p2);
    let length = _v2.default.dist(p1.pos, p2.pos);
    let diff = this.getDiff(length);
    if (diff > this.endurance) {
      return [binding.setBind(false)];
    }
    return stickResolve(p1, p2, diff);
  }
}

exports.BindStick = BindStick;
class BindJoint {
  get iterating() {
    return false;
  }

  constructor({ id, p1, p2, q1, q2, binding }) {
    Object.assign(this, { id, p1, p2, q1, q2, binding });
  }

  resolve(stateMap) {
    let p1 = stateMap.get(this.p1);
    let p2 = stateMap.get(this.p2);
    let q1 = stateMap.get(this.q1);
    let q2 = stateMap.get(this.q2);
    let binding = stateMap.get(this.binding);
    // allow kramuals
    if (_v2.default.cross((0, _v2.default)(p2.pos).sub(p1.pos), (0, _v2.default)(q2.pos).sub(q1.pos)) >= 0) {
      return [];
    } else if (binding.isBinded()) {
      return [binding.setBind(false)];
    }
    return [];
  }
}
exports.BindJoint = BindJoint;
class DirectedChain {
  get iterating() {
    return false;
  }

  constructor({ id, ps }, initialStateMap) {
    let [, ...points] = ps;
    let lengths = points.map((id, i) => _v2.default.dist(initialStateMap.get(id).pos, initialStateMap.get(ps[i]).pos));
    Object.assign(this, { id, ps, lengths });
  }

  resolve(stateMap) {
    let points = this.ps.map(id => stateMap.get(id));

    for (let i = 1; i < points.length; i++) {
      let p0 = points[i - 1];
      let p1 = points[i];
      let restLength = this.lengths[i - 1];
      let length = _v2.default.dist(p0.pos, p1.pos);
      let nextPosition = (0, _v2.default)(p0.pos).sub(p1.pos).mul(getDiff(restLength, length)).add(p1.pos);

      points[i] = p1.setPosition(nextPosition);
    }

    [, ...points] = points;

    return points;
  }
}
exports.DirectedChain = DirectedChain;