@xforge-dev/forge-kit 0.24.1 → 0.24.3

package/README.md

@@ -132,7 +132,9 @@ the lowercased name without spaces, so a stored board never holds names.
 ### Legion Points (GMS v.272)
 
 v.272 removes the board. The points model sits beside it (the board stays for app versions still reading it):
-`legionPoints` (the automatic raid's ranks, B 1 … SSS 5, as many members as the Legion rank holds), stat levels
+`legionPoints` (the automatic raid's ranks, B 1 … SSS 5, as many members as the Legion rank holds; `raidSplit` gives
+those and the bonus-only rest, since every member at rank B or higher gives its effect: `effectMembers`; pass the
+owned event blocks and the two equipped ones add a member's points of their rank each: `legionPointsBreakdown`), stat levels
 (`LegionStats`, one point a level, what a grid square was: same values, caps 15 inner and 40 outer),
 `allocationProblem`, `statTotals`, `suggestStats`, the two highest event blocks (`appliedEventBlocks`), 10 named
 presets (`SharedPoints`, stored under `points` in the shared row so an older board write leaves it alone) and the 5th

package/dist/legion.d.ts

@@ -211,10 +211,31 @@ export type PointsMember = {
  * The caller works out ranks (Zero's own levels) and Legion level.
  */
 export declare function raidComposition<M extends PointsMember>(members: readonly M[], legionLevel: number): M[];
+/**
+ * The Legion split in two: `counted`, the members the raid takes (their ranks are the Legion Points), and `bonus`, the
+ * other members at rank B or higher, whose effects apply too but who give no points. Members below B are in neither.
+ */
+export declare function raidSplit<M extends PointsMember>(members: readonly M[], legionLevel: number): {
+    counted: M[];
+    bonus: M[];
+};
+/** Members whose effects apply: every member at rank B or higher, counted by the raid or not. */
+export declare const effectMembers: <M extends PointsMember>(members: readonly M[]) => M[];
 /** The two event blocks that apply: the highest values among those owned. */
 export declare function appliedEventBlocks(owned: readonly EventBlock[]): EventBlock[];
-/** Legion Points to spend: the ranks of the members the raid counts. Event blocks add ATT, not points. */
-export declare function legionPoints(members: readonly PointsMember[], legionLevel: number): number;
+/** Legion Points an equipped event block gives: a member's of its rank (B 1 … SSS 5; Ride or Die is SSS, as on the board). */
+export declare const eventBlockPoints: (b: EventBlock) => number;
+/** Legion Points split: the members the raid counts, and the two equipped event blocks (the two highest owned). */
+export declare function legionPointsBreakdown(members: readonly PointsMember[], legionLevel: number, blocks?: readonly EventBlock[]): {
+    members: number;
+    blocks: number;
+    total: number;
+};
+/**
+ * Legion Points to spend: the ranks of the members the raid counts, plus the two equipped event blocks' (a member's of
+ * the same rank each; they don't take a member's place). Their ATT is separate.
+ */
+export declare function legionPoints(members: readonly PointsMember[], legionLevel: number, blocks?: readonly EventBlock[]): number;
 /** Points the stat levels spend. */
 export declare const pointsSpent: (stats: LegionStats) => number;
 /** What each stat gives at its level (only stats with a level). */

package/dist/legion.js

@@ -227,8 +227,9 @@ export function legionLevelRank(level) {
 /** Members the automatic Legion Raid takes at this Legion level (Nameless I's 9 below it). */
 export const raidMembers = (level) => (legionLevelRank(level) ?? LEGION_LEVEL_RANKS[0]).members;
 // The rules are the board's, without the board: a stat level is what a grid square was (same value per level, the
-// same caps: inner stats 15, outer stats 40, open from the start as every area was), and only the members the raid
-// counts (the top members by Legion level, as the board's slots were) give points and their effects.
+// same caps: inner stats 15, outer stats 40, open from the start as every area was). Every member at rank B or higher
+// gives its effect; only the members the raid counts (the top members by level, as many as the board's slots were)
+// give points.
 /** What one level of each stat gives: a grid square's value. */
 export const STAT_PER_LEVEL = { ...GRID_PER_SQUARE };
 /** Each stat's highest level: its grid area's size. */
@@ -245,13 +246,35 @@ export const statUnlocked = (k, legionLevel) => statCap(k, legionLevel) > 0;
 export function raidComposition(members, legionLevel) {
     return members.filter((m) => m.rank).sort((a, b) => b.level - a.level).slice(0, raidMembers(legionLevel));
 }
+/**
+ * The Legion split in two: `counted`, the members the raid takes (their ranks are the Legion Points), and `bonus`, the
+ * other members at rank B or higher, whose effects apply too but who give no points. Members below B are in neither.
+ */
+export function raidSplit(members, legionLevel) {
+    const counted = raidComposition(members, legionLevel);
+    const taken = new Set(counted);
+    return { counted, bonus: members.filter((m) => m.rank && !taken.has(m)).sort((a, b) => b.level - a.level) };
+}
+/** Members whose effects apply: every member at rank B or higher, counted by the raid or not. */
+export const effectMembers = (members) => members.filter((m) => m.rank);
 /** The two event blocks that apply: the highest values among those owned. */
 export function appliedEventBlocks(owned) {
     return [...owned].sort((a, b) => b.value - a.value).slice(0, MAX_EVENT_BLOCKS);
 }
-/** Legion Points to spend: the ranks of the members the raid counts. Event blocks add ATT, not points. */
-export function legionPoints(members, legionLevel) {
-    return raidComposition(members, legionLevel).reduce((t, m) => t + RANK_POINTS[m.rank], 0);
+/** Legion Points an equipped event block gives: a member's of its rank (B 1 … SSS 5; Ride or Die is SSS, as on the board). */
+export const eventBlockPoints = (b) => eventBlockSquares(b);
+/** Legion Points split: the members the raid counts, and the two equipped event blocks (the two highest owned). */
+export function legionPointsBreakdown(members, legionLevel, blocks = []) {
+    const m = raidComposition(members, legionLevel).reduce((t, x) => t + RANK_POINTS[x.rank], 0);
+    const b = appliedEventBlocks(blocks).reduce((t, x) => t + eventBlockPoints(x), 0);
+    return { members: m, blocks: b, total: m + b };
+}
+/**
+ * Legion Points to spend: the ranks of the members the raid counts, plus the two equipped event blocks' (a member's of
+ * the same rank each; they don't take a member's place). Their ATT is separate.
+ */
+export function legionPoints(members, legionLevel, blocks = []) {
+    return legionPointsBreakdown(members, legionLevel, blocks).total;
 }
 /** Points the stat levels spend. */
 export const pointsSpent = (stats) => Object.values(stats).reduce((t, n) => t + (n ?? 0), 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xforge-dev/forge-kit",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "description": "Shared auth, app registry and UI for xForge apps",
   "license": "MIT",
   "repository": {