const clamp = (vmin, vmax, v) => Math.max(vmin, Math.min(v, vmax));
const lerp = (x, y, a) => x * (1 - a) + y * a;
const invlerp = (x, y, a) => clamp(0, 1,(a - x) / (y - x));
const range = (x1, y1, x2, y2, a) => lerp(x2, y2, invlerp(x1, y1, a));
const rand = (min, max) => min + (max-min)*Math.random();
const round = (number, count = 3) => +(Math.round(number + "e+" + count)  + "e-" + count);

// Use the default seeded random instance (seed = 42)
const x = seededRandom.range(0, CANVAS_WIDTH);
const y = seededRandom.range(0, CANVAS_HEIGHT);

// Create a new instance with a custom seed
const myRandom = new SeededRandom(123);
const randomColor = myRandom.choice(['red', 'blue', 'green', 'yellow']);

// Generate random integers
const randomSize = myRandom.int(10, 50);

// Generate booleans
const shouldShow = myRandom.bool(0.3); // 30% chance of being true

// Shuffle an array
const shuffledArray = myRandom.shuffle([1, 2, 3, 4, 5]);

// Create multiple circles with seeded positions
for (let i = 0; i < 10; i++) {
  const circle = new Shape.Circle({
    center: [seededRandom.range(50, 450), seededRandom.range(50, 350)],
    radius: seededRandom.int(5, 25),
    fillColor: seededRandom.choice(['red', 'blue', 'green'])
  });
}

function shuffle(array) {
  return array.map(value => ({ value, sort: Math.random() })).sort((a, b) => a.sort - b.sort).map(({ value }) => value);
}

// or use seededRandom.shuffle(array)
const shuffledArray = seededRandom.shuffle(array);

function cutText(text, charactersNumber = 50) {
  const len = text.length;
  const iterationNumber = Math.floor(len/charactersNumber);
  
  if (iterationNumber == 0) {
    return text;
  }
  
  let result = '';
  let tmpText = text;

  for (let i = 0; i < iterationNumber; i++) {
    const t = tmpText.substring(charactersNumber).indexOf(" ");
    const k = charactersNumber + Math.max(1, t);
    result += t > 0 ? tmpText.substring(0, k) + '
' : tmpText.substring(0, k);
    tmpText = t > 0 ? tmpText.substring(k+1) : tmpText.substring(k);
  }
  result += tmpText;

  return result;
}

const ALLOW_VIBRATION = true;
function rumble(gpIdx = 0, {duration = 100, weakMagnitude = 1, strongMagnitude = 1}) {
  if (ALLOW_VIBRATION) {
    navigator.getGamepads()[gpIdx].vibrationActuator.playEffect("dual-rumble", {
      startDelay: 0,
      duration: duration,
      weakMagnitude: weakMagnitude,
      strongMagnitude: strongMagnitude,
    });
  }
}

const text = new PointText({
  point: [50, 50],
  content: 'Lorem ipsum',
  fillColor: 'black',
  fontFamily: 'Courier New',
  fontWeight: 'bold',
  fontSize: 25
});

const path = new Path({
  segments: [[20, 20], [80, 80], [140, 20]],
  fillColor: 'black',
  strokeColor: 'red',
  strokeWidth: 20,
  strokeCap: 'round',
  closed: true
});

const path = new Path.Circle({
  center: [80, 50],
  radius: 30,
  strokeColor: 'black'
});

const path = new Path.Line({
  from: [20, 20],
  to: [80, 80],
  strokeColor: 'black'
});

const path = new Path.Rectangle({
  point: [20, 20],
  size: [60, 60],
  strokeColor: 'black'
});

const shape = new Shape.Circle({
  center: [80, 50],
  radius: 30,
  strokeColor: 'black'
});

const shape = new Shape.Rectangle({
  point: [20, 20],
  size: [60, 60],
  strokeColor: 'black'
});

item.tweenTo(
  { position: [0, 0] },
  {
    duration: 100,
    easing: 'linear', 
  }
);

// All the easing options are: linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeInQuint, easeOutQuint, easeInOutQuint

const intersectionsGroup = new Group();
function showIntersections(path1, path2) {
  var intersections = path1.getIntersections(path2);
  for (var i = 0; i < intersections.length; i++) {
    const path = new Path.Circle({
        center: intersections[i].point,
        radius: 5,
        fillColor: '#FFD700'
    });
    intersectionsGroup.addChild(path);
  }
}