Working smoke test, needs polish and for smogon#5370 to land

Author: scheibo

dev-tools/harness.js

@@ -22,7 +22,7 @@ const PRNG = require('../.sim-dist/prng').PRNG;
 const RandomPlayerAI = require('../.sim-dist/examples/random-player-ai').RandomPlayerAI;
 
 // 'move' 70% of the time (ie. 'switch' 30%) and ' mega' 60% of the time that its an option.
-const AI_OPTIONS = {move: 0.7, mega: 0.6};
+const AI_OPTIONS = {move: 0.7, mega: 0.6, createAI: (s, o) => new RandomPlayerAI(s, o)};
 
 class Runner {
 	constructor(options) {
@@ -55,9 +55,9 @@ class Runner {
 		const p1spec = this.getPlayerSpec("Bot 1", this.p1options);
 		const p2spec = this.getPlayerSpec("Bot 2", this.p2options);
 
-		const p1 = new RandomPlayerAI(
+		const p1 = this.p1options.createAI(
 			streams.p1, Object.assign({seed: this.newSeed()}, this.p1options)).start();
-		const p2 = new RandomPlayerAI(
+		const p2 = this.p2options.createAI(
 			streams.p2, Object.assign({seed: this.newSeed()}, this.p2options)).start();
 
 		streams.omniscient.write(`>start ${JSON.stringify(spec)}\n` +

dev-tools/smoke.js

@@ -10,43 +10,37 @@ if (require.main === module) shell('node ../build');
 const Dex = require('../.sim-dist/dex');
 const PRNG = require('../.sim-dist/prng').PRNG;
 const RandomPlayerAI = require('../.sim-dist/examples/random-player-ai').RandomPlayerAI;
+const toId = Dex.getId;
 
 class TeamGenerator {
-	constructor(mod, prng, nonStandard) {
-		const dex = Dex.mod(mod);
+	constructor(dex, prng, pools) {
 		this.dex = dex;
 		this.prng = prng && !Array.isArray(prng) ? prng : new PRNG(prng);
-		this.nonStandard = !!nonStandard;
-
-		this.pokemon = new Pool(this.onlyValid(dex.data.Pokedex, p => dex.getTemplate(p),
-			(_, p) => (p.species !== 'Pichu-Spiky-eared' && p.species.substr(0, 8) !== 'Pikachu-')), this.prng);
-		this.items = new Pool(this.onlyValid(dex.data.Items, i => dex.getItem(i)), this.prng);
-		this.abilities = new Pool(this.onlyValid(dex.data.Abilities, a => dex.getAbility(a)), this.prng);
-		this.moves = new Pool(this.onlyValid(dex.data.Movedex, m => dex.getMove(m),
-			m => (m === 'hiddenpower' || m.substr(0, 11) !== 'hiddenpower')), this.prng);
+		this.pools = pools;
+
 		this.natures = Object.keys(this.dex.data.Natures);
 	}
 
 	get exhausted() {
-		const exhausted = [this.pokemon.exhausted, this.moves.exhausted];
-		if (this.dex.gen >= 2) exhausted.push(this.items.exhausted);
-		if (this.dex.gen >= 3) exhausted.push(this.abilities.exhausted);
+		const exhausted = [this.pools.pokemon.exhausted, this.pools.moves.exhausted];
+		if (this.dex.gen >= 2) exhausted.push(this.pools.items.exhausted);
+		if (this.dex.gen >= 3) exhausted.push(this.pools.abilities.exhausted);
 		return Math.min.apply(null, exhausted);
 	}
 
 	generate() {
 		const team = [];
-		for (let pokemon of this.pokemon.next(6)) {
+		for (let pokemon of this.pools.pokemon.next(6)) {
 			const template = this.dex.getTemplate(pokemon);
 			const randomEVs = () => this.prng.next(253);
 			const randomIVs = () => this.prng.next(32);
 			team.push({
 				name: template.baseSpecies,
 				species: template.species,
 				gender: template.gender,
-				item: this.dex.gen >= 2 ? this.items.next() : '',
-				ability: this.dex.gen >= 3 ? this.abilities.next() : 'None',
-				moves: this.moves.next(4),
+				item: this.dex.gen >= 2 ? this.pools.items.next() : '',
+				ability: this.dex.gen >= 3 ? this.pools.abilities.next() : 'None',
+				moves: this.pools.moves.next(4),
 				evs: {
 					hp: randomEVs(),
 					atk: randomEVs(),
@@ -64,76 +58,161 @@ class TeamGenerator {
 					spe: randomIVs(),
 				},
 				nature: this.prng.sample(this.natures),
-				level: this.prng.next(70, 100),
+				level: this.prng.next(50, 100),
 				happiness: this.prng.next(256),
 				shiny: this.prng.randomChance(1, 1024),
 			});
 		}
 		return team;
 	}
-
-	onlyValid(obj, getter, additional) {
-		return Object.keys(obj).filter(k => {
-			const v = getter(k);
-			return v.gen <= this.dex.gen &&
-				(!v.isNonstandard || this.nonStandard) &&
-				(!additional || additional(k, v));
-		});
-	}
 }
 
 class Pool {
 	constructor(possible, prng) {
 		this.possible = possible;
 		this.prng = prng;
-
-		this.remaining = this.possible.slice();
 		this.exhausted = 0;
+
+		this.reset();
+	}
+
+	toString() {
+		return `${this.exhausted} (${this.unused.size}/${this.possible.length})`;
+	}
+
+	reset() {
+		this.iter = undefined;
+		this.unused = new Set(this.shuffle(this.possible));
+		if (this.filled) {
+			for (let used of this.filled) {
+				this.unused.delete(used);
+			}
+			this.filled = new Set();
+			if (!this.unused.size) {
+				this.exhausted++;
+				this.reset();
+			}
+		} else {
+			this.filled = new Set();
+		}
+		this.filler = this.possible.slice();
+		// POST: this.unused.size > 0
+		// POST: this.filler.length > 0
+		// POST: this.filled.size === 0
+		// POST: this.iter === undefined
+	}
+
+	shuffle(arr) {
+		for (let i = arr.length - 1; i > 0; i--) {
+			const j = Math.floor(this.prng.next() * (i + 1));
+			[arr[i], arr[j]] = [arr[j], arr[i]];
+		}
+		return arr;
+	}
+
+	wasUsed(k) {
+		// NOTE: We are intentionally clearing our iterator even though `unused`
+		// hasn't been modified, see explanation below.
+		this.iter = undefined;
+		return !this.unused.has(k);
+	}
+
+	markUsed(k) {
+		this.iter = undefined;
+		this.unused.delete(k);
 	}
 
 	next(num) {
+		if (!num) return this.choose();
 		const chosen = [];
-		do {
-			if (!this.remaining.length) {
-				this.exhausted++;
-				this.remaining = this.possible.slice();
+		for (let i = 0; i < num; i++) {
+			chosen.push(this.choose());
+		}
+		return chosen;
+	}
+
+	// Returns the next option in our set of unused options which were shuffled
+	// before insertion so as to come out in random order. The iterator is
+	// reset when the pools are manipulated by the CombinedPlayerAI (`markUsed`
+	// as it mutates the set, but also `wasUsed` because resetting the
+	// iterator isn't so much 'marking it as invalid' as 'signalling that we
+	// should move the unused options to the top again').
+	//
+	// As the pool of options dwindles, we run into scenarios where `choose`
+	// will keep returning the same options. This helps ensure they get used,
+	// but having a game with every Pokemon having the same move or ability etc
+	// is less realistic, so instead we 'fill' out the remaining choices during a
+	// generator round (ie. until our iterator gets invalidated during gameplay).
+	//
+	// The 'filler' choices are tracked in `filled` to later subtract from the next
+	// exhaustion cycle of this pool, but in theory we could be so unlucky that
+	// we loop through our fillers multiple times while dealing with a few stubborn
+	// remaining options in `unused`, therefore undercounting our `exhausted` total,
+	// but this is considered to be unlikely enough that we don't care (and
+	// `exhausted` is a lower bound anyway).
+	choose() {
+		if (!this.unused.size) {
+			this.exhausted++;
+			this.reset();
+		}
+
+		if (this.iter) {
+			if (!this.iter.done) {
+				const next = this.iter.next();
+				this.iter.done = next.done;
+				if (!next.done) return next.value;
 			}
-			chosen.push(this.choose(this.remaining));
-		// eslint-disable-next-line
-		} while (!chosen.length || (num && chosen.length < num));
-		return num ? chosen : chosen[0];
+			return this.fill();
+		}
+
+		this.iter = this.unused.values();
+		const next = this.iter.next();
+		this.iter.done = next.done;
+		// this.iter.next() must have a value (!this.iter.done) because this.unused.size > 0
+		// after this.reset(), and the only places that mutate this.unused clear this.iter.
+		return next.value;
 	}
 
-	choose(list) {
-		const length = list.length;
+	fill() {
+		let length = this.filler.length;
+		if (!length) {
+			this.filler = this.possible.slice();
+			length = this.filler.length;
+		}
 		const index = this.prng.next(length);
-		const element = list[index];
-		list[index] = list[length - 1];
-		list.pop();
+		const element = this.filler[index];
+		this.filler[index] = this.filler[length - 1];
+		this.filler.pop();
+		this.filled.add(element);
 		return element;
 	}
 }
 
-// TODO: make sure all ids
+// Random AI which shares pools with the TeamGenerator to coordinate creating battle simulations
+// that test out as many different Pokemon/Species/Items/Moves as possible. The logic is still
+// random, so it's not going to optimally use as many new effects as would be possible, but it
+// should exhaust its pools much faster than the naive RandomPlayerAI alone.
+//
+// NOTE: We're tracking 'usage' when we make the choice and not what actually gets used in Battle.
+// These can differ in edge cases and so its possible we report that we've 'used' every option
+// when we haven't (for example, we may switch in a Pokemon with an ability, but we're not guaranteeing
+// the ability activates, etc).
 class CoordinatedPlayerAI extends RandomPlayerAI {
-	constructor(playerStream, options, pokemon, abilities, items, moves) {
+	constructor(playerStream, options, pools) {
 		super(playerStream, options);
-		this.pokemon = pokemon;
-		this.abilities = abilities;
-		this.moves = moves;
-		this.items = items; // TODO: reconcile Set and Array!
+		this.pools = pools;
 	}
 
 	chooseTeamPreview(team) {
-		return this.choosePokemon(team.map((p, i) => ({slot: i + 1, pokemon: p}))) || `default`;
+		return `${this.choosePokemon(team.map((p, i) => ({slot: i + 1, pokemon: p}))) || 1}`;
 	}
 
 	chooseMove(moves) {
 		// Prefer to use a move which hasn't been used yet.
 		for (const {choice, move} of moves) {
-			const id = move.id.startsWith('hiddenpower') ? 'hiddenpower' : move.id;
-			if (this.moves.includes(id)) {
-				this.moves.remove(id);
+			const id = this.fixMove(move);
+			if (!this.pools.moves.wasUsed(id)) {
+				this.pools.moves.markUsed(id);
 				return choice;
 			}
 		}
@@ -147,49 +226,88 @@ class CoordinatedPlayerAI extends RandomPlayerAI {
 	choosePokemon(choices) {
 		// Prefer to choose a Pokemon that has a species/ability/item/move we haven't seen yet.
 		for (const {slot, pokemon} of choices) {
-			const species = Dex.toId(pokemon.details.split(',')[0]);
-			if (this.pokemon.includes(species) ||
-					this.abilities.includes(pokemon.baseAbility) ||
-					this.items.includes(pokemon.item) ||
-					pokemon.moves.some(m => this.moves.includes(m.id.startsWith('hiddenpower') ? 'hiddenpower' : m.id))) {
-				this.pokemon.remove(species);
-				this.abilities.remove(pokemon.baseAbility);
-				this.items.remove(pokemon.item);
+			const species = toId(pokemon.details.split(',')[0]);
+			if (!this.pools.pokemon.wasUsed(species) ||
+					!this.pools.abilities.wasUsed(pokemon.baseAbility) ||
+					!this.pools.items.wasUsed(pokemon.item) ||
+					pokemon.moves.some(m => !this.pools.moves.wasUsed(this.fixMove(m)))) {
+				this.pools.pokemon.markUsed(species);
+				this.pools.abilities.markUsed(pokemon.baseAbility);
+				this.pools.items.markUsed(pokemon.item);
 				return slot;
 			}
 		}
 	}
+
+	// The move options provided by the simulator have been converted from the name
+	// which we're tracking, so we need to convert them back;
+	fixMove(m) {
+		const id = toId(m.move);
+		if (id.startsWith('return')) return 'return';
+		if (id.startsWith('frustration')) return 'frustration';
+		if (id.startsWith('hiddenpower')) return 'hiddenpower';
+		return id;
+	}
+}
+
+function createPools(dex, prng) {
+	return {
+		pokemon: new Pool(onlyValid(dex.gen, dex.data.Pokedex, p => dex.getTemplate(p),
+			(_, p) => (p.species !== 'Pichu-Spiky-eared' && p.species.substr(0, 8) !== 'Pikachu-')), prng),
+		items: new Pool(onlyValid(dex.gen, dex.data.Items, i => dex.getItem(i)), prng),
+		abilities: new Pool(onlyValid(dex.gen, dex.data.Abilities, a => dex.getAbility(a)), prng),
+		moves: new Pool(onlyValid(dex.gen, dex.data.Movedex, m => dex.getMove(m),
+			m => (m === 'hiddenpower' || m.substr(0, 11) !== 'hiddenpower')), prng),
+	};
+}
+
+function onlyValid(gen, obj, getter, additional, nonStandard) {
+	return Object.keys(obj).filter(k => {
+		const v = getter(k);
+		return v.gen <= gen &&
+			(!v.isNonstandard || !!nonStandard) &&
+			(!additional || additional(k, v));
+	});
 }
 
 if (require.main === module) {
-	const Runner = require('./runner');
+	Dex.includeModData();
+	const Runner = require('./harness');
 
+	// Because of our handwavey accounting of 'usage', as well as to account for ordering effects and
+	// the interplay of various combinations, we should actually run multiple cycles of exhausting our
+	// pools to provide more confidence that we're actually smoking out issues.
 	const CYCLES = Number(process.argv[2]) || 1;
 	const MODS = ['gen1', 'gen2', 'gen3', 'gen4', 'gen5', 'gen6', 'gen7'];
-	const prng = new PRNG();
-	const games = [];
 
-	for (let mod of MODS) {
-		const generator = new TeamGenerator(mod, prng);
-		do {
-			games.push(new Runner({
-				prng,
-				p1options: {team: generator.generate()},
-				p2options: {team: generator.generate()},
-				format: `${mod}customgame`,
-				error: true,
-			}).run());
-		} while (generator.exhausted < CYCLES);
-	}
+	const prng = new PRNG();
 
 	(async () => {
 		let failures = 0;
-		for (let game of games) {
-			try {
-				await game;
-			} catch (err) {
-				failures++;
-			}
+		for (let mod of MODS) {
+			const dex = Dex.mod(mod);
+			const pools = createPools(dex, prng);
+			const createAI = (s, o) => new CoordinatedPlayerAI(s, o, pools);
+			const generator = new TeamGenerator(dex, prng, pools);
+			let games = 0;
+			do {
+				games++;
+				try {
+					// We run these sequentially instead of async so that the team generator
+					// and the AI can coordinate usage properly.
+					await new Runner({
+						prng,
+						p1options: {team: generator.generate(), createAI},
+						p2options: {team: generator.generate(), createAI},
+						format: `${mod}customgame`,
+						error: true,
+					}).run();
+					//console.log(`[${mod}] P:${pools.pokemon} I:${pools.items} A:${pools.abilities} M:${pools.moves} = ${games}`);
+				} catch (err) {
+					console.error(err); // TODO
+					failures++;
+				}
+			} while (generator.exhausted < CYCLES);
 		}
 		process.exit(failures);
 	})();