Rework bucket formation logic

Author: noahm

Diff for: src/card-draw.ts

@@ -1,8 +1,9 @@
 import { nanoid } from "nanoid";
 import { GameData, Song, Chart } from "./models/SongData";
-import { chunkInPieces, pickRandomItem, shuffle, times } from "./utils";
+import { pickRandomItem, shuffle, times } from "./utils";
 import { CountingSet } from "./utils/counting-set";
 import { DefaultingMap } from "./utils/defaulting-set";
+import { Fraction } from "./utils/fraction";
 import { DrawnChart, EligibleChart, Drawing } from "./models/Drawing";
 import { ConfigState } from "./config-state";
 import { getDifficultyColor } from "./hooks/useDifficultyColor";
@@ -12,6 +13,15 @@ import {
   getDiffAbbr,
 } from "./game-data-utils";
 
+function clampToNearest(incr: number, n: number, clamp: (n: number) => number) {
+  const multor = Math.round(1 / incr);
+  let ret = clamp(n * multor) / multor;
+  if (Number.isInteger(n) && clamp === Math.floor) {
+    ret -= incr;
+  }
+  return ret;
+}
+
 export function getDrawnChart(
   gameData: GameData,
   currentSong: Song,
@@ -67,9 +77,8 @@ export function chartIsValid(
 }
 
 export function* eligibleCharts(config: ConfigState, gameData: GameData) {
-  const buckets = getBuckets(
-    config,
-    getAvailableLevels(gameData, config.useGranularLevels),
+  const buckets = Array.from(
+    getBuckets(config, getAvailableLevels(gameData, config.useGranularLevels)),
   );
   for (const currentSong of gameData.songs) {
     if (!songIsValid(config, currentSong)) {
@@ -105,37 +114,50 @@ export function* eligibleCharts(config: ConfigState, gameData: GameData) {
 
 export type LevelRangeBucket = [low: number, high: number];
 export type BucketLvlRanges = Array<LevelRangeBucket>;
-export type LvlRanges = Array<number> | BucketLvlRanges;
+export type LvlRanges = Array<number | LevelRangeBucket>;
 
 /**
  *
  * @param cfg
  * @param availableLvls prefer granular
  * @returns
  */
-export function getBuckets(
+export function* getBuckets(
   cfg: Pick<
     ConfigState,
     "useWeights" | "probabilityBucketCount" | "upperBound" | "lowerBound"
   >,
   availableLvls: Array<number>,
-): LvlRanges {
+): Generator<LevelRangeBucket | number> {
   const { useWeights, probabilityBucketCount, upperBound, lowerBound } = cfg;
   const absoluteRangeSize = upperBound - lowerBound + 1;
   if (!useWeights || !probabilityBucketCount) {
-    return times(absoluteRangeSize, (n) => n - 1 + lowerBound);
+    for (let n = lowerBound; n <= upperBound; n++) {
+      yield n;
+    }
+    return;
   }
-  const lowerIndex = availableLvls.indexOf(lowerBound);
+  const bucketWidth = new Fraction(absoluteRangeSize, probabilityBucketCount);
   let upperIndex: number | undefined = availableLvls.indexOf(upperBound + 1);
   if (upperIndex === -1) {
     upperIndex = undefined;
   }
-  const levelsInRange = availableLvls.slice(lowerIndex, upperIndex);
-  return Array.from(chunkInPieces(probabilityBucketCount, levelsInRange)).map(
-    (levels): LevelRangeBucket => {
-      return [levels[0], levels[levels.length - 1]];
-    },
-  );
+  // TODO add this to the data file spec
+  const incrementGuess = availableLvls[1] - availableLvls[0];
+  const lowerBoundF = new Fraction(lowerBound);
+  const nudge = new Fraction(1, 1000);
+  for (let i = 0; i < probabilityBucketCount; i++) {
+    const bucketBottom = bucketWidth.mult(new Fraction(i)).add(lowerBoundF);
+    const bucketTop = bucketBottom.add(bucketWidth);
+    yield [
+      clampToNearest(incrementGuess, bucketBottom.valueOf(), Math.ceil),
+      clampToNearest(
+        incrementGuess,
+        bucketTop.sub(nudge).valueOf(),
+        Math.floor,
+      ),
+    ];
+  }
 }
 
 /**
@@ -184,7 +206,10 @@ export function draw(gameData: GameData, configData: ConfigState): Drawing {
 
   for (const chart of eligibleCharts(configData, gameData)) {
     const bucketIdx = useWeights
-      ? bucketIndexForLvl(chartLevelOrTier(chart, useGranularLevels), buckets)
+      ? bucketIndexForLvl(
+          chartLevelOrTier(chart, useGranularLevels),
+          Array.from(buckets),
+        )
       : 0; // outside of weights mode we just put all songs into one shared bucket
     if (bucketIdx === null) continue;
     validCharts.get(bucketIdx).push(chart);

Diff for: src/controls/controls-weights.tsx

@@ -52,14 +52,16 @@ export function WeightsControls({ usesTiers, high, low }: Props) {
   const gameData = useDrawState((s) => s.gameData);
   const groups = useMemo(() => {
     const availableLevels = getAvailableLevels(gameData, useGranularLevels);
-    return getBuckets(
-      {
-        lowerBound: low,
-        upperBound: high,
-        useWeights,
-        probabilityBucketCount: bucketCount,
-      },
-      availableLevels,
+    return Array.from(
+      getBuckets(
+        {
+          lowerBound: low,
+          upperBound: high,
+          useWeights,
+          probabilityBucketCount: bucketCount,
+        },
+        availableLevels,
+      ),
     );
   }, [gameData, useGranularLevels, low, high, useWeights, bucketCount]);
 

Diff for: src/utils/fraction.ts

@@ -0,0 +1,64 @@
+function gcd(a: number, b: number) {
+  if (!a) return b;
+  if (!b) return a;
+  while (true) {
+    a %= b;
+    if (!a) return b;
+    b %= a;
+    if (!b) return a;
+  }
+}
+
+/*********
+ * This is a port of the bare minimum functionality from the 'fraction.js'
+ * npm package to suit the needs of dealing with fractional beat offsets.
+ * The original package has types written in a strange way that doesn't make
+ * typescript happy when in pure ESM mode.
+ *
+ * This file and the original implementation are available under the MIT license.
+ * See: https://github.com/infusion/Fraction.js/blob/master/fraction.js
+ *********/
+export class Fraction {
+  constructor(
+    public n: number,
+    public d: number = 1,
+  ) {}
+
+  add(f: Fraction) {
+    if (f.d === this.d) {
+      return new Fraction(this.n + f.n, this.d);
+    }
+    return new Fraction(this.n * f.d + this.d * f.n, this.d * f.d).simplify();
+  }
+
+  sub(f: Fraction) {
+    return this.add(f.mult(negativeOne));
+  }
+
+  mult(f: Fraction) {
+    return new Fraction(this.n * f.n, this.d * f.d).simplify();
+  }
+
+  mod(f: Fraction) {
+    return new Fraction((f.d * this.n) % (f.n * this.d), f.d * this.d);
+  }
+
+  simplify() {
+    const reduceBy = gcd(this.n, this.d);
+    return new Fraction(this.n / reduceBy, this.d / reduceBy);
+  }
+
+  valueOf() {
+    return this.n / this.d;
+  }
+
+  toFixed(digits?: number) {
+    return this.valueOf().toFixed(digits);
+  }
+
+  toString() {
+    return this.valueOf().toString();
+  }
+}
+
+const negativeOne = new Fraction(-1);