@luceosports/play-rendering 1.19.0 → 2.0.0

package/src/math/LineDrawingMath.js

@@ -1,570 +0,0 @@
-const math = require('mathjs');
-
-const sinusoidNumberOfPoints = 1000;
-
-module.exports.adjustedBezierCurveWithExclusionZones = function(
-  controlPoints,
-  startZoneRadius = null,
-  startAnchor = null,
-  endZoneRadius = null,
-  endAnchor = null
-) {
-  let curve = [...controlPoints];
-  if (startZoneRadius && startAnchor) {
-    const controlPointsMat = controlPointsMatFromPoints(controlPoints);
-    const tVal = firstTValForPointOnCurveOutsideCircle(controlPointsMat, startAnchor, startZoneRadius);
-    const splitCurves = splitBezierCurveAtTVal(controlPoints, tVal);
-    curve = [...splitCurves].pop();
-  }
-
-  if (endZoneRadius && endAnchor) {
-    const reverseControlPoints = [].concat(curve).reverse(); // reverse array without changing the original
-    const reverseControlPointsMat = controlPointsMatFromPoints(reverseControlPoints);
-    const reverseTVal = firstTValForPointOnCurveOutsideCircle(reverseControlPointsMat, endAnchor, endZoneRadius);
-    const tVal = 1.0 - reverseTVal;
-    const splitCurves = splitBezierCurveAtTVal(curve, tVal);
-    curve = splitCurves[0];
-  }
-  return curve;
-};
-
-module.exports.sinusodialBezierPathsForBezierPaths = function(controlPointPaths, waveLength, amplitude) {
-  const [pointsOnCurve, tangentAnglesToPointsOnCurve] = evenlySpacedPointsOnCurveWithTangentAngles(
-    controlPointPaths,
-    waveLength / 2.0
-  );
-
-  const returnPaths = [];
-  let normal_PI_inc = Math.PI / 2;
-  let index = 0;
-
-  while (index < pointsOnCurve.length - 4) {
-    const beginPoint = pointsOnCurve[index];
-    const midPoint = pointsOnCurve[index + 1];
-    const endPoint = pointsOnCurve[index + 2];
-    const midPointNormalAngle = tangentAnglesToPointsOnCurve[index + 1] + normal_PI_inc;
-
-    const controlPoint = {
-      x: midPoint.x + amplitude * Math.cos(midPointNormalAngle),
-      y: midPoint.y + amplitude * Math.sin(midPointNormalAngle)
-    };
-
-    returnPaths.push([beginPoint, controlPoint, endPoint]);
-    normal_PI_inc *= -1.0;
-    index += 2;
-  }
-
-  const lastPoint = [...[...returnPaths].pop()].pop();
-  if (lastPoint) {
-    const lastCp = [...[...controlPointPaths].pop().controlPoints].pop();
-    returnPaths.push([lastPoint, lastCp]);
-  }
-  return returnPaths;
-};
-
-module.exports.distanceBetweenPoints = function(point1, point2) {
-  const xDist = point1.x - point2.x;
-  const yDist = point1.y - point2.y;
-  return Math.sqrt(xDist * xDist + yDist * yDist);
-};
-
-module.exports.splitBezierCurveAtTVal = splitBezierCurveAtTVal;
-
-function evenlySpacedPointsOnCurveWithTangentAngles(controlPointPaths, distanceBetweenPoints) {
-  const returnPoints = [];
-  const returnTangentAngles = [];
-
-  controlPointPaths.forEach((linePath, pathIndex) => {
-    const { controlPoints } = linePath;
-    const helperMat = helperMatrixForDegree(controlPoints.length - 1);
-    const tMat = preCalculatedTMatrixForDegree(controlPoints.length - 1);
-    const controlPointsMat = controlPointsMatFromPoints(controlPoints);
-    const testPoints = math.multiply(helperMat, controlPointsMat);
-    const testPointsTangentRatiosMat = slopesOnCurveAtTVals(controlPointsMat, tMat);
-    const distancesBetweenPoints = distanceBetweenPointsOnCurve(testPoints);
-    if (pathIndex === 0) {
-      const tpFirstRowVector0 = math.subset(testPointsTangentRatiosMat, math.index(0, [0]));
-      const tpFirstRowVector1 = math.subset(testPointsTangentRatiosMat, math.index(0, [1]));
-      returnTangentAngles.push(Math.atan2(tpFirstRowVector1, tpFirstRowVector0));
-      returnPoints.push({ x: tpFirstRowVector0, y: tpFirstRowVector1 });
-    }
-
-    let currentDistance = 0.0;
-    distancesBetweenPoints.forEach((dist, i) => {
-      currentDistance += dist;
-      if (currentDistance >= distanceBetweenPoints) {
-        const tpAdjustedStartVectorX = math.subset(testPointsTangentRatiosMat, math.index(i, [0]));
-        const tpAdjustedStartVectorY = math.subset(testPointsTangentRatiosMat, math.index(i, [1]));
-        returnTangentAngles.push(Math.atan2(tpAdjustedStartVectorY, tpAdjustedStartVectorX));
-        returnPoints.push({ x: tpAdjustedStartVectorX, y: tpAdjustedStartVectorY });
-        currentDistance = 0.0;
-      }
-    });
-  });
-
-  return [returnPoints, returnTangentAngles];
-}
-
-function distanceBetweenPointsOnCurve(points) {
-  // Creates a copy of the vector with points offset by 1 in order to calculate the relative distances between points
-  const [pointsNumberOfRows] = points.size();
-
-  const xPointsVector = [];
-  points.forEach(value => xPointsVector.push(value));
-
-  const oneOffSetXPoints = [...xPointsVector];
-  oneOffSetXPoints.splice(0, 2);
-  oneOffSetXPoints.push(xPointsVector[xPointsVector.length - 2]);
-  oneOffSetXPoints.push(xPointsVector[xPointsVector.length - 1]);
-
-  const yPointsVector = [...xPointsVector];
-  yPointsVector.splice(0, 1);
-
-  const oneOffSetYPoints = [...oneOffSetXPoints];
-  oneOffSetYPoints.splice(0, 1);
-
-  const xPointsVectorStrideAdjusted = [];
-  const oneOffSetXPointsStrideAdjusted = [];
-  const yPointsVectorStrideAdjusted = [];
-  const oneOffSetYPointsStrideAdjusted = [];
-  xPointsVector.forEach((p, index) => {
-    if (!(index % 2)) xPointsVectorStrideAdjusted.push(p);
-  });
-  oneOffSetXPoints.forEach((p, index) => {
-    if (!(index % 2)) oneOffSetXPointsStrideAdjusted.push(p);
-  });
-  yPointsVector.forEach((p, index) => {
-    if (!(index % 2)) yPointsVectorStrideAdjusted.push(p);
-  });
-  oneOffSetYPoints.forEach((p, index) => {
-    if (!(index % 2)) oneOffSetYPointsStrideAdjusted.push(p);
-  });
-
-  const distance = [];
-  for (let n = 0; n < pointsNumberOfRows; ++n) {
-    distance.push(
-      Math.sqrt(
-        (xPointsVectorStrideAdjusted[n] - oneOffSetXPointsStrideAdjusted[n]) ** 2 +
-          (yPointsVectorStrideAdjusted[n] - oneOffSetYPointsStrideAdjusted[n]) ** 2
-      )
-    );
-  }
-  return distance;
-}
-
-function slopesOnCurveAtTVals(controlPointsMat, tVals) {
-  const [cpMatNumberOfRows] = controlPointsMat.size();
-
-  if (cpMatNumberOfRows === 2) {
-    const xPoints = [];
-    const yPoints = [];
-
-    controlPointsMat.forEach((value, [, col]) => {
-      switch (col) {
-        case 0: {
-          xPoints.push(value);
-          break;
-        }
-        case 1: {
-          yPoints.push(value);
-          break;
-        }
-        default: {
-          break;
-        }
-      }
-    });
-
-    const xDiff = xPoints[1] - xPoints[0];
-    const yDiff = yPoints[1] - yPoints[0];
-
-    const matrixRows = [];
-    const [tValsNumberOfRows] = tVals.size();
-    for (let i = 0; i < tValsNumberOfRows; i++) {
-      matrixRows.push([xDiff, yDiff]);
-    }
-
-    return math.matrix(matrixRows);
-  }
-
-  let fixedMat = null;
-  if (cpMatNumberOfRows === 3) {
-    fixedMat = quadraticDerivativeMatrix();
-  } else {
-    fixedMat = cubicDerivativeMatrix();
-  }
-
-  console.log({ tVals, fixedMat, controlPointsMat });
-
-  const slopeRatios = calculatedPointsOnCurve(tVals, controlPointsMat, fixedMat);
-
-  console.log({ slopeRatios });
-
-  return slopeRatios;
-}
-
-function calculatedPointsOnCurve(tValMatrix, controlPointsMatrix, fixedMatrix) {
-  return math.multiply(tValMatrix, fixedMatrix, controlPointsMatrix);
-}
-
-function splitBezierCurveAtTVal(controlPoints, tVal) {
-  switch (controlPoints.length) {
-    case 2:
-      return splitLinearBezierCurveAtTVal(controlPoints, tVal);
-    case 3:
-      return splitQuadraticCurveAtTVal(controlPoints, tVal);
-    case 4:
-      return splitCubicCurveAtTVal(controlPoints, tVal);
-    default:
-      return null;
-  }
-}
-
-function linearPointAtTVal(controlPoints, tVal) {
-  const [firstControlPoint] = controlPoints;
-  const lastControlPoint = [...controlPoints].pop();
-  const xt = firstControlPoint.x + (lastControlPoint.x - firstControlPoint.x) * tVal;
-  const yt = firstControlPoint.y + (lastControlPoint.y - firstControlPoint.y) * tVal;
-  return { y: yt, x: xt };
-}
-
-function splitLinearBezierCurveAtTVal(controlPoints, tVal) {
-  // Comment from prev dev:
-  // this could be faster by doing calculations directly.. but who cares
-  const midPoint = linearPointAtTVal(controlPoints, tVal);
-  return [
-    [controlPoints[0], midPoint],
-    [midPoint, [...controlPoints].pop()]
-  ];
-}
-
-function splitQuadraticCurveAtTVal(controlPoints, tVal) {
-  const firstTwoPoints = [controlPoints[0], controlPoints[1]];
-  const lastTwoPoints = [controlPoints[1], controlPoints[2]];
-  const control1 = linearPointAtTVal(firstTwoPoints, tVal);
-  const control2 = linearPointAtTVal(lastTwoPoints, tVal);
-  const breakPoint = linearPointAtTVal([control1, control2], tVal);
-  return [
-    [controlPoints[0], control1, breakPoint],
-    [breakPoint, control2, controlPoints[2]]
-  ];
-}
-
-function splitCubicCurveAtTVal(controlPoints, tVal) {
-  const firstTwoPoints = [controlPoints[0], controlPoints[1]];
-  const middleTwoPoints = [controlPoints[1], controlPoints[2]];
-  const lastTwoPoints = [controlPoints[2], controlPoints[3]];
-
-  const firstTwoMidPoint = linearPointAtTVal(firstTwoPoints, tVal);
-  const middleTwoMidPoint = linearPointAtTVal(middleTwoPoints, tVal);
-  const lastTwoMidPoint = linearPointAtTVal(lastTwoPoints, tVal);
-
-  const midPoint123 = linearPointAtTVal([firstTwoMidPoint, middleTwoMidPoint], tVal);
-  const midPoint234 = linearPointAtTVal([middleTwoMidPoint, lastTwoMidPoint], tVal);
-  const breakPoint = linearPointAtTVal([midPoint123, midPoint234], tVal);
-
-  return [
-    [controlPoints[0], firstTwoMidPoint, midPoint123, breakPoint],
-    [breakPoint, midPoint234, lastTwoMidPoint, controlPoints[3]]
-  ];
-}
-
-function firstTValForPointOnCurveOutsideCircle(controlPointsMat, anchorPoint, radius) {
-  const [numberOfRows] = controlPointsMat.size();
-  const helperMat = helperMatrixForDegree(numberOfRows - 1);
-  const pointsOnCurveMat = math.multiply(helperMat, controlPointsMat);
-  const distances = distancesFromPointToPoints(anchorPoint, pointsOnCurveMat);
-
-  // Comment from prev dev:
-  // We're assuming that point 0 is the closest to the anchor point... So we could use a binary search here to save a bit of time
-  // Chances are is that the tVal will actually be near the beginning however due to the way the function i used at this time
-
-  let indexOfPoint = distances.length - 1;
-  for (let i = 0; i < distances.length; i++) {
-    if (distances[i] >= radius) {
-      indexOfPoint = i;
-      break;
-    }
-  }
-
-  const tInc = 1.0 / sinusoidNumberOfPoints;
-  return indexOfPoint * tInc;
-}
-
-function distancesFromPointToPoints(anchorPoint, pointsOnCurveMat) {
-  const xPointAdjustFromOrigin = -anchorPoint.x;
-  const yPointAdjustFromOrigin = -anchorPoint.y;
-
-  const adjustedXPoints = [];
-  const adjustedYPoints = [];
-
-  pointsOnCurveMat.forEach((value, [, col]) => {
-    switch (col) {
-      case 0: {
-        adjustedXPoints.push(value + xPointAdjustFromOrigin);
-        break;
-      }
-      case 1: {
-        adjustedYPoints.push(value + yPointAdjustFromOrigin);
-        break;
-      }
-      default: {
-        break;
-      }
-    }
-  });
-
-  const distances = [];
-  for (let i = 0; i < adjustedXPoints.length; i++) {
-    distances.push(Math.sqrt(adjustedXPoints[i] * adjustedXPoints[i] + adjustedYPoints[i] * adjustedYPoints[i]));
-  }
-  return distances;
-}
-
-function helperMatrixForDegree(degree) {
-  switch (degree) {
-    case 1: {
-      return linearHelperMatrix();
-    }
-    case 2: {
-      return quadraticHelperMatrix();
-    }
-    case 3: {
-      return cubicHelperMatrix();
-    }
-    default: {
-      return null;
-    }
-  }
-}
-
-function preCalculatedTMatrixForDegree(degree) {
-  switch (degree) {
-    case 1: {
-      return linearTMatSinusoid();
-    }
-    case 2: {
-      return quadraticTMatSinusoid();
-    }
-    case 3: {
-      return cubicTMatSinusoid();
-    }
-    default: {
-      return null;
-    }
-  }
-}
-
-function linearBezierMatrix() {
-  return math.matrix([
-    [1, 0],
-    [-1, 1]
-  ]);
-}
-
-function quadraticBezierMatrix() {
-  return math.matrix([
-    [1, 0, 0],
-    [-2, 2, 0],
-    [1, -2, 1]
-  ]);
-}
-
-function cubicBezierMatrix() {
-  return math.matrix([
-    [1, 0, 0, 0],
-    [-3, 3, 0, 0],
-    [3, -6, 3, 0],
-    [-1, 3, -3, 1]
-  ]);
-}
-
-function cubicDerivativeMatrix() {
-  return math.matrix([
-    [-3, 3, 0, 0],
-    [6, -12, 6, 0],
-    [-3, 9, -9, 3],
-    [0, 0, 0, 0]
-  ]);
-}
-
-function quadraticDerivativeMatrix() {
-  return math.matrix([
-    [-2, 2, 0],
-    [2, -4, 2],
-    [0, 0, 0]
-  ]);
-}
-
-function linearHelperMatrix() {
-  return math.multiply(linearTMatSinusoid(), linearBezierMatrix());
-}
-
-function quadraticHelperMatrix() {
-  return math.multiply(quadraticTMatSinusoid(), quadraticBezierMatrix());
-}
-function cubicHelperMatrix() {
-  return math.multiply(cubicTMatSinusoid(), cubicBezierMatrix());
-}
-
-function linearTMatSinusoid() {
-  return tMatrixForEvenlyDistributedTValues(sinusoidNumberOfPoints, 1);
-}
-
-function quadraticTMatSinusoid() {
-  return tMatrixForEvenlyDistributedTValues(sinusoidNumberOfPoints, 2);
-}
-
-function cubicTMatSinusoid() {
-  return tMatrixForEvenlyDistributedTValues(sinusoidNumberOfPoints, 3);
-}
-
-function tMatrixForEvenlyDistributedTValues(numberOfPoints, degreeOfCurve) {
-  const increment = 1.0 / numberOfPoints;
-  let tVal = 0;
-  const returnArray = math.ones(numberOfPoints + 1, degreeOfCurve + 1).map((value, [, col]) => {
-    let resVal = null;
-    switch (col) {
-      case 0: {
-        resVal = 1.0;
-        break;
-      }
-      case 1: {
-        resVal = tVal;
-        break;
-      }
-      case 2: {
-        resVal = tVal * tVal;
-        break;
-      }
-      case 3: {
-        resVal = tVal * tVal * tVal;
-        break;
-      }
-      default: {
-        break;
-      }
-    }
-    tVal += increment;
-    return resVal;
-  });
-
-  return math.matrix(returnArray);
-}
-
-function controlPointsMatFromPoints(controlPoints) {
-  const controlPointsVec = controlPoints.map(cp => {
-    return [cp.x, cp.y];
-  });
-  return math.matrix(controlPointsVec);
-}
-
-module.exports.bezierBoundingBox = function(controlPoints) {
-  if (![2, 4].includes(controlPoints.length)) {
-    throw new Error('bezierBoundingBox function supports only linear and cubic bezier curves for now');
-  }
-
-  const bMinMax = controlPoints.length === 2 ? linearBezierMinMax(controlPoints) : cubicBezierMinMax(controlPoints);
-
-  // Extend bounding box for straight lines
-  const yAxisOffset = controlPoints.length === 2 ? 1 : 0;
-
-  return [
-    {
-      x: bMinMax.min.x,
-      y: bMinMax.min.y - yAxisOffset
-    },
-    {
-      x: bMinMax.max.x,
-      y: bMinMax.min.y - yAxisOffset
-    },
-    {
-      x: bMinMax.max.x,
-      y: bMinMax.max.y + yAxisOffset
-    },
-    {
-      x: bMinMax.min.x,
-      y: bMinMax.max.y + yAxisOffset
-    }
-  ];
-};
-
-function linearBezierMinMax([p0, p1]) {
-  const xValues = [p0.x, p1.x];
-  const yValues = [p0.y, p1.y];
-  return {
-    min: { x: Math.min.apply(0, xValues), y: Math.min.apply(0, yValues) },
-    max: { x: Math.max.apply(0, xValues), y: Math.max.apply(0, yValues) }
-  };
-}
-
-function cubicBezierMinMax([p0, p1, p2, p3]) {
-  const tValues = [];
-  const xValues = [];
-  const yValues = [];
-  let a;
-  let b;
-  let c;
-  let t;
-  let t1;
-  let t2;
-  let b2ac;
-  let sqrtb2ac;
-  for (let i = 0; i < 2; ++i) {
-    if (i === 0) {
-      b = 6 * p0.x - 12 * p1.x + 6 * p2.x;
-      a = -3 * p0.x + 9 * p1.x - 9 * p2.x + 3 * p3.x;
-      c = 3 * p1.x - 3 * p0.x;
-    } else {
-      b = 6 * p0.y - 12 * p1.y + 6 * p2.y;
-      a = -3 * p0.y + 9 * p1.y - 9 * p2.y + 3 * p3.y;
-      c = 3 * p1.y - 3 * p0.y;
-    }
-    if (Math.abs(a) < 1e-12) {
-      if (Math.abs(b) < 1e-12) {
-        continue;
-      }
-      t = -c / b;
-      if (t > 0 && t < 1) {
-        tValues.push(t);
-      }
-      continue;
-    }
-    b2ac = b * b - 4 * c * a;
-    if (b2ac < 0) {
-      if (Math.abs(b2ac) < 1e-12) {
-        t = -b / (2 * a);
-        if (t > 0 && t < 1) {
-          tValues.push(t);
-        }
-      }
-      continue;
-    }
-    sqrtb2ac = Math.sqrt(b2ac);
-    t1 = (-b + sqrtb2ac) / (2 * a);
-    if (t1 > 0 && t1 < 1) {
-      tValues.push(t1);
-    }
-    t2 = (-b - sqrtb2ac) / (2 * a);
-    if (t2 > 0 && t2 < 1) {
-      tValues.push(t2);
-    }
-  }
-
-  let j = tValues.length;
-  let mt;
-  while (j--) {
-    t = tValues[j];
-    mt = 1 - t;
-    xValues[j] = mt * mt * mt * p0.x + 3 * mt * mt * t * p1.x + 3 * mt * t * t * p2.x + t * t * t * p3.x;
-    yValues[j] = mt * mt * mt * p0.y + 3 * mt * mt * t * p1.y + 3 * mt * t * t * p2.y + t * t * t * p3.y;
-  }
-
-  xValues.push(p0.x, p3.x);
-  yValues.push(p0.y, p3.y);
-
-  return {
-    min: { x: Math.min.apply(0, xValues), y: Math.min.apply(0, yValues) },
-    max: { x: Math.max.apply(0, xValues), y: Math.max.apply(0, yValues) }
-  };
-}

