Pre-balanced. A fixed list of six scores. Pick a tier, then drag each
score down into an ability — or click a chip below and then click an ability slot.
setSel({ kind:"row", index: r })}
title={`Row ${r+1}`}>R{r+1}
{row.map((v, c) => (
{
// click toggles which dimension to select
const cs = sel;
if (cs.kind === "row" && cs.index !== r) setSel({kind:"row", index:r});
else if (cs.kind === "col" && cs.index !== c) setSel({kind:"col", index:c});
else setSel({kind:"row", index:r});
}}>{v}
))}
))}
{[0,1,2,3,4,5].map(c => (
setSel({kind:"col", index: c})}>C{c+1}
))}
Click any row label (R), column label (C), or a diagonal button to select a 6-score
array, in order. The arrays are intended to be used in order, but
Free Assign lets you place them where you like.
);
}
// ============================================================
// Method V — 3d6 / VI — 4d6 drop lowest / V&VI alternatives
// ============================================================
function MethodDice({ kind, onPool, onAssignment, onMethodNote, generateKey }) {
// kind: "3d6" | "4d6" | "5d6" (drop two lowest)
// Two independent toggles:
// rollStyle: standard | best7 | rerolllow | bestoftwo
// assignStyle: assign | inorder
const [rollStyle, setRollStyle] = React.useState("standard");
const [assignStyle, setAssignStyle] = React.useState("assign");
const [sets, setSets] = React.useState(null);
const roll = React.useCallback(() => {
let s;
const makeSet = () => {
if (kind === "3d6") {
const r = ASG.rollDice(3, 6);
return { dice: r, kept: r, dropped: [], score: ASG.sumD(r) };
} else if (kind === "4d6") {
const r = ASG.rollDice(4, 6);
const sorted = r.slice().sort((a,b) => b-a);
return { dice: r, kept: sorted.slice(0,3), dropped: [sorted[3]], score: ASG.sumD(sorted.slice(0,3)) };
} else { // 5d6
const r = ASG.rollDice(5, 6);
const sorted = r.slice().sort((a,b) => b-a);
return { dice: r, kept: sorted.slice(0,3), dropped: sorted.slice(3), score: ASG.sumD(sorted.slice(0,3)) };
}
};
if (rollStyle === "best7") {
const seven = [];
for (let i = 0; i < 7; i++) seven.push(makeSet());
seven.sort((a,b) => b.score - a.score);
s = seven.slice(0, 6);
} else if (rollStyle === "bestoftwo") {
const A = []; const B = [];
for (let i = 0; i < 6; i++) { A.push(makeSet()); B.push(makeSet()); }
const sa = A.reduce((x,y) => x+y.score, 0);
const sb = B.reduce((x,y) => x+y.score, 0);
s = sa >= sb ? A : B;
} else {
s = [];
for (let i = 0; i < 6; i++) s.push(makeSet());
if (rollStyle === "rerolllow") {
s.sort((a,b) => a.score - b.score);
s[0] = makeSet();
}
}
setSets(s);
}, [kind, rollStyle]);
React.useEffect(() => { roll(); }, [rollStyle, kind, generateKey]);
React.useEffect(() => {
if (!sets) return;
if (assignStyle === "inorder") {
onPool([]);
onAssignment(Object.fromEntries(ABILS.map((a, i) => [a, sets[i].score])));
} else {
onPool(sets.map(s => ({
id: uid(),
value: s.score,
detail: `${s.kept.join("+")}${s.dropped && s.dropped.length ? " (drop " + s.dropped.join(",") + ")" : ""}`
})));
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
}
const lbl = {
"3d6": "3d6",
"4d6": "4d6 drop lowest",
"5d6": "5d6 drop two lowest"
}[kind];
const rsLbl = ({
standard: "standard roll",
best7: "7 sets, keep 6 best",
rerolllow: "reroll the lowest",
bestoftwo: "best of two arrays"
})[rollStyle];
const asLbl = assignStyle === "inorder" ? "in order" : "assign as you wish";
onMethodNote(`${lbl} · ${rsLbl} · ${asLbl}`);
}, [sets, assignStyle]);
return (
Roll Style
{[
["standard", "Standard"],
["best7", "Best 6 of 7"],
["rerolllow", "Reroll Lowest"],
["bestoftwo", "Best of Two"]
].map(([v,l]) => (
))}
Assignment
{sets && (
{sets.map((s, i) => (
{(i+1).toString().padStart(2,"0")}
{
// find indices that are in kept array (but only once each)
const taken = new Set();
return s.kept.find((kd, ki) => kd === d && !taken.has(idx) && (taken.add(idx), true)) ? idx : null;
}).filter(x => x !== null)}
drop={s.dice.map((d, idx) => {
// mark dice not in `kept` (lowest ones)
const sorted = s.dice.slice().sort((a,b) => a-b);
const dropCount = s.dice.length - 3;
const dropSet = sorted.slice(0, dropCount);
return dropSet.includes(d) ? idx : null;
}).filter(x => x !== null)} />
{s.score}
))}
)}
);
}
// ============================================================
// Method VII — Dice Pool
// ============================================================
function MethodDicePool({ onPool, onAssignment, onMethodNote, generateKey }) {
const [poolSize, setPoolSize] = React.useState(18);
const [dice, setDice] = React.useState(null); // pool of die values
// Partition: 6 buckets, each holds up to 3 die indices.
// A die index not present in any bucket is "in the pool".
const [partition, setPartition] = React.useState(() => [[],[],[],[],[],[]]);
const [pickedDie, setPickedDie] = React.useState(null); // die index currently held
const roll = React.useCallback(() => {
const d = ASG.rollDice(poolSize, 6);
setDice(d);
setPartition([[],[],[],[],[],[]]);
setPickedDie(null);
}, [poolSize]);
React.useEffect(() => { roll(); }, [poolSize, generateKey]);
const used = new Set(partition.flat());
// Remove dieIdx from wherever it currently is; return a fresh partition.
const removeFromAny = (part, dieIdx) =>
part.map(s => s.filter(i => i !== dieIdx));
// Click a die (anywhere). Toggles "picked".
// - If no die is picked: pick this one up.
// - If THIS die is already picked: drop it back to the pool (unpick).
// - If a DIFFERENT die is picked: swap selection to this one (so users can change their mind mid-move).
const onClickDie = (dieIdx) => {
if (pickedDie === dieIdx) {
// already picked → put it back where it was AND unpick (returns to pool if it was in a slot)
setPartition(p => removeFromAny(p, dieIdx));
setPickedDie(null);
return;
}
setPickedDie(dieIdx);
};
// Click a slot. If a die is picked, move it there (from wherever it currently lives).
const placeIn = (slot) => {
if (pickedDie == null) return;
if (partition[slot].length >= 3 && !partition[slot].includes(pickedDie)) return;
// Remove from any other slot first
let next = removeFromAny(partition, pickedDie);
// If it was already in `slot`, we just removed it — that's "move back to pool".
// If not, place it.
if (!partition[slot].includes(pickedDie)) {
next = next.map((s, i) => i === slot ? s.concat([pickedDie]) : s);
}
setPartition(next);
setPickedDie(null);
};
// Click the pool area background — return picked die (from a slot) to the pool.
const sendToPool = () => {
if (pickedDie == null) return;
setPartition(p => removeFromAny(p, pickedDie));
setPickedDie(null);
};
const clearSlot = (slot) => {
const next = partition.map((s, i) => i === slot ? [] : s);
setPartition(next);
setPickedDie(null);
};
const autoAssign = () => {
// Greedy: largest dice go together in highest-buckets
if (!dice) return;
const sorted = dice.map((v, i) => ({ v, i })).sort((a,b) => b.v - a.v);
const next = [[],[],[],[],[],[]];
for (let k = 0; k < sorted.length; k++) {
const slot = Math.floor(k / 3);
if (slot >= 6) break;
next[slot].push(sorted[k].i);
}
setPartition(next);
setPickedDie(null);
};
const clearAll = () => { setPartition([[],[],[],[],[],[]]); setPickedDie(null); };
// Compute scores for slots
React.useEffect(() => {
if (!dice) return;
const sums = partition.map(s => s.length === 3 ? s.reduce((sum, idx) => sum + dice[idx], 0) : null);
const allFilled = sums.every(s => s !== null);
if (allFilled) {
onPool(poolFromValues(sums));
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
} else {
onPool([]);
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
}
onMethodNote(`${poolSize}d6 pool · partition into six groups of three`);
}, [dice, partition, poolSize]);
return (
Actions
Pool & partition. Roll a shared pool of d6s. Each player partitions the
numbers into six groups of three — each group is summed to make one ability score.
Click a die to pick it up, then click a slot to place it. Click a placed
die to pick it up again, or click empty pool space to drop it back.
{dice && (
<>
Pool — {dice.length}d6 · sum {ASG.sumD(dice)}click a die · then a slot
);
}
// ============================================================
// Method VIII — Targeted Rolling
// ============================================================
function MethodTargeted({ onAssignment, onMethodNote, generateKey, onPool }) {
const [klass, setKlass] = React.useState("Fighter");
const [variant, setVariant] = React.useState("class"); // class | swappable
const [data, setData] = React.useState(null); // per-ability rolls or array of sets
const roll = React.useCallback(() => {
if (variant === "class") setData(ASG.genMethodVIII(klass));
else setData(ASG.genMethodVIII_swappable());
}, [klass, variant]);
React.useEffect(() => { roll(); }, [klass, variant, generateKey]);
React.useEffect(() => {
if (!data) return;
if (variant === "class") {
// direct assignment
onPool([]);
onAssignment(Object.fromEntries(ABILS.map(a => [a, data[a].score])));
onMethodNote(`Targeted · ${klass} class profile`);
} else {
onPool(data.map(s => ({ id: uid(), value: s.score, detail: `${s.count}d6 → top 3 = ${s.kept.join("+")}` })));
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
onMethodNote(`Swappable · 8d6/7d6/6d6/5d6/4d6/3d6 · top 3 each`);
}
}, [data, variant]);
const profile = ASG.CLASS_DICE[klass];
return (
{variant === "class" && (
)}
{variant === "class" && profile && (
{ABILS.map(a => (
{SHORT[a]}
{profile[a]}d6
))}
)}
Built to fit. Roll the listed dice pool for each ability — keep only the
top three dice. This method consistently produces Mythic arrays; the swappable
variant lets you assign which pile goes where.
);
}
// ============================================================
// Method IX — Rolemaster Style
// ============================================================
function MethodRolemaster({ onAssignmentEx, onMethodNote, generateKey, onPool, onAssignment }) {
const [variant, setVariant] = React.useState("standard"); // standard | alt
const [assignFree, setAssignFree] = React.useState(false);
const [sets, setSets] = React.useState(null);
const roll = React.useCallback(() => {
setSets(variant === "standard" ? ASG.genMethodIX() : ASG.genMethodIX_alt());
}, [variant]);
React.useEffect(() => { roll(); }, [variant, generateKey]);
React.useEffect(() => {
if (!sets) return;
if (assignFree) {
// pool by start; max travels with the score in a different way — we need to attach
onPool(sets.map(s => ({ id: uid(), value: s.start, max: s.max, detail: `start ${s.start} · max ${s.max}` })));
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
onAssignmentEx(null);
} else {
onPool([]);
const map = Object.fromEntries(ABILS.map((a, i) => [a, { score: sets[i].start, max: sets[i].max }]));
onAssignmentEx(map);
}
onMethodNote(`Rolemaster Style · ${variant === "standard" ? "3d6 vs 4d6 drop lowest" : "4d6 → low 3 / all 4"}${assignFree ? " · free assign" : " · in order"}`);
}, [sets, assignFree, variant]);
return (
Two tracks: start & potential. Each ability has a starting score and a
higher maximum. As your character grows, you may raise an ability one point per level —
never exceeding its potential. Expect a low-powered start.
Buy six. 4 points to spend across six scores. Pricier costs lock in higher
floors — the 0-cost roll is fully random. Choose each slot's cost; click Re-roll
to roll the dice for the chosen options.
Roll 2d6: one for row, one for column. Look up the score on the table.
The weighted variant uses 2d6 for the row, biasing toward higher rows (and higher scores).
{sets && (
{sets.map((s, i) => (
{(i+1).toString().padStart(2,"0")}
row {s.row} · col {s.col}{s.score}
))}
)}
);
}
// ============================================================
// Method XII — Hand of Fate
// ============================================================
function MethodHandOfFate({ onPool, onAssignment, onMethodNote, generateKey }) {
const [handSize, setHandSize] = React.useState(9);
const [hand, setHand] = React.useState(null); // array of dealt cards
const [slots, setSlots] = React.useState(() => [[],[],[],[],[],[]]); // each slot holds card indices
const [picked, setPicked] = React.useState(null); // index of card currently picked up
const dealNew = React.useCallback(() => {
const h = ASG.dealHand(handSize);
setHand(h);
setSlots([[],[],[],[],[],[]]);
setPicked(null);
}, [handSize]);
React.useEffect(() => { dealNew(); }, [handSize, generateKey]);
// ---- Hand evaluation for an arbitrary 1-3 card slot ----
// Returns { kind, score } or { kind:"—", score: null } for invalid combinations.
function evaluateSlot(cardIdxs) {
if (!hand || cardIdxs.length === 0) return { kind: "empty", score: null };
const cs = cardIdxs.map(i => hand[i]);
if (cs.length === 1) return { kind: "High Card", score: cs[0].value };
if (cs.length === 2) {
if (cs[0].value === cs[1].value) return { kind: "Pair", score: 14 };
return { kind: "incomplete", score: null };
}
// 3 cards
const sameSuit = cs.every(c => c.suit === cs[0].suit);
const vals = cs.map(c => c.value).sort((a,b) => a-b);
const isRun = (vals[2] - vals[0] === 2 && new Set(vals).size === 3) ||
(vals.includes(14) && vals.includes(2) && vals.includes(3));
const sameRank = cs.every(c => c.value === cs[0].value);
if (sameSuit && isRun) return { kind: "Straight Flush", score: 18 };
if (sameRank) return { kind: "Three of a Kind", score: 17 };
if (isRun) return { kind: "Straight", score: 16 };
if (sameSuit) return { kind: "Flush", score: 15 };
return { kind: "invalid", score: null };
}
// ---- Manipulation ----
const removeFromAny = (sls, idx) => sls.map(s => s.filter(i => i !== idx));
const onClickCard = (idx) => {
if (picked === idx) {
// toggle off — return to pool
setSlots(s => removeFromAny(s, idx));
setPicked(null);
return;
}
setPicked(idx);
};
const placeIn = (slot) => {
if (picked == null) return;
const slotHasIt = slots[slot].includes(picked);
if (slots[slot].length >= 3 && !slotHasIt) return;
let next = removeFromAny(slots, picked);
if (!slotHasIt) next = next.map((s, i) => i === slot ? s.concat([picked]) : s);
setSlots(next);
setPicked(null);
};
const sendToPool = () => {
if (picked == null) return;
setSlots(s => removeFromAny(s, picked));
setPicked(null);
};
const clearSlot = (slot) => { setSlots(s => s.map((x, i) => i === slot ? [] : x)); setPicked(null); };
const clearAll = () => { setSlots([[],[],[],[],[],[]]); setPicked(null); };
const autoBuild = () => {
if (!hand) return;
const result = ASG.buildBestHands(hand);
// Translate result.hands (lists of Card objects) into indices into `hand`.
// We greedily match cards back to indices (cards are unique by rank+suit).
const used = new Set();
const indexOf = (card) => {
for (let i = 0; i < hand.length; i++) {
if (used.has(i)) continue;
if (hand[i].rank === card.rank && hand[i].suit === card.suit) {
used.add(i); return i;
}
}
return -1;
};
const next = result.hands.map(h => h.cards.map(indexOf).filter(i => i >= 0)).slice(0, 6);
while (next.length < 6) next.push([]);
setSlots(next);
setPicked(null);
};
// Used indices = anything placed in a slot
const used = new Set(slots.flat());
// Compute pool of completed ability scores and push up.
React.useEffect(() => {
if (!hand) return;
const evals = slots.map(s => evaluateSlot(s));
const allComplete = evals.every(e => e.score != null);
if (allComplete) {
onPool(evals.map(e => ({ id: uid(), value: e.score, detail: e.kind })));
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
} else {
onPool([]);
onAssignment(Object.fromEntries(ABILS.map(a => [a, null])));
}
onMethodNote(`Hand of Fate · ${handSize}-card draw${allComplete ? "" : ` · ${evals.filter(e => e.score != null).length}/6 hands built`}`);
}, [slots, hand]);
return (
Actions
Build six hands. Deal {handSize} cards, then form up to six
ability hands. Click a card to pick it up, click a slot to place it.
Straight Flush = 18, Three of a Kind = 17, Straight = 16,
Flush = 15, Pair = 14; a single card scores its face value
(Ace = 14, King = 13, Queen = 12, Jack = 11).
{hand && (
<>
Drawn cards — {handSize} total · {hand.length - used.size} unplacedclick a card · then a slot
Maximum chaos. One d20 per ability. Flat distribution: as likely to roll a 1
as a 20. Expect wildly uneven characters; party balance is not guaranteed.