MediaWiki:Gadget-spawncalc.js: Difference between revisions

Revision as of 08:50, 18 June 2026

/*
 * Pixelmon spawn-chance calculator gadget (full-page).
 *
 * Mounts into <div id="spawn-calculator" data-species="..."> on the standalone
 * Spawn Calculator page. data-species is normally empty there; a ?species=Name
 * query parameter (used by the link on each species page) pre-fills the picker.
 *
 * For a chosen species and situation it shows the chance that a single
 * Better-Spawner selection is that species:
 *     P = sum(rarity of this species' matching spawns)
 *         / sum(rarity of all matching spawns)
 *
 * Dimensions: biome, location type, time of day, weather, Y-level, light level,
 * moon phase. Only the dimensions that actually constrain the chosen species are
 * shown. Each shown field can be locked so "Find best chance" leaves it fixed.
 * "Consecutive times" averages a cyclic block of times of day, weighting each by
 * its real in-game length; with "Strict block" the optimizer only accepts blocks
 * where the species spawns in every time, otherwise it reduces the block size.
 *
 * Data is provided by Gadget-spawncalc-data.js as window.PixelmonSpawnData.
 * This file is static UI/logic; it is NOT generated. The data file IS.
 */
( function () {
	'use strict';

	// Active in-game duration (ticks out of 24000) of each WorldTime, from the
	// Pixelmon WorldTime SEGMENTS partition. Weights a block of times by length.
	var TIME_TICKS = {
		DAWN: 1800, MORNING: 7451, DAY: 12001, MIDDAY: 1001,
		AFTERNOON: 6000, DUSK: 1800, NIGHT: 10550, MIDNIGHT: 1001
	};

	function el( tag, attrs, children ) {
		var node = document.createElement( tag );
		attrs = attrs || {};
		Object.keys( attrs ).forEach( function ( k ) {
			if ( k === 'class' ) { node.className = attrs[ k ]; }
			else if ( k === 'text' ) { node.textContent = attrs[ k ]; }
			else { node.setAttribute( k, attrs[ k ] ); }
		} );
		( children || [] ).forEach( function ( c ) {
			node.appendChild( typeof c === 'string' ? document.createTextNode( c ) : c );
		} );
		return node;
	}

	function prettyBiome( id ) {
		var s = id.charAt( 0 ) === '#' ? id.slice( 1 ) : id;
		if ( s.indexOf( ':' ) !== -1 ) { s = s.split( ':' )[ 1 ]; }
		if ( s.indexOf( '/' ) !== -1 ) { s = s.split( '/' ).pop(); }
		return s.replace( /_/g, ' ' ).replace( /\b\w/g, function ( c ) { return c.toUpperCase(); } );
	}

	function titleCase( s ) { return s.charAt( 0 ) + s.slice( 1 ).toLowerCase(); }
	function inList( list, v ) { return list && list.indexOf( v ) !== -1; }
	function uniq( arr ) {
		var seen = {}, out = [];
		arr.forEach( function ( v ) { if ( !seen[ v ] ) { seen[ v ] = 1; out.push( v ); } } );
		return out;
	}

	function getParam( name ) {
		var q = location.search || '';
		var m = new RegExp( '[?&]' + name + '=([^&#]*)' ).exec( q );
		if ( !m ) { return null; }
		try { return decodeURIComponent( m[ 1 ].replace( /\+/g, ' ' ) ); } catch ( e ) { return m[ 1 ]; }
	}

	function build( root, data, initialSpecies ) {
		var entries = data.entries;
		var NT = data.times.length;
		var timeLen = data.times.map( function ( name ) { return TIME_TICKS[ name ] || 1; } );
		var allTimes = data.times.map( function ( _t, i ) { return i; } );
		var allWeathers = data.weathers.map( function ( _w, i ) { return i; } );

		var byMethod = {};
		entries.forEach( function ( e ) {
			e.m.forEach( function ( m ) { ( byMethod[ m ] = byMethod[ m ] || [] ).push( e ); } );
		} );

		var speciesSet = {}, speciesList = [];
		entries.forEach( function ( e ) {
			if ( !speciesSet[ e.s ] ) { speciesSet[ e.s ] = true; speciesList.push( e.s ); }
		} );
		speciesList.sort( function ( a, b ) { return a.localeCompare( b ); } );

		var species = initialSpecies || '';
		var speciesEntries = [];
		var rel = {};
		function refreshSpecies() {
			speciesEntries = entries.filter( function ( e ) { return e.s === species; } );
			function any( fn ) { return speciesEntries.some( fn ); }
			rel = {
				time: any( function ( e ) { return e.t; } ),
				weather: any( function ( e ) { return e.w; } ),
				y: any( function ( e ) { return e.y0 != null || e.y1 != null; } ),
				light: any( function ( e ) { return e.l0 != null || e.l1 != null; } ),
				moon: any( function ( e ) { return e.mp != null; } )
			};
		}
		refreshSpecies();

		// ── core probability ───────────────────────────────────────────
		// base: { B, M, W, y, light, moon } where any null field is "any".
		function passes( c, base ) {
			if ( c.b && !inList( c.b, base.B ) ) { return false; }
			if ( base.y != null ) {
				if ( c.y0 != null && base.y < c.y0 ) { return false; }
				if ( c.y1 != null && base.y > c.y1 ) { return false; }
			}
			if ( base.light != null ) {
				if ( c.l0 != null && base.light < c.l0 ) { return false; }
				if ( c.l1 != null && base.light > c.l1 ) { return false; }
			}
			if ( base.moon != null && c.mp != null && base.moon !== c.mp ) { return false; }
			if ( base.W != null && c.w && !inList( c.w, base.W ) ) { return false; }
			return true;
		}

		// Per-time probability array for a base situation (one pass).
		function chanceP8( base ) {
			var pool = byMethod[ base.M ] || [];
			var num = [], den = [];
			for ( var z = 0; z < NT; z++ ) { num.push( 0 ); den.push( 0 ); }
			for ( var i = 0; i < pool.length; i++ ) {
				var c = pool[ i ];
				if ( !passes( c, base ) ) { continue; }
				var ct = c.t || allTimes;
				for ( var j = 0; j < ct.length; j++ ) {
					den[ ct[ j ] ] += c.r;
					if ( c.s === species ) { num[ ct[ j ] ] += c.r; }
				}
			}
			var p8 = [];
			for ( var q = 0; q < NT; q++ ) { p8.push( den[ q ] > 0 ? num[ q ] / den[ q ] : 0 ); }
			return p8;
		}

		// Full breakdown at one time (null = any time): rarity, competitors.
		function chanceAt( base, t ) {
			var pool = byMethod[ base.M ] || [];
			var num = 0, den = 0, comp = 0;
			for ( var i = 0; i < pool.length; i++ ) {
				var c = pool[ i ];
				if ( !passes( c, base ) ) { continue; }
				if ( t != null && c.t && !inList( c.t, t ) ) { continue; }
				den += c.r;
				if ( c.s === species ) { num += c.r; } else { comp++; }
			}
			return { num: num, den: den, comp: comp, p: den > 0 ? num / den : 0 };
		}

		function blockTimes( start, n ) {
			n = Math.max( 1, Math.min( NT, n ) );
			var out = [];
			for ( var k = 0; k < n; k++ ) { out.push( ( start + k ) % NT ); }
			return out;
		}
		function blockWeighted( p8, times ) {
			var wsum = 0, acc = 0;
			for ( var i = 0; i < times.length; i++ ) {
				wsum += timeLen[ times[ i ] ];
				acc += timeLen[ times[ i ] ] * p8[ times[ i ] ];
			}
			return wsum > 0 ? acc / wsum : 0;
		}
		function pickY( e ) {
			var y = 63;
			if ( e.y0 != null && y < e.y0 ) { y = e.y0; }
			if ( e.y1 != null && y > e.y1 ) { y = e.y1; }
			return y;
		}
		function round2( n ) { return Math.round( n * 100 ) / 100; }
		function fmtPct( p ) {
			if ( !( p > 0 ) ) { return '0%'; }
			var v = p * 100;
			return ( v >= 1 ? v.toFixed( 1 ) : v.toFixed( 2 ) ) + '%';
		}

		// ── controls ────────────────────────────────────────────────────
		var biomeSel = el( 'select', { class: 'scalc-input' } );
		data.biomes
			.map( function ( id, i ) { return { i: i, name: prettyBiome( id ) }; } )
			.sort( function ( a, b ) { return a.name.localeCompare( b.name ); } )
			.forEach( function ( o ) { biomeSel.appendChild( el( 'option', { value: o.i, text: o.name } ) ); } );

		var methodSel = el( 'select', { class: 'scalc-input' } );
		data.methods.forEach( function ( m, i ) { methodSel.appendChild( el( 'option', { value: i, text: m } ) ); } );

		var timeSel = el( 'select', { class: 'scalc-input' } );
		data.times.forEach( function ( t, i ) { timeSel.appendChild( el( 'option', { value: i, text: titleCase( t ) } ) ); } );

		var weatherSel = el( 'select', { class: 'scalc-input' } );
		data.weathers.forEach( function ( w, i ) { weatherSel.appendChild( el( 'option', { value: i, text: titleCase( w ) } ) ); } );

		var ySel = el( 'input', { type: 'number', min: '-64', max: '320', value: '63', class: 'scalc-num' } );
		var lightSel = el( 'input', { type: 'number', min: '0', max: '15', value: '7', class: 'scalc-num' } );
		var moonSel = el( 'select', { class: 'scalc-input' } );
		for ( var mp = 0; mp < 8; mp++ ) { moonSel.appendChild( el( 'option', { value: mp, text: 'Phase ' + mp } ) ); }

		var consecSel = el( 'input', {
			type: 'number', min: '1', max: String( NT ), value: '1', class: 'scalc-num',
			title: 'Average a block of this many consecutive times of day, weighting '
				+ 'each by its real length. Set to ' + NT + ' for any time.'
		} );
		var strictChk = el( 'input', { type: 'checkbox', class: 'scalc-check', checked: 'checked' } );

		function lockBox() {
			return el( 'input', { type: 'checkbox', class: 'scalc-lock-chk',
				title: 'Lock: keep this value when using Find best chance.' } );
		}
		var lockBiome = lockBox(), lockMethod = lockBox(), lockTime = lockBox(),
			lockWeather = lockBox(), lockY = lockBox(), lockLight = lockBox(), lockMoon = lockBox();

		function field( labelText, control, lock ) {
			var lab = el( 'label', { class: 'scalc-label' }, [ document.createTextNode( labelText ) ] );
			if ( lock ) {
				lab.appendChild( el( 'label', { class: 'scalc-lock' }, [ lock, document.createTextNode( ' lock' ) ] ) );
			}
			return el( 'div', { class: 'scalc-field' }, [ lab, control ] );
		}

		// Species picker (standalone page).
		var speciesInput = el( 'input', {
			class: 'scalc-input scalc-species', list: 'scalc-species-list',
			placeholder: 'Type a Pokemon name', autocomplete: 'off'
		} );
		var speciesDl = el( 'datalist', { id: 'scalc-species-list' } );
		speciesList.forEach( function ( n ) { speciesDl.appendChild( el( 'option', { value: n } ) ); } );
		function onSpeciesPick() { if ( speciesSet[ speciesInput.value ] ) { setSpecies( speciesInput.value ); } }
		speciesInput.addEventListener( 'change', onSpeciesPick );
		speciesInput.addEventListener( 'input', onSpeciesPick );
		var fSpecies = el( 'div', { class: 'scalc-field scalc-field-species' }, [
			el( 'label', { class: 'scalc-label', text: 'Pokemon' } ), speciesInput, speciesDl
		] );

		var fBiome = field( 'Biome', biomeSel, lockBiome );
		var fMethod = field( 'Location type', methodSel, lockMethod );
		var fTime = field( 'Time of day', timeSel, lockTime );
		var fWeather = field( 'Weather', weatherSel, lockWeather );
		var fY = field( 'Y-level', ySel, lockY );
		var fLight = field( 'Light level', lightSel, lockLight );
		var fMoon = field( 'Moon phase', moonSel, lockMoon );

		var formFields = [];
		if ( !initialSpecies ) { formFields.push( fSpecies ); }
		formFields.push( fBiome, fMethod, fTime, fWeather, fY, fLight, fMoon );
		var form = el( 'div', { class: 'scalc-form' }, formFields );

		var meta = el( 'div', { class: 'scalc-form scalc-meta' }, [
			el( 'span', { class: 'scalc-meta-label', text: 'Time block' } ),
			field( 'Consecutive times', consecSel ),
			el( 'div', { class: 'scalc-field' }, [
				el( 'label', { class: 'scalc-label', text: 'Strict block' } ),
				el( 'label', { class: 'scalc-check-wrap',
					title: 'Only accept blocks where the species spawns in every time. '
						+ 'If none exists, the block size is reduced and you are warned.' }, [
					strictChk, el( 'span', { class: 'scalc-check-text', text: 'all times must spawn' } )
				] )
			] )
		] );

		var bestBtn = el( 'button', { class: 'scalc-btn', type: 'button', text: 'Find best chance' } );
		var actions = el( 'div', { class: 'scalc-actions' }, [ bestBtn ] );
		var results = el( 'div', { class: 'scalc-results' } );

		function getN() { return Math.max( 1, Math.min( NT, parseInt( consecSel.value, 10 ) || 1 ) ); }
		function getBase() {
			return {
				B: +biomeSel.value,
				M: +methodSel.value,
				W: rel.weather ? +weatherSel.value : null,
				y: rel.y ? ( ySel.value === '' ? null : +ySel.value ) : null,
				light: rel.light ? ( lightSel.value === '' ? null : +lightSel.value ) : null,
				moon: rel.moon ? +moonSel.value : null
			};
		}

		function applyVisibility() {
			fTime.style.display = rel.time ? '' : 'none';
			fWeather.style.display = rel.weather ? '' : 'none';
			fY.style.display = rel.y ? '' : 'none';
			fLight.style.display = rel.light ? '' : 'none';
			fMoon.style.display = rel.moon ? '' : 'none';
			meta.style.display = rel.time ? '' : 'none';
		}

		var flagBest = false, warnText = null;

		function recompute() {
			results.innerHTML = '';
			if ( !species ) {
				results.appendChild( el( 'div', { class: 'scalc-result' }, [
					el( 'span', { class: 'scalc-note', text: 'Choose a Pokemon to see its spawn chances.' } )
				] ) );
				flagBest = false; warnText = null; return;
			}
			if ( !speciesEntries.length ) {
				results.appendChild( el( 'div', { class: 'scalc-result scalc-result-miss' }, [
					el( 'span', { class: 'scalc-note', text:
						species + ' has no standard overworld spawns (legendary, boss, '
						+ 'fossil, evolution-only or event Pokemon).' } )
				] ) );
				flagBest = false; warnText = null; return;
			}

			var base = getBase();
			var N = getN();
			var p8 = [];
			for ( var t = 0; t < NT; t++ ) { p8.push( chanceAt( base, t ).p ); }

			var times = rel.time ? blockTimes( +timeSel.value, N ) : allTimes;
			var showBreak = rel.time && times.length > 1;
			var single = rel.time && times.length === 1;
			var p = times.length === 1 ? p8[ times[ 0 ] ] : blockWeighted( p8, times );

			var detailText;
			if ( single ) {
				var res = chanceAt( base, times[ 0 ] );
				detailText = '~1 in ' + Math.round( 1 / res.p ) + ' spawns - rarity '
					+ round2( res.num ) + ' of ' + round2( res.den ) + ' vs ' + res.comp
					+ ' competing spawn' + ( res.comp === 1 ? '' : 's' ) + '.';
			} else {
				detailText = '~1 in ' + Math.round( 1 / p ) + ' spawns, length-weighted across '
					+ ( !rel.time ? 'any time (this Pokemon ignores time of day)'
						: ( N >= NT ? 'any time' : N + ' consecutive times' ) ) + '.';
			}

			var hit = p > 0;
			var head = el( 'div', { class: 'scalc-result-head' }, [
				el( 'span', { class: 'scalc-pct', text: fmtPct( hit ? p : 0 ) } ),
				el( 'span', { class: 'scalc-pctlabel', text:
					'chance a wild spawn here is ' + species + ( flagBest && hit ? ' (best found)' : '' ) } )
			] );
			var detail = hit
				? el( 'span', { class: 'scalc-detail', text: detailText } )
				: el( 'span', { class: 'scalc-note', text:
					'Does not spawn in this situation. Try Find best chance, or change '
					+ 'the biome / location type / time.' } );

			var children = [];
			if ( warnText ) { children.push( el( 'div', { class: 'scalc-warn', text: warnText } ) ); }
			children.push( head, detail );

			if ( hit && showBreak ) {
				var deadCount = 0;
				var chips = times.map( function ( ti ) {
					var pv = p8[ ti ], dead = !( pv > 0 );
					if ( dead ) { deadCount++; }
					return el( 'span', { class: 'scalc-chip' + ( dead ? ' scalc-chip-dead' : '' ) }, [
						el( 'span', { class: 'scalc-chip-time', text: titleCase( data.times[ ti ] ) } ),
						el( 'span', { class: 'scalc-chip-pct', text: fmtPct( pv ) } )
					] );
				} );
				children.push( el( 'div', { class: 'scalc-breakdown' }, chips ) );
				if ( deadCount > 0 ) {
					children.push( el( 'div', { class: 'scalc-note', text:
						deadCount + ' of ' + times.length + ' times have no ' + species
						+ ' spawns here' + ( strictChk.checked ? ''
							: '; enable "Strict block" to make the optimizer avoid them' ) + '.' } ) );
				}
			}
			results.appendChild( el( 'div', {
				class: 'scalc-result ' + ( hit ? 'scalc-result-hit' : 'scalc-result-miss' )
				+ ( flagBest && hit ? ' scalc-result-best' : '' )
			}, children ) );
			flagBest = false; warnText = null;
		}

		// ── optimizer ────────────────────────────────────────────────────
		function biomeCandidates() {
			if ( speciesEntries.some( function ( e ) { return !e.b; } ) ) {
				return data.biomes.map( function ( _b, i ) { return i; } );
			}
			var all = [];
			speciesEntries.forEach( function ( e ) { if ( e.b ) { all = all.concat( e.b ); } } );
			return uniq( all );
		}
		function methodCandidates() {
			var all = [];
			speciesEntries.forEach( function ( e ) { all = all.concat( e.m ); } );
			return uniq( all );
		}
		function numCandidates( lo, hi, extra ) {
			var vals = [];
			speciesEntries.forEach( function ( e ) {
				if ( e[ lo ] != null ) { vals.push( e[ lo ] ); }
				if ( e[ hi ] != null ) { vals.push( e[ hi ] ); }
			} );
			( extra || [] ).forEach( function ( v ) { vals.push( v ); } );
			return uniq( vals );
		}
		function moonCandidates() {
			var vals = [];
			speciesEntries.forEach( function ( e ) { if ( e.mp != null ) { vals.push( e.mp ); } } );
			return uniq( vals );
		}

		function findBest() {
			if ( !species || !speciesEntries.length ) { recompute(); return; }
			var N = getN(), strict = strictChk.checked, lockT = lockTime.checked, curT = +timeSel.value;

			var biomeC = lockBiome.checked ? [ +biomeSel.value ] : biomeCandidates();
			var methodC = lockMethod.checked ? [ +methodSel.value ] : methodCandidates();
			var weatherC = !rel.weather ? [ null ] : ( lockWeather.checked ? [ +weatherSel.value ] : allWeathers );
			var yC = !rel.y ? [ null ] : ( lockY.checked ? [ +ySel.value ] : numCandidates( 'y0', 'y1', [ 63 ] ) );
			var lightC = !rel.light ? [ null ] : ( lockLight.checked ? [ +lightSel.value ] : numCandidates( 'l0', 'l1', [ 0, 7, 15 ] ) );
			var moonC = !rel.moon ? [ null ] : ( lockMoon.checked ? [ +moonSel.value ] : moonCandidates() );

			var situations = [];
			for ( var a = 0; a < biomeC.length; a++ ) {
				for ( var b = 0; b < methodC.length; b++ ) {
					for ( var c = 0; c < weatherC.length; c++ ) {
						for ( var d = 0; d < yC.length; d++ ) {
							for ( var f = 0; f < lightC.length; f++ ) {
								for ( var g = 0; g < moonC.length; g++ ) {
									var base = { B: biomeC[ a ], M: methodC[ b ], W: weatherC[ c ],
										y: yC[ d ], light: lightC[ f ], moon: moonC[ g ] };
									situations.push( { base: base, p8: chanceP8( base ) } );
								}
							}
						}
					}
				}
			}

			function searchAt( n, strictFlag ) {
				var best = null;
				for ( var i = 0; i < situations.length; i++ ) {
					var p8 = situations[ i ].p8;
					var starts = lockT ? [ curT ] : allTimes;
					for ( var si = 0; si < starts.length; si++ ) {
						var start = starts[ si ];
						var times = blockTimes( start, n );
						var allSpawn = true;
						for ( var j = 0; j < times.length; j++ ) {
							if ( !( p8[ times[ j ] ] > 0 ) ) { allSpawn = false; break; }
						}
						if ( strictFlag && !allSpawn ) {
							if ( n >= NT ) { break; }
							continue;
						}
						var p = times.length === 1 ? p8[ times[ 0 ] ] : blockWeighted( p8, times );
						if ( p > 0 && ( !best || p > best.p ) ) {
							best = { base: situations[ i ].base, start: start, p: p };
						}
						if ( n >= NT && !lockT ) { break; }
					}
				}
				return best;
			}

			var best = null, effN = N;
			if ( !rel.time ) {
				// time irrelevant: whole-day length-weighted, no start search
				for ( var k = 0; k < situations.length; k++ ) {
					var pw = blockWeighted( situations[ k ].p8, allTimes );
					if ( pw > 0 && ( !best || pw > best.p ) ) {
						best = { base: situations[ k ].base, start: null, p: pw };
					}
				}
			} else if ( strict ) {
				for ( var n = N; n >= 1; n-- ) {
					best = searchAt( n, true );
					if ( best ) { effN = n; break; }
				}
			} else {
				best = searchAt( N, false );
			}
			if ( !best ) { recompute(); return; }

			var bb = best.base;
			biomeSel.value = bb.B;
			methodSel.value = bb.M;
			if ( rel.weather && bb.W != null ) { weatherSel.value = bb.W; }
			if ( rel.y && bb.y != null ) { ySel.value = bb.y; }
			if ( rel.light && bb.light != null ) { lightSel.value = bb.light; }
			if ( rel.moon && bb.moon != null ) { moonSel.value = bb.moon; }
			if ( rel.time && best.start != null ) { timeSel.value = best.start; }
			if ( rel.time && strict && effN < N ) {
				consecSel.value = effN;
				warnText = species + ' spawns in at most ' + effN + ' consecutive time'
					+ ( effN === 1 ? '' : 's' ) + ' in any situation, so the block was reduced from '
					+ N + ' to ' + effN + '.';
			}
			flagBest = true;
			recompute();
		}

		function setDefaults() {
			if ( !speciesEntries.length ) { return; }
			var common = {};
			[ 'Grass', 'Land', 'Water', 'Surface Water', 'Air', 'Tree Top', 'Underground', 'Seafloor' ]
				.forEach( function ( name ) {
					var idx = data.methods.indexOf( name );
					if ( idx !== -1 ) { common[ idx ] = true; }
				} );
			var pick = null;
			speciesEntries.forEach( function ( e ) {
				var isCommon = e.m.some( function ( m ) { return common[ m ]; } );
				var score = ( isCommon ? 1e6 : 0 ) + e.r;
				if ( !pick || score > pick.score ) { pick = { e: e, score: score }; }
			} );
			var se = pick.e;
			var m0 = se.m.filter( function ( m ) { return common[ m ]; } )[ 0 ];
			methodSel.value = ( m0 != null ? m0 : se.m[ 0 ] );
			if ( se.b && se.b.length ) { biomeSel.value = se.b[ 0 ]; }
			if ( se.t && se.t.length ) { timeSel.value = se.t[ 0 ]; }
			ySel.value = pickY( se );
			if ( rel.light ) { lightSel.value = ( se.l0 != null ? se.l0 : ( se.l1 != null ? se.l1 : 7 ) ); }
			if ( rel.moon && se.mp != null ) { moonSel.value = se.mp; }
		}

		function setSpecies( name ) {
			species = name;
			refreshSpecies();
			applyVisibility();
			setDefaults();
			recompute();
		}

		[ biomeSel, methodSel, timeSel, weatherSel, ySel, lightSel, moonSel, consecSel ]
			.forEach( function ( ctl ) {
				ctl.addEventListener( 'change', recompute );
				ctl.addEventListener( 'input', recompute );
			} );
		bestBtn.addEventListener( 'click', findBest );

		// ── assemble ─────────────────────────────────────────────────────
		var header = el( 'div', { class: 'scalc-header' }, [
			el( 'span', { class: 'scalc-header-title', text: 'Spawn Chance Calculator' } )
		] );
		var body = el( 'div', { class: 'scalc-body' }, [ form, meta, actions, results ] );
		root.appendChild( header );
		root.appendChild( body );

		applyVisibility();
		setDefaults();

		// Pre-fill from ?species= (link from a species page) when not fixed.
		if ( !initialSpecies ) {
			var pre = getParam( 'species' );
			if ( pre && speciesSet[ pre ] ) { speciesInput.value = pre; setSpecies( pre ); }
		}
		recompute();
	}

	function init() {
		var root = document.getElementById( 'spawn-calculator' );
		if ( !root ) { return; }
		var data = window.PixelmonSpawnData;
		if ( !data || !data.entries ) {
			root.textContent = 'Spawn calculator data failed to load.';
			return;
		}
		root.classList.add( 'scalc-ready' );
		root.innerHTML = '';
		build( root, data, root.getAttribute( 'data-species' ) || '' );
	}

	if ( document.readyState !== 'loading' ) { init(); }
	else { document.addEventListener( 'DOMContentLoaded', init ); }
}() );