package/src/models/Base/InternalFrameModel.js

@@ -1,20 +0,0 @@
-class Model {
-  constructor(data) {
-    this.originalData = JSON.parse(JSON.stringify(data));
-    this.adjustedData = JSON.parse(JSON.stringify(data));
-  }
-
-  _getAttrOriginal(attr) {
-    return typeof this.originalData[attr] !== 'undefined' ? this.originalData[attr] : null;
-  }
-
-  _getAttr(attr) {
-    return typeof this.adjustedData[attr] !== 'undefined' ? this.adjustedData[attr] : null;
-  }
-
-  _setAttr(attr, value) {
-    this.adjustedData[attr] = value;
-  }
-}
-
-module.exports = Model;

package/src/models/Play/Options.js

@@ -1,31 +0,0 @@
-module.exports = {
-  useDefaults: function(options = {}) {
-    const defaults = {
-      width: 300,
-      lineColor: '#fff', // courtBorderColor
-      linesDisplay: true,
-      linesDisplayOnMoveOnly: true,
-      linesHiddenIds: [],
-      linesSelectedIds: [],
-      shapeSelectedId: null,
-      noteSelectedId: null,
-      playersHiddenPositions: [],
-      background: '',
-      watermark: null,
-      mirror: false,
-      speed: 1,
-      position: null,
-      huddleMode: false,
-      magnetMode: false,
-      flipPlayerLabels: false,
-      legacyPrintStyle: false,
-      playerTokenScale: 1,
-      // TODO: refactor NBA court type constants below
-      showHalfCourtCircle: true
-    };
-    return {
-      ...defaults,
-      ...options
-    };
-  }
-};

