/* Pokémon Void — Nuzlocke Randomizer Generator. window.VIEWS.Nuzlocke
Press Randomize → get a complete, conflict-free Nuzlocke ruleset with a
difficulty rating scaled to how punishing the selected rules are. No external
data; pure generation. Rules carry a `w` (weight = how restrictive) and an
optional `tag` so contradictory rules can never appear together. */
window.VIEWS = window.VIEWS || {};
(function () {
const { PageHead } = window.VUI;
// ---- helpers ----
const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
const chance = (p) => Math.random() < p;
// Each option: { t: text, w: weight 0-3, tag?: mutual-exclusion key }
// Picking one option per category; where a category may contribute several,
// we filter so no two share a `tag`.
const CATS = {
encounter: {
label: 'Encounter Rules', color: '#33d6ff',
// exactly one of these governs how you catch
one: [
{ t: 'Standard: only the FIRST encounter on each route/area may be caught.', w: 0 },
{ t: 'Choice: you may pick between the first TWO encounters on each route.', w: 0 },
{ t: 'First unique species only — if you already own that species, you skip and the route is burned.', w: 1 },
{ t: 'Dupes Clause: if the first encounter is a species you already own, you may try again until it is new.', w: 0 },
],
// optional add-ons (each independent, may stack)
addons: [
{ t: 'Shiny Clause: a shiny may always be caught, even outside normal rules.', w: 0, tag: 'shiny' },
{ t: 'Static encounters (gift-spot/forced battles) count as your encounter for that area.', w: 1, tag: 'static' },
{ t: 'Static encounters are BANNED — they never count and may not be caught.', w: 2, tag: 'static' },
{ t: 'Gift Pokémon are ALLOWED and do not use up an encounter.', w: 0, tag: 'gift' },
{ t: 'Gift Pokémon are BANNED entirely.', w: 2, tag: 'gift' },
],
},
death: {
label: 'Death Rules', color: '#ff5f7e',
one: [
{ t: 'A fainted Pokémon is dead — box it permanently.', w: 1, tag: 'deadfate' },
{ t: 'A fainted Pokémon is dead — release it.', w: 2, tag: 'deadfate' },
],
addons: [
{ t: 'One Revive Token per Gym: you may resurrect a single dead Pokémon once between each badge.', w: -1, tag: 'mercy' },
{ t: 'A full team wipe ends the run immediately.', w: 2, tag: 'wipe' },
{ t: 'A team wipe only kills your active party — boxed Pokémon survive.', w: 0, tag: 'wipe' },
],
},
team: {
label: 'Team Restrictions', color: '#b08fff',
addons: [
{ t: 'Party cap: you may carry a maximum of {N} Pokémon at once.', w: 1, tag: 'size', dyn: () => ({ N: pick([3, 4, 5]) }) },
{ t: 'Monotype Run: every team member must share one chosen type.', w: 3, tag: 'typing' },
{ t: 'No Overlapping Types: no two team members may share any type.', w: 2, tag: 'typing' },
{ t: 'Your starter is benched permanently after the first gym.', w: 2, tag: 'starter' },
{ t: 'Team Rotation: you must swap in at least one fresh Pokémon after every badge.', w: 2, tag: 'rotate' },
{ t: 'Your lowest-level living Pokémon must always remain on the team.', w: 1, tag: 'lowmember' },
],
},
battle: {
label: 'Battle Rules', color: '#ffb347',
addons: [
{ t: 'Set Mode only — no free switching when the foe sends out a new Pokémon.', w: 1, tag: 'set' },
{ t: 'No items in battle (no potions, revives, or X-items mid-fight).', w: 2, tag: 'items' },
{ t: 'Held items are BANNED.', w: 1, tag: 'held' },
{ t: 'Level Cap: no Pokémon may exceed the next gym leader\u2019s ace level.', w: 2, tag: 'cap' },
{ t: 'No switching out a Pokémon for the rest of a battle once one of yours has been KO\u2019d.', w: 2, tag: 'noswitch' },
{ t: 'You must LEAD every battle with your lowest-level living Pokémon.', w: 2, tag: 'lead' },
],
},
species: {
label: 'Pokémon Restrictions', color: '#5fd13c',
addons: [
{ t: 'Legendary and Mythical Pokémon are BANNED.', w: 1, tag: 'legend' },
{ t: 'Pseudo-legendary Pokémon are BANNED.', w: 1, tag: 'pseudo' },
{ t: 'Trade-evolution Pokémon may not be evolved.', w: 1, tag: 'tradeevo' },
{ t: 'Pokémon with healing abilities are BANNED.', w: 1, tag: 'healability' },
{ t: 'Setup moves (stat-boosting moves) are BANNED.', w: 2, tag: 'setup' },
{ t: 'No two team members may share the same Ability.', w: 1, tag: 'dupeability' },
{ t: 'No Pokémon with a base stat total above {N} may be used.', w: 2, tag: 'bst', dyn: () => ({ N: pick([480, 500, 525]) }) },
],
},
modifier: {
label: 'Extra Modifiers', color: '#ff7fe0',
addons: [
{ t: 'No Pokémon Centers — healing only via items or in-field methods.', w: 3, tag: 'noheal' },
{ t: 'No Marts — you may not purchase anything.', w: 2, tag: 'nomart' },
{ t: 'No TMs may be used.', w: 1, tag: 'notm' },
{ t: 'Evolution is BANNED — Pokémon stay in their caught form forever.', w: 3, tag: 'noevo' },
{ t: 'One Pokémon per Gym: you may only use a single Pokémon against each gym leader.', w: 3, tag: 'onepergym' },
{ t: 'Permadeath applies to the whole evolution line — if one dies, you may never use that line again.', w: 2, tag: 'lineperma' },
{ t: 'After every gym, randomly sacrifice one surviving Pokémon.', w: 3, tag: 'sacrifice' },
],
},
};
const CORE = [
'If a Pokémon faints, it is considered dead and must be boxed or released (per your Death Rules).',
'You may only catch the first valid encounter in each route or area.',
'Every Pokémon you catch must be given a nickname.',
'A blackout/whiteout (losing with no usable Pokémon) loses the run, unless a selected rule says otherwise.',
];
const THEMES = [
{ name: 'Standard Nuzlocke', when: (d) => d <= 6 },
{ name: 'Mercy Locke', when: (d, r) => r.some(x => x.tag === 'mercy') },
{ name: 'Typebound Locke', when: (d, r) => r.some(x => x.tag === 'typing') },
{ name: 'Poverty Locke', when: (d, r) => r.some(x => x.tag === 'nomart' || x.tag === 'noheal') },
{ name: 'Anomaly Hunter Locke', when: (d, r) => r.some(x => x.tag === 'shiny') },
{ name: 'Hardcore Locke', when: (d) => d >= 12 && d < 17 },
{ name: 'Chaos Locke', when: (d, r) => r.length >= 11 },
{ name: 'Roulette Locke', when: (d, r) => r.some(x => x.tag === 'sacrifice') },
{ name: 'Masochist Locke', when: (d) => d >= 21 },
{ name: 'Rival Locke', when: () => true }, // fallback
];
const TIERS = [
{ name: 'Easy', min: -99, color: '#5fd13c' },
{ name: 'Normal', min: 7, color: '#33d6ff' },
{ name: 'Hard', min: 12, color: '#ffb347' },
{ name: 'Brutal', min: 17, color: '#ff7f4f' },
{ name: 'Nightmare', min: 21, color: '#ff4f6f' },
];
// resolve {N} placeholders and dynamic params
const realize = (opt) => {
if (!opt.dyn) return { ...opt };
const params = opt.dyn();
let t = opt.t;
Object.entries(params).forEach(([k, v]) => { t = t.replace('{' + k + '}', v); });
return { ...opt, t };
};
// pick a conflict-free set of addons from a pool: 1 per `tag`, count random
function pickAddons(pool, minN, maxN) {
const shuffled = [...pool].sort(() => Math.random() - 0.5);
const usedTags = new Set();
const chosen = [];
const target = minN + Math.floor(Math.random() * (maxN - minN + 1));
for (const opt of shuffled) {
if (chosen.length >= target) break;
if (opt.tag && usedTags.has(opt.tag)) continue; // conflict guard
chosen.push(realize(opt));
if (opt.tag) usedTags.add(opt.tag);
}
return chosen;
}
function generate() {
const out = {};
const all = [];
// Roll an INTENSITY first — this decides how many rules each category adds,
// so runs genuinely span Easy → Nightmare instead of always piling up.
// [team/battle/species min,max] and [modifier min,max] and [encounter/death addon max].
const INTENSITY = pick([
{ core: [0, 1], mod: [0, 1], extra: 1 }, // light
{ core: [1, 2], mod: [0, 2], extra: 2 }, // medium
{ core: [1, 3], mod: [1, 3], extra: 3 }, // heavy
{ core: [2, 3], mod: [2, 3], extra: 3 }, // insane
]);
const C = INTENSITY.core, MOD = INTENSITY.mod, EX = INTENSITY.extra;
// Encounter: exactly one governing rule + addons
const encOne = realize(pick(CATS.encounter.one));
const encAdd = pickAddons(CATS.encounter.addons, 0, EX);
out.encounter = [encOne, ...encAdd];
// Death: one fate rule + addons
const deathOne = realize(pick(CATS.death.one));
const deathAdd = pickAddons(CATS.death.addons, 0, Math.min(2, EX));
out.death = [deathOne, ...deathAdd];
// The rest scale with intensity
out.team = pickAddons(CATS.team.addons, C[0], C[1]);
out.battle = pickAddons(CATS.battle.addons, C[0], C[1]);
out.species = pickAddons(CATS.species.addons, C[0], C[1]);
out.modifier = pickAddons(CATS.modifier.addons, MOD[0], MOD[1]);
['encounter', 'death', 'team', 'battle', 'species', 'modifier'].forEach(k => out[k].forEach(r => all.push(r)));
// difficulty = sum of weights (mercy reduces it)
const score = all.reduce((s, r) => s + (r.w || 0), 0);
const tier = [...TIERS].reverse().find(t => score >= t.min) || TIERS[0];
// theme: first matching rule, else fallback
const theme = THEMES.find(t => t.when(score, all)) || THEMES[THEMES.length - 1];
// win/loss conditions reflect chosen rules
const wipeEnds = all.some(r => r.tag === 'wipe' && /ends the run/.test(r.t));
const loss = wipeEnds
? 'You black out with no usable Pokémon, OR your entire team is wiped in a single battle.'
: 'You black out / white out with no usable Pokémon remaining.';
return { theme: theme.name, tier, score, core: CORE, ...out, win: 'Defeat the Champion and complete the Drapalla League with at least one living Pokémon.', loss };
}
window.VIEWS.Nuzlocke = function Nuzlocke() {
const [run, setRun] = React.useState(null);
const roll = () => setRun(generate());
const Section = ({ label, color, rules }) => (
{label.toUpperCase()}
{rules.map((r, i) => (
{r.t || r}
))}
);
return (
{!run ? (
Hit Randomize to forge a run. You\u2019ll get a themed challenge with a difficulty rating, full rules, and clear win & loss conditions you can follow start to finish.
) : (
{/* banner */}
CHALLENGE NAME
{run.theme}
DIFFICULTY
{run.tier.name}
({ t }))} />
{run.modifier.length > 0 && }
{/* win / loss */}