@pkmn/sim 0.6.1 → 0.6.3

package/data/items.ts

@@ -4576,7 +4576,13 @@ export const Items: {[itemid: string]: ItemData} = {
 		fling: {
 			basePower: 100,
 		},
-		onUpdate(pokemon) {
+		onStart(pokemon) {
+			if (!pokemon.ignoringItem() && this.field.getPseudoWeather('trickroom')) {
+				pokemon.useItem();
+			}
+		},
+		onAnyPseudoWeatherStart() {
+			const pokemon = this.effectState.target;
 			if (this.field.getPseudoWeather('trickroom')) {
 				pokemon.useItem();
 			}

package/data/learnsets.ts

@@ -79223,7 +79223,7 @@ export const Learnsets: {[speciesid: string]: LearnsetData} = {
 			blizzard: ["8M"],
 			bodyslam: ["8M"],
 			boomburst: ["8L75"],
-			calmmind: ["8M", "8S0"],
+			calmmind: ["8M"],
 			charm: ["8M"],
 			crunch: ["8M", "8L35"],
 			darkpulse: ["8M", "8S0"],
@@ -79271,6 +79271,7 @@ export const Learnsets: {[speciesid: string]: LearnsetData} = {
 			stompingtantrum: ["8M", "8L30"],
 			substitute: ["8M"],
 			sunnyday: ["8M"],
+			switcheroo: ["8S0"],
 			taunt: ["8M"],
 			thief: ["8M"],
 			thunder: ["8M"],
@@ -79283,7 +79284,7 @@ export const Learnsets: {[speciesid: string]: LearnsetData} = {
 			wideguard: ["8L50"],
 		},
 		eventData: [
-			{generation: 8, level: 50, moves: ["recover", "calmmind", "darkpulse", "belch"], pokeball: "cherishball"},
+			{generation: 8, level: 50, moves: ["recover", "switcheroo", "darkpulse", "belch"], pokeball: "cherishball"},
 		],
 	},
 	syclant: {

package/data/mods/gen1/moves.ts

@@ -884,16 +884,6 @@ export const Moves: {[k: string]: ModdedMoveData} = {
 			status: 'par',
 		},
 	},
-	thunderwave: {
-		inherit: true,
-		accuracy: 100,
-		onTryHit(target) {
-			if (target.hasType('Ground')) {
-				this.add('-immune', target);
-				return null;
-			}
-		},
-	},
 	triattack: {
 		inherit: true,
 		onHit() {},

package/data/mods/gen1/scripts.ts

@@ -18,7 +18,7 @@ export const Scripts: ModdedBattleScriptsData = {
 		getStat(statName, unmodified) {
 			// @ts-ignore - type checking prevents 'hp' from being passed, but we're paranoid
 			if (statName === 'hp') throw new Error("Please read `maxhp` directly");
-			if (unmodified) return this.storedStats[statName];
+			if (unmodified) return this.baseStoredStats[statName];
 			return this.modifiedStats![statName];
 		},
 		// Gen 1 function to apply a stat modification that is only active until the stat is recalculated or mon switched.
@@ -46,9 +46,7 @@ export const Scripts: ModdedBattleScriptsData = {
 				changed = true;
 				// Recalculate the modified stat
 				if (i === 'evasion' || i === 'accuracy') continue;
-				let stat = this.species.baseStats[i];
-				stat = Math.floor(Math.floor(2 * stat + this.set.ivs[i] + Math.floor(this.set.evs[i] / 4)) * this.level / 100 + 5);
-				this.modifiedStats![i] = this.storedStats[i] = Math.floor(stat);
+				this.modifiedStats![i] = this.storedStats[i];
 				if (this.boosts[i] >= 0) {
 					this.modifyStat!(i, [1, 1.5, 2, 2.5, 3, 3.5, 4][this.boosts[i]]);
 				} else {
@@ -63,16 +61,13 @@ export const Scripts: ModdedBattleScriptsData = {
 				this.boosts[i] = 0;
 				// Recalculate the modified stat
 				if (i === 'evasion' || i === 'accuracy') continue;
-				let stat = this.species.baseStats[i];
-				stat = Math.floor(Math.floor(2 * stat + this.set.ivs[i] + Math.floor(this.set.evs[i] / 4)) * this.level / 100 + 5);
-				this.modifiedStats![i] = this.storedStats[i] = Math.floor(stat);
+				this.modifiedStats![i] = this.storedStats[i];
 			}
 		},
 	},
 	actions: {
 		// This function is the main one when running a move.
-		// It deals with the beforeMove and AfterMoveSelf events.
-		// This leads with partial trapping moves shennanigans after the move has been used.
+		// It deals with the beforeMove event.
 		// It also deals with how PP reduction works on gen 1.
 		runMove(moveOrMoveName, pokemon, targetLoc, sourceEffect) {
 			const target = this.battle.getTarget(pokemon, moveOrMoveName, targetLoc);
@@ -119,46 +114,79 @@ export const Scripts: ModdedBattleScriptsData = {
 				}
 			}
 			this.useMove(move, pokemon, target, sourceEffect);
-			this.battle.singleEvent('AfterMove', move, null, pokemon, target, move);
+		},
+		// This function deals with AfterMoveSelf events.
+		// This leads with partial trapping moves shenanigans after the move has been used.
+		useMove(moveOrMoveName, pokemon, target, sourceEffect) {
+			const moveResult = this.useMoveInner(moveOrMoveName, pokemon, target, sourceEffect);
 
-			// If target fainted
-			if (target && target.hp <= 0) {
-				// We remove recharge
-				if (pokemon.volatiles['mustrecharge']) pokemon.removeVolatile('mustrecharge');
-				delete pokemon.volatiles['partialtrappinglock'];
-				// We remove screens
-				target.side.removeSideCondition('reflect');
-				target.side.removeSideCondition('lightscreen');
-				pokemon.removeVolatile('twoturnmove');
-			} else if (pokemon.hp) {
-				this.battle.runEvent('AfterMoveSelf', pokemon, target, move);
+			if (!sourceEffect && this.battle.effect.id) sourceEffect = this.battle.effect;
+			const baseMove = this.battle.dex.moves.get(moveOrMoveName);
+			let move = this.battle.dex.getActiveMove(baseMove);
+			if (target === undefined) target = this.battle.getRandomTarget(pokemon, move);
+			if (move.target === 'self') {
+				target = pokemon;
 			}
-			if (pokemon.volatiles['mustrecharge']) this.battle.add('-mustrecharge', pokemon);
-
-			// For partial trapping moves, we are saving the target
-			if (move.volatileStatus === 'partiallytrapped' && target && target.hp > 0) {
-				// Let's check if the lock exists
-				if (pokemon.volatiles['partialtrappinglock'] && target.volatiles['partiallytrapped']) {
-					// Here the partialtrappinglock volatile has been already applied
-					const sourceVolatile = pokemon.volatiles['partialtrappinglock'];
-					const targetVolatile = target.volatiles['partiallytrapped'];
-					if (!sourceVolatile.locked) {
-						// If it's the first hit, we save the target
-						sourceVolatile.locked = target;
-					} else if (target !== pokemon && target !== sourceVolatile.locked) {
-						// Our target switched out! Re-roll the duration, damage, and accuracy.
-						const duration = this.battle.sample([2, 2, 2, 3, 3, 3, 4, 5]);
-						sourceVolatile.duration = duration;
-						sourceVolatile.locked = target;
-						// Duration reset thus partially trapped at 2 always.
-						targetVolatile.duration = 2;
+			if (sourceEffect) move.sourceEffect = sourceEffect.id;
+
+			this.battle.singleEvent('ModifyMove', move, null, pokemon, target, move, move);
+			if (baseMove.target !== move.target) {
+				// Target changed in ModifyMove, so we must adjust it here
+				target = this.battle.getRandomTarget(pokemon, move);
+			}
+			move = this.battle.runEvent('ModifyMove', pokemon, target, move, move);
+			if (baseMove.target !== move.target) {
+				// Check again, this shouldn't ever happen on Gen 1.
+				target = this.battle.getRandomTarget(pokemon, move);
+			}
+
+			if (move.id !== 'metronome') {
+				if (move.id !== 'mirrormove' ||
+					(!pokemon.side.foe.active[0]?.lastMove || pokemon.side.foe.active[0].lastMove?.id === 'mirrormove')) {
+					// The move is our 'final' move (a failed Mirror Move, or any move that isn't Metronome or Mirror Move).
+					this.battle.singleEvent('AfterMove', move, null, pokemon, target, move);
+
+					// If target fainted
+					if (target && target.hp <= 0) {
+						// We remove recharge
+						if (pokemon.volatiles['mustrecharge']) pokemon.removeVolatile('mustrecharge');
+						delete pokemon.volatiles['partialtrappinglock'];
+						// We remove screens
+						target.side.removeSideCondition('reflect');
+						target.side.removeSideCondition('lightscreen');
+						pokemon.removeVolatile('twoturnmove');
+					} else if (pokemon.hp) {
+						this.battle.runEvent('AfterMoveSelf', pokemon, target, move);
 					}
-				} // If we move to here, the move failed and there's no partial trapping lock.
+					if (pokemon.volatiles['mustrecharge']) this.battle.add('-mustrecharge', pokemon);
+
+					// For partial trapping moves, we are saving the target
+					if (move.volatileStatus === 'partiallytrapped' && target && target.hp > 0) {
+						// Let's check if the lock exists
+						if (pokemon.volatiles['partialtrappinglock'] && target.volatiles['partiallytrapped']) {
+							// Here the partialtrappinglock volatile has been already applied
+							const sourceVolatile = pokemon.volatiles['partialtrappinglock'];
+							const targetVolatile = target.volatiles['partiallytrapped'];
+							if (!sourceVolatile.locked) {
+								// If it's the first hit, we save the target
+								sourceVolatile.locked = target;
+							} else if (target !== pokemon && target !== sourceVolatile.locked) {
+								// Our target switched out! Re-roll the duration, damage, and accuracy.
+								const duration = this.battle.sample([2, 2, 2, 3, 3, 3, 4, 5]);
+								sourceVolatile.duration = duration;
+								sourceVolatile.locked = target;
+								// Duration reset thus partially trapped at 2 always.
+								targetVolatile.duration = 2;
+							}
+						} // If we move to here, the move failed and there's no partial trapping lock.
+					}
+				}
 			}
+			return moveResult;
 		},
 		// This is the function that actually uses the move, running ModifyMove events.
 		// It uses the move and then deals with the effects after the move.
-		useMove(moveOrMoveName, pokemon, target, sourceEffect) {
+		useMoveInner(moveOrMoveName, pokemon, target, sourceEffect) {
 			if (!sourceEffect && this.battle.effect.id) sourceEffect = this.battle.effect;
 			const baseMove = this.battle.dex.moves.get(moveOrMoveName);
 			let move = this.battle.dex.getActiveMove(baseMove);
@@ -334,6 +362,7 @@ export const Scripts: ModdedBattleScriptsData = {
 					let i: number;
 					for (i = 0; i < hits && target.hp && pokemon.hp; i++) {
 						move.hit = i + 1;
+						if (move.hit === hits) move.lastHit = true;
 						moveDamage = this.moveHit(target, pokemon, move);
 						if (moveDamage === false) break;
 						damage = (moveDamage || 0);
@@ -396,6 +425,7 @@ export const Scripts: ModdedBattleScriptsData = {
 			// We get the sub to the target to see if it existed
 			const targetSub = (target) ? target.volatiles['substitute'] : false;
 			const targetHadSub = (targetSub !== null && targetSub !== false && (typeof targetSub !== 'undefined'));
+			let targetHasSub: boolean;
 
 			if (target) {
 				hitResult = this.battle.singleEvent('TryHit', moveData, {}, target, pokemon, move);
@@ -428,6 +458,7 @@ export const Scripts: ModdedBattleScriptsData = {
 				}
 
 				if (hitResult === 0) {
+					targetHasSub = !!(target?.volatiles['substitute']);
 					target = null;
 				} else if (!hitResult) {
 					if (hitResult === false) this.battle.add('-fail', target);
@@ -557,7 +588,7 @@ export const Scripts: ModdedBattleScriptsData = {
 					return false;
 				}
 			}
-			const targetHasSub = !!(target?.volatiles['substitute']);
+			targetHasSub ??= !!(target?.volatiles['substitute']);
 
 			// Here's where self effects are applied.
 			const doSelf = (targetHadSub && targetHasSub) || !targetHadSub;
@@ -573,13 +604,16 @@ export const Scripts: ModdedBattleScriptsData = {
 			// Apply move secondaries.
 			if (moveData.secondaries) {
 				for (const secondary of moveData.secondaries) {
-					// We check here whether to negate the probable secondary status if it's para, burn, or freeze.
-					// In the game, this is checked and if true, the random number generator is not called.
-					// That means that a move that does not share the type of the target can status it.
-					// If a move that was not fire-type would exist on Gen 1, it could burn a Pokémon.
-					if (!(secondary.status && ['par', 'brn', 'frz'].includes(secondary.status) && target && target.hasType(move.type))) {
-						if (secondary.chance === undefined || this.battle.randomChance(Math.ceil(secondary.chance * 256 / 100), 256)) {
-							this.moveHit(target, pokemon, move, secondary, true, isSelf);
+					// Multi-hit moves only roll for status once
+					if (!move.multihit || move.lastHit) {
+						// We check here whether to negate the probable secondary status if it's para, burn, or freeze.
+						// In the game, this is checked and if true, the random number generator is not called.
+						// That means that a move that does not share the type of the target can status it.
+						// If a move that was not fire-type would exist on Gen 1, it could burn a Pokémon.
+						if (!(secondary.status && ['par', 'brn', 'frz'].includes(secondary.status) && target && target.hasType(move.type))) {
+							if (secondary.chance === undefined || this.battle.randomChance(Math.ceil(secondary.chance * 256 / 100), 256)) {
+								this.moveHit(target, pokemon, move, secondary, true, isSelf);
+							}
 						}
 					}
 				}
@@ -798,7 +832,7 @@ export const Scripts: ModdedBattleScriptsData = {
 			// This occurs when damage was either 2 or 3 prior to applying STAB/Type matchup, and target is 4x resistant to the move.
 			if (damage === 0) return damage;
 
-			// Apply random factor is damage is greater than 1
+			// Apply random factor if damage is greater than 1
 			if (damage > 1) {
 				damage *= this.battle.random(217, 256);
 				damage = Math.floor(damage / 255);

package/data/mods/gen2/moves.ts

@@ -415,7 +415,6 @@ export const Moves: {[k: string]: ModdedMoveData} = {
 	},
 	mimic: {
 		inherit: true,
-		accuracy: true,
 		ignoreAccuracy: undefined,
 		ignoreEvasion: undefined,
 		noSketch: true,

package/data/mods/gen2/scripts.ts

@@ -706,7 +706,7 @@ export const Scripts: ModdedBattleScriptsData = {
 				}
 			}
 
-			// Apply random factor is damage is greater than 1, except for Flail and Reversal
+			// Apply random factor if damage is greater than 1, except for Flail and Reversal
 			if (!move.noDamageVariance && damage > 1) {
 				damage *= this.battle.random(217, 256);
 				damage = Math.floor(damage / 255);

package/data/moves.ts

@@ -8707,10 +8707,16 @@ export const Moves: {[moveid: string]: MoveData} = {
 		basePower: 30,
 		basePowerCallback(pokemon, target, move) {
 			let bp = move.basePower;
-			if (pokemon.volatiles['iceball'] && pokemon.volatiles['iceball'].hitCount) {
-				bp *= Math.pow(2, pokemon.volatiles['iceball'].hitCount);
+			const iceballData = pokemon.volatiles['iceball'];
+			if (iceballData?.hitCount) {
+				bp *= Math.pow(2, iceballData.hitCount);
+			}
+			if (iceballData && pokemon.status !== 'slp') {
+				iceballData.hitCount++;
+				if (iceballData.hitCount < 5) {
+					iceballData.duration = 2;
+				}
 			}
-			if (pokemon.status !== 'slp') pokemon.addVolatile('iceball');
 			if (pokemon.volatiles['defensecurl']) {
 				bp *= 2;
 			}
@@ -8723,17 +8729,19 @@ export const Moves: {[moveid: string]: MoveData} = {
 		pp: 20,
 		priority: 0,
 		flags: {bullet: 1, contact: 1, protect: 1, mirror: 1},
+		onModifyMove(move, pokemon, target) {
+			if (pokemon.volatiles['iceball'] || pokemon.status === 'slp' || !target) return;
+			pokemon.addVolatile('iceball');
+			// @ts-ignore
+			// TS thinks pokemon.volatiles['iceball'] doesn't exist because of the condition on the return above
+			// but it does exist now because addVolatile created it
+			pokemon.volatiles['iceball'].targetSlot = move.sourceEffect ? pokemon.lastMoveTargetLoc : pokemon.getLocOf(target);
+		},
 		condition: {
-			duration: 2,
+			duration: 1,
 			onLockMove: 'iceball',
 			onStart() {
-				this.effectState.hitCount = 1;
-			},
-			onRestart() {
-				this.effectState.hitCount++;
-				if (this.effectState.hitCount < 5) {
-					this.effectState.duration = 2;
-				}
+				this.effectState.hitCount = 0;
 			},
 			onResidual(target) {
 				if (target.lastMove && target.lastMove.id === 'struggle') {
@@ -13434,7 +13442,11 @@ export const Moves: {[moveid: string]: MoveData} = {
 		priority: 0,
 		flags: {protect: 1, reflectable: 1, heal: 1},
 		onHit(target, source) {
-			if (!target.cureStatus()) return this.NOT_FAIL;
+			if (!target.cureStatus()) {
+				this.add('-fail', source);
+				this.attrLastMove('[still]');
+				return this.NOT_FAIL;
+			}
 			this.heal(Math.ceil(source.maxhp * 0.5), source);
 		},
 		secondary: null,
@@ -14390,10 +14402,16 @@ export const Moves: {[moveid: string]: MoveData} = {
 		basePower: 30,
 		basePowerCallback(pokemon, target, move) {
 			let bp = move.basePower;
-			if (pokemon.volatiles['rollout'] && pokemon.volatiles['rollout'].hitCount) {
-				bp *= Math.pow(2, pokemon.volatiles['rollout'].hitCount);
+			const rolloutData = pokemon.volatiles['rollout'];
+			if (rolloutData?.hitCount) {
+				bp *= Math.pow(2, rolloutData.hitCount);
+			}
+			if (rolloutData && pokemon.status !== 'slp') {
+				rolloutData.hitCount++;
+				if (rolloutData.hitCount < 5) {
+					rolloutData.duration = 2;
+				}
 			}
-			if (pokemon.status !== 'slp') pokemon.addVolatile('rollout');
 			if (pokemon.volatiles['defensecurl']) {
 				bp *= 2;
 			}
@@ -14405,17 +14423,19 @@ export const Moves: {[moveid: string]: MoveData} = {
 		pp: 20,
 		priority: 0,
 		flags: {contact: 1, protect: 1, mirror: 1},
+		onModifyMove(move, pokemon, target) {
+			if (pokemon.volatiles['rollout'] || pokemon.status === 'slp' || !target) return;
+			pokemon.addVolatile('rollout');
+			// @ts-ignore
+			// TS thinks pokemon.volatiles['rollout'] doesn't exist because of the condition on the return above
+			// but it does exist now because addVolatile created it
+			pokemon.volatiles['rollout'].targetSlot = move.sourceEffect ? pokemon.lastMoveTargetLoc : pokemon.getLocOf(target);
+		},
 		condition: {
-			duration: 2,
+			duration: 1,
 			onLockMove: 'rollout',
 			onStart() {
-				this.effectState.hitCount = 1;
-			},
-			onRestart() {
-				this.effectState.hitCount++;
-				if (this.effectState.hitCount < 5) {
-					this.effectState.duration = 2;
-				}
+				this.effectState.hitCount = 0;
 			},
 			onResidual(target) {
 				if (target.lastMove && target.lastMove.id === 'struggle') {

package/data/pokedex.ts

@@ -17309,7 +17309,7 @@ export const Pokedex: {[speciesid: string]: SpeciesData} = {
 	chromera: {
 		num: -60,
 		name: "Chromera",
-		types: ["Dark", "Poison"],
+		types: ["Dark", "Normal"],
 		gender: "N",
 		baseStats: {hp: 85, atk: 85, def: 115, spa: 115, spd: 100, spe: 100},
 		abilities: {0: "Color Change"},

package/data/rulesets.ts

@@ -2097,4 +2097,63 @@ export const Rulesets: {[k: string]: FormatData} = {
 			}
 		},
 	},
+	godlygiftmod: {
+		effectType: 'Rule',
+		name: "Godly Gift Mod",
+		onValidateTeam(team) {
+			const gods = new Set<string>();
+			for (const set of team) {
+				let species = this.dex.species.get(set.species);
+				if (typeof species.battleOnly === 'string') species = this.dex.species.get(species.battleOnly);
+				if (set.item && this.dex.items.get(set.item).megaStone) {
+					const item = this.dex.items.get(set.item);
+					if (item.megaEvolves === species.baseSpecies) {
+						species = this.dex.species.get(item.megaStone);
+					}
+				}
+				if (
+					['ag', 'uber'].includes(this.toID(this.ruleTable.has('standardnatdex') ? species.natDexTier : species.tier)) ||
+					this.toID(set.ability) === 'powerconstruct'
+				) {
+					gods.add(species.name);
+				}
+			}
+			if (gods.size > 1) {
+				return [`You have too many Gods.`, `(${Array.from(gods).join(', ')} are Gods.)`];
+			}
+		},
+		onModifySpeciesPriority: 3,
+		onModifySpecies(species, target, source) {
+			if (source || !target?.side) return;
+			const god = target.side.team.find(set => {
+				let godSpecies = this.dex.species.get(set.species);
+				const isNatDex = this.format.ruleTable?.has('standardnatdex');
+				const validator = this.dex.formats.getRuleTable(
+					this.dex.formats.get(`gen${this.gen}${isNatDex && this.gen >= 8 ? 'nationaldex' : 'ou'}`)
+				);
+				if (this.toID(set.ability) === 'powerconstruct') {
+					return true;
+				}
+				if (set.item) {
+					const item = this.dex.items.get(set.item);
+					if (item.megaEvolves === set.species) godSpecies = this.dex.species.get(item.megaStone);
+				}
+				const isBanned = validator.isBannedSpecies(godSpecies);
+				return isBanned;
+			}) || target.side.team[0];
+			const stat = Dex.stats.ids()[target.side.team.indexOf(target.set)];
+			const newSpecies = this.dex.deepClone(species);
+			let godSpecies = this.dex.species.get(god.species);
+			if (typeof godSpecies.battleOnly === 'string') {
+				godSpecies = this.dex.species.get(godSpecies.battleOnly);
+			}
+			newSpecies.bst -= newSpecies.baseStats[stat];
+			newSpecies.baseStats[stat] = godSpecies.baseStats[stat];
+			if (this.gen === 1 && (stat === 'spa' || stat === 'spd')) {
+				newSpecies.baseStats['spa'] = newSpecies.baseStats['spd'] = godSpecies.baseStats[stat];
+			}
+			newSpecies.bst += newSpecies.baseStats[stat];
+			return newSpecies;
+		},
+	},
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/sim",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "An automatically generated extraction of just the simulator portion of Pokémon Showdown",
   "homepage": "https://psim.us",
   "main": "build/sim/index.js",

package/sim/battle.ts

@@ -2247,13 +2247,15 @@ export class Battle {
 		// when used without an explicit target.
 
 		move = this.dex.moves.get(move);
-		if (move.target === 'adjacentAlly') {
-			const adjacentAllies = pokemon.adjacentAllies();
-			return adjacentAllies.length ? this.sample(adjacentAllies) : null;
-		}
 		if (['self', 'all', 'allySide', 'allyTeam', 'adjacentAllyOrSelf'].includes(move.target)) {
 			return pokemon;
+		} else if (move.target === 'adjacentAlly') {
+			if (this.gameType === 'singles') return null;
+			const adjacentAllies = pokemon.adjacentAllies();
+			return adjacentAllies.length ? this.sample(adjacentAllies) : null;
 		}
+		if (this.gameType === 'singles') return pokemon.side.foe.active[0];
+
 		if (this.activePerHalf > 2) {
 			if (move.target === 'adjacentFoe' || move.target === 'normal' || move.target === 'randomNormal') {
 				// even if a move can target an ally, auto-resolution will never make it target an ally

package/sim/dex-conditions.ts

@@ -390,6 +390,7 @@ export interface EventMethods {
 	onAnyNegateImmunity?: ((this: Battle, pokemon: Pokemon, type: string) => boolean | void) | boolean;
 	onAnyOverrideAction?: (this: Battle, pokemon: Pokemon, target: Pokemon, move: ActiveMove) => string | void;
 	onAnyPrepareHit?: CommonHandlers['ResultSourceMove'];
+	onAnyPseudoWeatherStart?: (this: Battle, target: Pokemon, source: Pokemon, pseudoWeather: Condition) => void;
 	onAnyRedirectTarget?: (
 		this: Battle, target: Pokemon, source: Pokemon, source2: Effect, move: ActiveMove
 	) => Pokemon | void;

package/sim/field.ts

@@ -218,6 +218,7 @@ export class Field {
 			delete this.pseudoWeather[status.id];
 			return false;
 		}
+		this.battle.runEvent('PseudoWeatherStart', source, source, status);
 		return true;
 	}
 

package/sim/pokemon.ts

@@ -1180,6 +1180,7 @@ export class Pokemon {
 		let statName: StatIDExceptHP;
 		for (statName in this.storedStats) {
 			this.storedStats[statName] = pokemon.storedStats[statName];
+			if (this.modifiedStats) this.modifiedStats[statName] = pokemon.modifiedStats![statName]; // Gen 1: Copy modified stats.
 		}
 		this.moveSlots = [];
 		this.set.ivs = (this.battle.gen >= 5 ? this.set.ivs : pokemon.set.ivs);
@@ -1204,14 +1205,6 @@ export class Pokemon {
 		let boostName: BoostID;
 		for (boostName in pokemon.boosts) {
 			this.boosts[boostName] = pokemon.boosts[boostName];
-			if (this.battle.gen <= 1) {
-				if (boostName === 'evasion' || boostName === 'accuracy') continue;
-				if (this.boosts[boostName] >= 0) {
-					this.modifyStat!(boostName, [1, 1.5, 2, 2.5, 3, 3.5, 4][this.boosts[boostName]]);
-				} else {
-					this.modifyStat!(boostName, [100, 66, 50, 40, 33, 28, 25][-this.boosts[boostName]] / 100);
-				}
-			}
 		}
 		if (this.battle.gen >= 6) {
 			const volatilesToCopy = ['focusenergy', 'gmaxchistrike', 'laserfocus'];

package/sim/team-validator.ts

@@ -687,7 +687,7 @@ export class TeamValidator {
 			const {species: eventSpecies, eventData} = eventOnlyData;
 			let legal = false;
 			for (const event of eventData) {
-				if (this.validateEvent(set, event, eventSpecies)) continue;
+				if (this.validateEvent(set, setSources, event, eventSpecies)) continue;
 				legal = true;
 				break;
 			}
@@ -698,20 +698,19 @@ export class TeamValidator {
 				if (eventData.length === 1) {
 					problems.push(`${species.name} is only obtainable from an event - it needs to match its event:`);
 				} else {
-					problems.push(`${species.name} is only obtainable from events - it needs to match one of its events, such as:`);
+					problems.push(`${species.name} is only obtainable from events - it needs to match one of its events:`);
 				}
-				let eventInfo = eventData[0];
-				let eventNum = 1;
 				for (const [i, event] of eventData.entries()) {
 					if (event.generation <= dex.gen && event.generation >= this.minSourceGen) {
-						eventInfo = event;
-						eventNum = i + 1;
-						break;
+						const eventInfo = event;
+						const eventNum = i + 1;
+						const eventName = eventData.length > 1 ? ` #${eventNum}` : ``;
+						const eventProblems = this.validateEvent(
+							set, setSources, eventInfo, eventSpecies, ` to be`, `from its event${eventName}`
+						);
+						if (eventProblems) problems.push(...eventProblems);
 					}
 				}
-				const eventName = eventData.length > 1 ? ` #${eventNum}` : ``;
-				const eventProblems = this.validateEvent(set, eventInfo, eventSpecies, ` to be`, `from its event${eventName}`);
-				if (eventProblems) problems.push(...eventProblems);
 			}
 		}
 
@@ -1102,7 +1101,7 @@ export class TeamValidator {
 		}
 
 		// complicated fancy return signature
-		return this.validateEvent(set, eventData, eventSpecies, because as any) as any;
+		return this.validateEvent(set, setSources, eventData, eventSpecies, because as any) as any;
 	}
 
 	findEggMoveFathers(source: PokemonSource, species: Species, setSources: PokemonSources): boolean;
@@ -1674,16 +1673,22 @@ export class TeamValidator {
 		return null;
 	}
 
-	validateEvent(set: PokemonSet, eventData: EventInfo, eventSpecies: Species): true | undefined;
 	validateEvent(
-		set: PokemonSet, eventData: EventInfo, eventSpecies: Species, because: string, from?: string
+		set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species
+	): true | undefined;
+	validateEvent(
+		set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species,
+		because: string, from?: string
 	): string[] | undefined;
 	/**
 	 * Returns array of error messages if invalid, undefined if valid
 	 *
 	 * If `because` is not passed, instead returns true if invalid.
 	 */
-	validateEvent(set: PokemonSet, eventData: EventInfo, eventSpecies: Species, because = ``, from = `from an event`) {
+	validateEvent(
+		set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species,
+		because = ``, from = `from an event`
+	) {
 		const dex = this.dex;
 		let name = set.species;
 		const species = dex.species.get(set.species);
@@ -1784,8 +1789,15 @@ export class TeamValidator {
 				problems.push(`${name} can only use Hidden Power Dark/Dragon/Electric/Steel/Ice because it must have at least 5 perfect IVs${etc}.`);
 			}
 		}
-		// Event-related ability restrictions only matter if we care about illegal abilities
 		const ruleTable = this.ruleTable;
+		if (ruleTable.has('obtainablemoves')) {
+			const ssMaxSourceGen = setSources.maxSourceGen();
+			const tradebackEligible = dex.gen === 2 && species.gen === 1;
+			if (ssMaxSourceGen && eventData.generation > ssMaxSourceGen && !tradebackEligible) {
+				if (fastReturn) return true;
+				problems.push(`${name} must not have moves only learnable in gen ${ssMaxSourceGen}${etc}.`);
+			}
+		}
 		if (ruleTable.has('obtainableabilities')) {
 			if (dex.gen <= 5 && eventData.abilities && eventData.abilities.length === 1 && !eventData.isHidden) {
 				if (species.name === eventSpecies.name) {