package/src/models/Play.js

@@ -1,91 +0,0 @@
-const _ = require('lodash');
-const { loadImage } = require('canvas');
-const playerHatsConfig = require('../playerHatsConfig');
-const shapesConfig = require('../shapesConfig');
-const { useDefaults } = require('./Play/Options');
-const {
-  SPORT_TYPE_BASKETBALL,
-  SPORT_TYPE_VOLLEYBALL,
-  SPORT_TYPE_FOOTBALL,
-  SPORT_TYPE_LACROSSE,
-  SPORT_TYPE_SOCCER,
-  SPORT_TYPE_HOCKEY,
-  SPORT_TYPE_BASEBALL
-} = require('../constants');
-
-const STORAGE_URL = 'https://playbooksstore.blob.core.windows.net/public';
-const LUCEOSPORTS_WATERMARK_PATH = 'partners/LuceoSports/luceo-sports-logo-powered-by-sm.png';
-
-class Play {
-  constructor(data, options = {}) {
-    this.name = data.name;
-    this.options = useDefaults(options);
-    this.setPlayData(data.playData);
-  }
-
-  static async init({ teamLogoPath = '' } = {}) {
-    Play.playerHats = await playerHatsConfig();
-    Play.shapes = await shapesConfig();
-
-    const hardwoodImageData = require('../assets/wood_bg.png');
-    const hardwoodImage = await loadImage(hardwoodImageData);
-    const grassImageData = require('../assets/grass_bg.png');
-    const grassImage = await loadImage(grassImageData);
-    const iceImageData = require('../assets/ice_bg.png');
-    const iceImage = await loadImage(iceImageData);
-
-    Play.backgroundOptions = {
-      Hardwood: hardwoodImage,
-      [SPORT_TYPE_BASKETBALL]: hardwoodImage,
-      [SPORT_TYPE_VOLLEYBALL]: hardwoodImage,
-      [SPORT_TYPE_FOOTBALL]: grassImage,
-      [SPORT_TYPE_LACROSSE]: grassImage,
-      [SPORT_TYPE_SOCCER]: grassImage,
-      [SPORT_TYPE_HOCKEY]: iceImage,
-      [SPORT_TYPE_BASEBALL]: grassImage
-    };
-
-    const luceoSportsWatermark = await loadImage(`${STORAGE_URL}/${LUCEOSPORTS_WATERMARK_PATH}`);
-    const teamLogoWatermark = teamLogoPath ? await loadImage(`${STORAGE_URL}/${teamLogoPath}`) : null;
-    Play.watermark = {
-      LuceoSports: luceoSportsWatermark,
-      TeamLogo: teamLogoWatermark
-    };
-  }
-
-  get totalPhasesCount() {
-    const distinctPhases = _.uniq(_.map(this.playData.lines, 'phase'));
-    return distinctPhases.length || 1;
-  }
-
-  get scale() {
-    return this.options.width / this.playData.court.courtRect.size.width;
-  }
-
-  get width() {
-    return this.options.width;
-  }
-
-  get height() {
-    return Math.ceil(this.playData.court.courtRect.size.height * this.scale);
-  }
-
-  get staticData() {
-    return {
-      backgroundOptions: Play.backgroundOptions,
-      watermark: Play.watermark,
-      playerHats: Play.playerHats,
-      shapes: Play.shapes
-    };
-  }
-
-  setOptions(options) {
-    this.options = { ...this.options, ...options };
-  }
-
-  setPlayData(playData) {
-    this.playData = playData;
-  }
-}
-
-module.exports = Play;