data/mods/gen1/scripts.ts

/**
 * Gen 1 mechanics are fairly different to those we know on current gen.
 * Therefor we need to make a lot of changes to the battle engine for this game simulation.
 * This generation inherits all the changes from older generations, that must be taken into account when editing code.
 */

const SKIP_LASTDAMAGE = new Set([
	'confuseray', 'conversion', 'counter', 'focusenergy', 'glare', 'haze', 'leechseed', 'lightscreen',
	'mimic', 'mist', 'poisongas', 'poisonpowder', 'recover', 'reflect', 'rest', 'softboiled',
	'splash', 'stunspore', 'substitute', 'supersonic', 'teleport', 'thunderwave', 'toxic', 'transform',
]);

const TWO_TURN_MOVES = ['dig', 'fly', 'razorwind', 'skullbash', 'skyattack', 'solarbeam'];

export const Scripts: ModdedBattleScriptsData = {
	inherit: 'gen2',
	gen: 1,
	init() {
		for (const i in this.data.Pokedex) {
			const poke = this.modData('Pokedex', i);
			poke.gender = 'N';
			poke.eggGroups = null;
		}
	},
	// BattlePokemon scripts.
	pokemon: {
		inherit: true,
		getStat(statName, unmodified) {
			// @ts-expect-error 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.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.
		modifyStat(statName, modifier) {
			if (!(statName in this.storedStats)) throw new Error("Invalid `statName` passed to `modifyStat`");
			const modifiedStats = this.battle.clampIntRange(Math.floor(this.modifiedStats![statName] * modifier), 1);
			this.modifiedStats![statName] = modifiedStats;
		},
		// In generation 1, boosting function increases the stored modified stat and checks for opponent's status.
		boostBy(boost) {
			let changed: boolean | number = false;
			let i: BoostID;
			for (i in boost) {
				const delta = boost[i];
				if (delta === undefined) continue;
				if (delta > 0 && this.boosts[i] >= 6) continue;
				if (delta < 0 && this.boosts[i] <= -6) continue;
				if (i === 'evasion' || i === 'accuracy') {
					this.boosts[i] += delta;
					if (this.boosts[i] > 6) {
						this.boosts[i] = 6;
					}
					if (this.boosts[i] < -6) {
						this.boosts[i] = -6;
					}
					changed = true;
					continue;
				}
				// Stat being modified is not evasion or accuracy, so change modifiedStats.
				if (delta > 0) {
					if (this.modifiedStats![i] === 999) {
						// Intended max stat value
						this.boosts[i] += delta;
						if (this.boosts[i] > 6) {
							this.boosts[i] = 6;
						}
						this.boosts[i]--;
						// changed = 0 corresponds to increasing stats at 999 (or decreasing at 1).
						changed = 0;
					} else {
						this.boosts[i] += delta;
						if (this.boosts[i] > 6) {
							this.boosts[i] = 6;
						}
						changed = true;
					}
				}
				if (delta < 0) {
					if (this.modifiedStats![i] === 1) {
						// Minimum stat value
						this.boosts[i] += delta;
						if (this.boosts[i] < -6) {
							this.boosts[i] = -6;
						}
						this.boosts[i]++;
						// changed = 0 corresponds to increasing stats at 999 (or decreasing at 1).
						changed = 0;
					} else {
						this.boosts[i] += delta;
						if (this.boosts[i] < -6) {
							this.boosts[i] = -6;
						}
						changed = true;
					}
				}
				if (changed) {
					// Recalculate the modified 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 {
						this.modifyStat!(i, [100, 66, 50, 40, 33, 28, 25][-this.boosts[i]] / 100);
					}
					if (delta > 0 && this.modifiedStats![i] > 999) {
						// Cap the stat at 999
						this.modifiedStats![i] = 999;
					}
				}
			}
			return changed;
		},
		clearBoosts() {
			let i: BoostID;
			for (i in this.boosts) {
				this.boosts[i] = 0;
				// Recalculate the modified stat
				if (i === 'evasion' || i === 'accuracy') continue;
				this.modifiedStats![i] = this.storedStats[i];
			}
		},
	},
	actions: {
		inherit: true,
		// This function is the main one when running a move.
		// It deals with the beforeMove event.
		// It also deals with how PP reduction works on gen 1.
		runMove(moveOrMoveName, pokemon, targetLoc, options) {
			let sourceEffect = options?.sourceEffect;
			const target = this.battle.getTarget(pokemon, moveOrMoveName, targetLoc);
			let move = this.battle.dex.getActiveMove(moveOrMoveName);

			// If a faster partial trapping move misses against a user of Hyper Beam during a recharge turn,
			// the user of Hyper Beam will automatically use Hyper Beam during that turn.
			const autoHyperBeam = (
				move.id === 'recharge' && !pokemon.volatiles['mustrecharge'] && !pokemon.volatiles['partiallytrapped']
			);
			if (autoHyperBeam) {
				move = this.battle.dex.getActiveMove('hyperbeam');
				this.battle.hint(`In Gen 1, If a faster partial trapping move misses against a user of Hyper Beam during a recharge turn, ` +
					`the user of Hyper Beam will automatically use Hyper Beam during that turn.`, true);
			}

			if (target?.subFainted) target.subFainted = null;

			this.battle.setActiveMove(move, pokemon, target);

			if (pokemon.moveThisTurn || !this.battle.runEvent('BeforeMove', pokemon, target, move)) {
				this.battle.clearActiveMove(true);
				// This is only run for sleep.
				this.battle.runEvent('AfterMoveSelf', pokemon, target, move);
				return;
			}
			if (move.beforeMoveCallback) {
				if (move.beforeMoveCallback.call(this.battle, pokemon, target, move)) {
					this.battle.clearActiveMove(true);
					return;
				}
			}
			let lockedMove = this.battle.runEvent('LockMove', pokemon);
			if (lockedMove === true) lockedMove = false;
			if (
				!lockedMove &&
				(!pokemon.volatiles['partialtrappinglock'] || pokemon.volatiles['partialtrappinglock'].locked !== target)
			) {
				pokemon.deductPP(move, null, target);
			} else {
				sourceEffect = move;
				if (pokemon.volatiles['twoturnmove']) {
					// Two-turn moves like Sky Attack deduct PP on their second turn.
					pokemon.deductPP(pokemon.volatiles['twoturnmove'].originalMove, null, target);
				}
			}
			if (
				(pokemon.volatiles['partialtrappinglock'] && target !== pokemon.volatiles['partialtrappinglock'].locked) ||
				autoHyperBeam
			) {
				const moveSlot = pokemon.moveSlots.find(ms => ms.id === move.id);
				if (moveSlot && moveSlot.pp < 0) {
					moveSlot.pp = 63;
					this.battle.hint("In Gen 1, if a player is forced to use a move with 0 PP, the move will underflow to have 63 PP.");
				}
			}
			this.useMove(move, pokemon, { target, sourceEffect });
			// Restore PP if the move is the first turn of a charging move. Save the move from which PP should be deducted if the move succeeds.
			if (pokemon.volatiles['twoturnmove']) {
				pokemon.deductPP(move, -1, target);
				pokemon.volatiles['twoturnmove'].originalMove = move.id;
			}
		},
		// This function deals with AfterMoveSelf events.
		// This leads with partial trapping moves shenanigans after the move has been used.
		useMove(moveOrMoveName, pokemon, options) {
			let sourceEffect = options?.sourceEffect;
			let target = options?.target;
			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 (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);
			}
			// The charging turn of a two-turn move does not update pokemon.lastMove
			if (!TWO_TURN_MOVES.includes(move.id) || pokemon.volatiles['twoturnmove']) pokemon.lastMove = move;

			const moveResult = this.useMoveInner(moveOrMoveName, pokemon, { target, sourceEffect });

			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).
					pokemon.side.lastMove = move;

					if (pokemon.volatiles['lockedmove']?.time <= 0) pokemon.removeVolatile('lockedmove');

					// If target fainted
					if (target && target.hp <= 0) {
						// We remove recharge
						if (pokemon.volatiles['mustrecharge']) pokemon.removeVolatile('mustrecharge');
						delete pokemon.volatiles['partialtrappinglock'];
					} else {
						if (pokemon.volatiles['mustrecharge']) this.battle.add('-mustrecharge', pokemon);
						if (pokemon.hp) this.battle.runEvent('AfterMoveSelf', pokemon, target, move);
					}

					// 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.
		useMoveInner(moveOrMoveName, pokemon, options) {
			let sourceEffect = options?.sourceEffect;
			let target = options?.target;
			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 (sourceEffect) move.sourceEffect = sourceEffect.id;

			this.battle.setActiveMove(move, pokemon, target);

			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);
				this.battle.debug('not a gen 1 mechanic');
			}
			if (!move) return false;

			let attrs = '';
			if (pokemon.fainted) {
				return false;
			}

			if (sourceEffect) attrs += `|[from]${this.battle.dex.conditions.get(sourceEffect)}`;
			this.battle.addMove('move', pokemon, move.name, `${target}${attrs}`);

			if (!this.battle.singleEvent('Try', move, null, pokemon, target, move)) {
				return true;
			}
			if (!this.battle.singleEvent('TryMove', move, null, pokemon, target, move) ||
				!this.battle.runEvent('TryMove', pokemon, target, move)) {
				return true;
			}

			if (move.ignoreImmunity === undefined) {
				move.ignoreImmunity = (move.category === 'Status');
			}

			let damage: number | undefined | false | '' = false;
			if (!target || target.fainted) {
				this.battle.attrLastMove('[notarget]');
				this.battle.add('-notarget');
				return true;
			}
			// Store 0 damage for last damage if the move is not in the array.
			if (!SKIP_LASTDAMAGE.has(move.id)) this.battle.lastDamage = 0;

			damage = this.tryMoveHit(target, pokemon, move);

			// Disable and Selfdestruct/Explosion boost rage, regardless of whether they miss/fail.
			if (target.boosts.atk < 6 && (move.selfdestruct || move.id === 'disable') && target.volatiles['rage']) {
				this.battle.boost({ atk: 1 }, target, pokemon, this.dex.conditions.get('rage'));
				this.battle.hint(`In Gen 1, using ${move.name} causes the target to build Rage, ` +
					`even if it misses or fails`, true);
			}

			// Go ahead with results of the used move.
			if (damage === false) {
				this.battle.singleEvent('MoveFail', move, null, target, pokemon, move);
				return true;
			}

			if (!move.negateSecondary) {
				this.battle.singleEvent('AfterMoveSecondarySelf', move, null, pokemon, target, move);
				this.battle.runEvent('AfterMoveSecondarySelf', pokemon, target, move);
			}
			return true;
		},
		// This function attempts a move hit and returns the attempt result before the actual hit happens.
		// It deals with partial trapping weirdness and accuracy bugs as well.
		tryMoveHit(target, pokemon, move) {
			let damage: number | false | undefined = 0;

			// Add Thrashing effect before the move does damage, or add confusion if Thrash effect is ending
			if (move?.self?.volatileStatus === 'lockedmove') {
				if (pokemon.volatiles['lockedmove']) {
					pokemon.volatiles['lockedmove'].time--;
					if (!pokemon.volatiles['lockedmove'].time) {
						// Confusion begins even if already confused.
						// Remove lockedmove volatile when dealing with after move effects.
						delete pokemon.volatiles['confusion'];
						pokemon.addVolatile('confusion', pokemon, this.dex.conditions.get('lockedmove'));
					}
				} else {
					pokemon.addVolatile('lockedmove', pokemon, move);
				}
			}

			// First, check if the target is semi-invulnerable
			let hitResult = this.battle.runEvent('Invulnerability', target, pokemon, move);
			if (hitResult === false) {
				this.battle.attrLastMove('[miss]');
				this.battle.add('-miss', pokemon);
				if (move.selfdestruct) {
					this.battle.faint(pokemon, pokemon, move);
				}
				return false;
			}

			// Then, check if the Pokémon is immune to this move.
			if (
				(!move.ignoreImmunity || (move.ignoreImmunity !== true && !move.ignoreImmunity[move.type])) &&
				!target.runImmunity(move.type, true)
			) {
				if (move.selfdestruct) {
					this.battle.faint(pokemon, pokemon, move);
				}
				return false;
			}
			hitResult = this.battle.singleEvent('TryImmunity', move, null, target, pokemon, move);
			if (hitResult === false) {
				this.battle.add('-immune', target);
				return false;
			}

			// Now, let's calculate the accuracy.
			let accuracy = move.accuracy;

			// Partial trapping moves: true accuracy while it lasts
			if (move.volatileStatus === 'partiallytrapped' && target === pokemon.volatiles['partialtrappinglock']?.locked) {
				accuracy = true;
			}

			// If a sleep inducing move is used while the user is recharging, the accuracy is true.
			if (move.status === 'slp' && target?.volatiles['mustrecharge']) {
				accuracy = true;
			}

			// OHKO moves only have a chance to hit if the user is at least as fast as the target
			if (move.ohko) {
				if (target.getStat('spe') > pokemon.getStat('spe')) {
					this.battle.add('-immune', target, '[ohko]');
					return false;
				}
			}

			// Calculate true accuracy for gen 1, which uses 0-255.
			// Gen 1 uses the same boost table for accuracy and evasiveness as every other stat
			const boostTable = [25, 28, 33, 40, 50, 66, 100, 150, 200, 250, 300, 350, 400];
			if (accuracy !== true) {
				accuracy = Math.floor(accuracy * 255 / 100);
				// Rage and Thrash/Petal Dance accuracy bug
				if (pokemon.volatiles['lockedmove']) accuracy = pokemon.volatiles['lockedmove'].accuracy;
				if (pokemon.volatiles['rage']) accuracy = pokemon.volatiles['rage'].accuracy;

				// This line is just to satisfy TypeScript, accuracy should never be true at this point
				if (accuracy !== true) {
					// Check also for accuracy modifiers.
					if (!move.ignoreAccuracy) {
						accuracy = Math.floor(accuracy * (boostTable[pokemon.boosts.accuracy + 6] / 100));
					}
					if (!move.ignoreEvasion) {
						accuracy = Math.floor(accuracy * (boostTable[-target.boosts.evasion + 6] / 100));
					}
					accuracy = this.battle.clampIntRange(accuracy, 1, 255);
				}
				if (pokemon.volatiles['lockedmove']) pokemon.volatiles['lockedmove'].accuracy = accuracy;
				if (pokemon.volatiles['rage']) pokemon.volatiles['rage'].accuracy = accuracy;
			}
			accuracy = this.battle.runEvent('Accuracy', target, pokemon, move, accuracy);
			// Moves that target the user do not suffer from the 1/256 miss chance.
			if (move.target === 'self' && accuracy !== true) accuracy++;
			// 1/256 chance of missing always, no matter what. Besides the aforementioned exceptions.
			if (accuracy !== true && !this.battle.randomChance(accuracy, 256)) {
				this.battle.attrLastMove('[miss]');
				this.battle.add('-miss', pokemon);
				if (accuracy === 255) this.battle.hint("In Gen 1, moves with 100% accuracy can still miss 1/256 of the time.");
				damage = false;
				this.battle.lastDamage = 0;
			}

			// If damage is 0 and not false it means it didn't miss, let's calc.
			if (damage !== false) {
				if (move.multihit) {
					let hits = move.multihit;
					if (Array.isArray(hits)) {
						// Yes, it's hardcoded... meh
						if (hits[0] === 2 && hits[1] === 5) {
							hits = this.battle.sample([2, 2, 2, 3, 3, 3, 4, 5]);
						} else {
							hits = this.battle.random(hits[0], hits[1] + 1);
						}
					}
					hits = Math.floor(hits);
					// In gen 1, all the hits have the same damage for multihits move
					let moveDamage: number | undefined | false = 0;
					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);
						// Move damage is fixed to be the first move's damage
						if (i === 0) move.damage = damage;
						if (target.subFainted) {
							i++;
							break;
						}
					}
					move.damage = null;
					if (i === 0) return 1;
					this.battle.add('-hitcount', target, i);
				} else {
					damage = this.moveHit(target, pokemon, move);
				}
			}

			if (move.category !== 'Status') {
				target.gotAttacked(move, damage, pokemon);
			}

			if (move.selfdestruct) {
				if (!target.subFainted) {
					this.battle.faint(pokemon, pokemon, move);
				} else {
					this.battle.hint(`In Gen 1, the user of ${move.name} will not take damage if it breaks a Substitute.`);
				}
			}

			// The move missed.
			if (damage === false) {
				// Delete the partial trap lock if necessary.
				delete pokemon.volatiles['partialtrappinglock'];
				return false;
			}

			if (move.ohko) this.battle.add('-ohko');

			if (!move.negateSecondary) {
				this.battle.singleEvent('AfterMoveSecondary', move, null, target, pokemon, move);
				this.battle.runEvent('AfterMoveSecondary', target, pokemon, move);
			}

			return damage;
		},
		// It deals with the actual move hit, as the name indicates, dealing damage and/or effects.
		// This function also deals with the Gen 1 Substitute behaviour on the hitting process.
		moveHit(target, pokemon, move, moveData, isSecondary, isSelf) {
			let damage: number | false | null | undefined = 0;

			if (!isSecondary && !isSelf) this.battle.setActiveMove(move, pokemon, target);
			let hitResult: number | boolean = true;
			if (!moveData) moveData = move;

			if (move.ignoreImmunity === undefined) {
				move.ignoreImmunity = (move.category === 'Status');
			}

			// 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 | undefined = undefined;

			if (target) {
				hitResult = this.battle.singleEvent('TryHit', moveData, {}, target, pokemon, move);

				// Handle here the applying of partial trapping moves to Pokémon with Substitute
				if (targetSub && moveData.volatileStatus && moveData.volatileStatus === 'partiallytrapped') {
					target.addVolatile(moveData.volatileStatus, pokemon, move);
					if (!pokemon.volatiles['partialtrappinglock'] || pokemon.volatiles['partialtrappinglock'].duration! > 1) {
						target.volatiles[moveData.volatileStatus].duration = 2;
					}
				}

				if (!hitResult) {
					if (hitResult === false) this.battle.add('-fail', target);
					return false;
				}

				// Only run the hit events for the hit itself, not the secondary or self hits
				if (!isSelf && !isSecondary) {
					hitResult = this.battle.runEvent('TryHit', target, pokemon, move);
					if (!hitResult) {
						if (hitResult === false) this.battle.add('-fail', target);
						// Special Substitute hit flag
						if (hitResult !== 0) {
							return false;
						}
					}
					if (!this.battle.runEvent('TryFieldHit', target, pokemon, move)) {
						return false;
					}
				} else if (isSecondary && !moveData.self) {
					hitResult = this.battle.runEvent('TrySecondaryHit', target, pokemon, moveData);
				}

				if (hitResult === 0) {
					targetHasSub = !!(target?.volatiles['substitute']);
					target = null;
				} else if (!hitResult) {
					if (hitResult === false) this.battle.add('-fail', target);
					return false;
				}
			}

			if (target) {
				let didSomething = false;

				damage = this.getDamage(pokemon, target, moveData);

				// getDamage has several possible return values:
				//
				//   a number:
				//     means that much damage is dealt (0 damage still counts as dealing
				//     damage for the purposes of things like Static)
				//   false:
				//     gives error message: "But it failed!" and move ends
				//   null:
				//     the move ends, with no message (usually, a custom fail message
				//     was already output by an event handler)
				//   undefined:
				//     means no damage is dealt and the move continues
				//
				// basically, these values have the same meanings as they do for event
				// handlers.

				if (damage && damage > target.hp) {
					damage = target.hp;
				}
				if ((damage || damage === 0) && !target.fainted) {
					damage = this.battle.damage(damage, target, pokemon, move);
					if (!(damage || damage === 0)) return false;
					didSomething = true;
				} else if (damage === false && typeof hitResult === 'undefined') {
					this.battle.add('-fail', target);
				}
				if (damage === false || damage === null) {
					return false;
				}
				if (moveData.boosts && target.hp) {
					const willBoost = this.battle.boost(moveData.boosts, target, pokemon, move);
					if (!willBoost) {
						this.battle.add('-fail', target);
						return false;
					}
					didSomething = true;
					// Check the status of the Pokémon whose turn is not.
					// When a move that affects stat levels is used, if the Pokémon whose turn it is not right now is paralyzed or
					// burned, the correspoding stat penalties will be applied again to that Pokémon.
					if (pokemon.side.foe.active[0].status) {
						// If it's paralysed, quarter its speed.
						if (pokemon.side.foe.active[0].status === 'par') {
							pokemon.side.foe.active[0].modifyStat!('spe', 0.25);
						}
						// If it's burned, halve its attack.
						if (pokemon.side.foe.active[0].status === 'brn') {
							pokemon.side.foe.active[0].modifyStat!('atk', 0.5);
						}
					}
				}
				if (moveData.heal && !target.fainted) {
					const d = target.heal(Math.floor(target.maxhp * moveData.heal[0] / moveData.heal[1]));
					if (!d) {
						this.battle.add('-fail', target);
						return false;
					}
					this.battle.add('-heal', target, target.getHealth);
					didSomething = true;
				}
				if (moveData.status) {
					// Gen 1 bug: If the target has just used hyperbeam and must recharge, its status will be ignored and put to sleep.
					// This does NOT revert the paralyse speed drop or the burn attack drop.
					// Also, being put to sleep clears the recharge condition.
					if (moveData.status === 'slp' && target.volatiles['mustrecharge']) {
						// The sleep move is guaranteed to hit in this situation, unless Sleep Clause activates.
						// Do not clear recharge in that case.
						if (target.setStatus(moveData.status, pokemon, move)) {
							target.removeVolatile('mustrecharge');
							this.battle.hint(
								"In Gen 1, if a Pokémon that has just used Hyper Beam and has yet to recharge is targeted with a sleep inducing move, " +
								"any other status it may already have will be ignored and sleep will be induced regardless."
							);
						}
					} else if (!target.status) {
						if (target.setStatus(moveData.status, pokemon, move)) {
							// Gen 1 mechanics: The burn attack drop and the paralyse speed drop are applied here directly on stat modifiers.
							if (moveData.status === 'brn') target.modifyStat!('atk', 0.5);
							if (moveData.status === 'par') target.modifyStat!('spe', 0.25);
						}
					} else if (!isSecondary) {
						if (target.status === moveData.status) {
							this.battle.add('-fail', target, target.status);
						} else {
							this.battle.add('-fail', target);
						}
					}
					didSomething = true;
				}
				if (moveData.forceStatus) {
					if (target.setStatus(moveData.forceStatus, pokemon, move)) {
						if (moveData.forceStatus === 'brn') target.modifyStat!('atk', 0.5);
						if (moveData.forceStatus === 'par') target.modifyStat!('spe', 0.25);
						didSomething = true;
					}
				}
				if (moveData.volatileStatus) {
					if (target.addVolatile(moveData.volatileStatus, pokemon, move)) {
						didSomething = true;
					}
				}
				if (moveData.sideCondition) {
					if (target.side.addSideCondition(moveData.sideCondition, pokemon, move)) {
						didSomething = true;
					}
				}
				if (moveData.pseudoWeather) {
					if (this.battle.field.addPseudoWeather(moveData.pseudoWeather, pokemon, move)) {
						didSomething = true;
					}
				}
				// Hit events
				hitResult = this.battle.singleEvent('Hit', moveData, {}, target, pokemon, move);
				if (!isSelf && !isSecondary) {
					this.battle.runEvent('Hit', target, pokemon, move);
				}
				if (!hitResult && !didSomething) {
					if (hitResult === false) this.battle.add('-fail', target);
					return false;
				}
			}
			if (targetHasSub === undefined) targetHasSub = !!(target?.volatiles['substitute']);

			// Here's where self effects are applied.
			const doSelf = (targetHadSub && targetHasSub) || !targetHadSub;
			if (moveData.self && (moveData.self.volatileStatus !== 'lockedmove') &&
				(doSelf || moveData.self.volatileStatus === 'partialtrappinglock')) {
				this.moveHit(pokemon, pokemon, move, moveData.self, isSecondary, true);
			}

			// Now we can save the partial trapping damage.
			if (pokemon.volatiles['partialtrappinglock']) {
				pokemon.volatiles['partialtrappinglock'].damage = this.battle.lastDamage;
			}

			// Apply move secondaries.
			if (moveData.secondaries && target && target.hp > 0) {
				for (const secondary of moveData.secondaries) {
					// 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.hasType(move.type))) {
							if (secondary.chance === undefined) {
								this.moveHit(target, pokemon, move, secondary, true, isSelf);
							} else {
								let secondaryChance = Math.ceil(secondary.chance * 256 / 100);
								// If the secondary effect is confusion, the numerator should be decreased by 1 (10% = 25/256 not 26/256).
								if (secondary?.volatileStatus === 'confusion') secondaryChance--;
								if (this.battle.randomChance(secondaryChance, 256)) {
									this.moveHit(target, pokemon, move, secondary, true, isSelf);
								}
							}
						}
					}
				}
			}
			if (move.selfSwitch && pokemon.hp) {
				pokemon.switchFlag = move.selfSwitch === true ? true : this.dex.toID(move.selfSwitch);
			}

			return damage;
		},
		// This calculates the damage pokemon does to target with move.
		getDamage(source, target, move, suppressMessages) {
			// First of all, we get the move.
			if (typeof move === 'string') {
				move = this.battle.dex.getActiveMove(move);
			} else if (typeof move === 'number') {
				move = {
					basePower: move,
					type: '???',
					category: 'Physical',
					willCrit: false,
					flags: {},
				} as ActiveMove;
			}

			// Let's see if the target is immune to the move.
			if (!move.ignoreImmunity || (move.ignoreImmunity !== true && !move.ignoreImmunity[move.type])) {
				if (!target.runImmunity(move.type, true)) {
					return false;
				}
			}

			// Is it an OHKO move?
			if (move.ohko) {
				return 65535;
			}

			// We edit the damage through move's damage callback if necessary.
			if (move.damageCallback) {
				return move.damageCallback.call(this.battle, source, target);
			}

			// We take damage from damage=level moves (seismic toss).
			if (move.damage === 'level') {
				return source.level;
			}

			// If there's a fix move damage, we return that.
			if (move.damage || move.damage === 0) {
				return move.damage;
			}

			// If it's the first hit on a Normal-type partially trap move, it hits Ghosts anyways but damage is 0.
			if (move.volatileStatus === 'partiallytrapped' && move.type === 'Normal' && target.hasType('Ghost')) {
				return 0;
			}

			// Let's check if we are in middle of a partial trap sequence to return the previous damage.
			if (source.volatiles['partialtrappinglock'] && (target === source.volatiles['partialtrappinglock'].locked)) {
				return source.volatiles['partialtrappinglock'].damage;
			}

			// We check the category and typing to calculate later on the damage.
			if (!move.category) move.category = 'Physical';
			// '???' is typeless damage: used for Struggle and Confusion etc
			if (!move.type) move.type = '???';
			const type = move.type;

			// We get the base power and apply basePowerCallback if necessary.
			let basePower: number | false | null = move.basePower;
			if (move.basePowerCallback) {
				basePower = move.basePowerCallback.call(this.battle, source, target, move);
			}
			if (!basePower) {
				return basePower === 0 ? undefined : basePower;
			}
			basePower = this.battle.clampIntRange(basePower, 1);

			// Checking for the move's Critical Hit possibility. We check if it's a 100% crit move, otherwise we calculate the chance.
			let isCrit = move.willCrit || false;
			if (!isCrit) {
				// In gen 1, the critical chance is based on speed.
				// First, we get the base speed, divide it by 2 and floor it. This is our current crit chance.
				let critChance = Math.floor(this.dex.species.get(source.set.species).baseStats['spe'] / 2);

				// Now we check for focus energy volatile.
				if (source.volatiles['focusenergy']) {
					// If it exists, crit chance is divided by 2 again and floored.
					critChance = Math.floor(critChance / 2);
				} else {
					// Normally, without focus energy, crit chance is multiplied by 2 and capped at 255 here.
					critChance = this.battle.clampIntRange(critChance * 2, 1, 255);
				}

				// Now we check for the move's critical hit ratio.
				if (move.critRatio === 1) {
					// Normal hit ratio, we divide the crit chance by 2 and floor the result again.
					critChance = Math.floor(critChance / 2);
				} else if (move.critRatio === 2) {
					// High crit ratio, we multiply the result so far by 4 and cap it at 255.
					critChance = this.battle.clampIntRange(critChance * 4, 1, 255);
				}

				// Last, we check deppending on ratio if the move critical hits or not.
				// We compare our critical hit chance against a random number between 0 and 255.
				// If the random number is lower, we get a critical hit. This means there is always a 1/255 chance of not hitting critically.
				if (critChance > 0) {
					isCrit = this.battle.randomChance(critChance, 256);
				}
			}
			if (isCrit) target.getMoveHitData(move).crit = true;

			// Happens after crit calculation.
			if (basePower) {
				basePower = this.battle.runEvent('BasePower', source, target, move, basePower);
				if (basePower && move.basePowerModifier) {
					basePower *= move.basePowerModifier;
				}
			}
			if (!basePower) return 0;
			basePower = this.battle.clampIntRange(basePower, 1);

			// We now check attacker's and defender's stats.
			let level = source.level;
			const attacker = move.overrideOffensivePokemon === 'target' ? target : source;
			const defender = move.overrideDefensivePokemon === 'source' ? source : target;

			const isPhysical = move.category === 'Physical';
			const atkType: StatIDExceptHP = move.overrideOffensiveStat || (isPhysical ? 'atk' : 'spa');
			const defType: StatIDExceptHP = move.overrideDefensiveStat || (isPhysical ? 'def' : 'spd');

			let attack = attacker.getStat(atkType);
			let defense = defender.getStat(defType);

			// In gen 1, screen effect is applied here.
			if ((defType === 'def' && defender.volatiles['reflect']) || (defType === 'spd' && defender.volatiles['lightscreen'])) {
				this.battle.debug('Screen doubling (Sp)Def');
				defense *= 2;
			}

			// In the event of a critical hit, the offense and defense changes are ignored.
			// This includes both boosts and screens.
			// Also, level is doubled in damage calculation.
			if (isCrit) {
				move.ignoreOffensive = true;
				move.ignoreDefensive = true;
				level *= 2;
				if (!suppressMessages) this.battle.add('-crit', target);
			}

			if (move.ignoreOffensive) {
				this.battle.debug('Negating (sp)atk boost/penalty.');
				attack = attacker.getStat(atkType, true);
			}

			if (move.ignoreDefensive) {
				this.battle.debug('Negating (sp)def boost/penalty.');
				// No screens
				defense = target.getStat(defType, true);
			}

			// When either attack or defense are higher than 256, both are divided by 4.
			// If that's still over 256, it rolls over (%256), which is what causes rollover bugs.
			if (attack >= 256 || defense >= 256) {
				if (attack >= 1024 || defense >= 1024) {
					this.battle.hint("In Gen 1, a stat will roll over to a small number if it is larger than 1024.");
				}
				attack = this.battle.clampIntRange(Math.floor(attack / 4) % 256, 1);
				// Defense isn't checked on the cartridge, but we don't want those / 0 bugs on the sim.
				defense = Math.floor(defense / 4) % 256;
				if (defense === 0) {
					this.battle.hint('Pokemon Showdown avoids division by zero by rounding defense up to 1. ' +
						'In game, the battle would have crashed.');
					defense = 1;
				}
			}

			// Self destruct moves halve defense at this point.
			if (move.selfdestruct && defType === 'def') {
				defense = this.battle.clampIntRange(Math.floor(defense / 2), 1);
			}

			// Let's go with the calculation now that we have what we need.
			// We do it step by step just like the game does.
			let damage = level * 2;
			damage = Math.floor(damage / 5);
			damage += 2;
			damage *= basePower;
			damage *= attack;
			damage = Math.floor(damage / defense);
			damage = this.battle.clampIntRange(Math.floor(damage / 50), 0, 997);
			damage += 2;

			// STAB damage bonus, the "???" type never gets STAB
			if (type !== '???' && source.hasType(type)) {
				damage += Math.floor(damage / 2);
			}

			// Type effectiveness.
			// In Gen 1, type effectiveness is applied against each of the target's types.
			for (const targetType of target.types) {
				let typeMod = this.battle.dex.getEffectiveness(type, targetType);
				typeMod = this.battle.runEvent('Effectiveness', this.battle, targetType, move, typeMod);
				if (typeMod > 0) {
					// Super effective against targetType
					damage *= 20;
					damage = Math.floor(damage / 10);
				}
				if (typeMod < 0) {
					// Not very effective against targetType
					damage *= 5;
					damage = Math.floor(damage / 10);
				}
			}
			const totalTypeMod = target.runEffectiveness(move);
			if (totalTypeMod > 0) {
				if (!suppressMessages) this.battle.add('-supereffective', target);
			}
			if (totalTypeMod < 0) {
				if (!suppressMessages) this.battle.add('-resisted', target);
			}

			// If damage becomes 0, the move is made to miss.
			// 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 if damage is greater than 1
			if (damage > 1) {
				damage *= this.battle.random(217, 256);
				damage = Math.floor(damage / 255);
			}

			// And we are done.
			return Math.floor(damage);
		},
	},
	// deals with Pokémon stat boosting.
	boost(boost, target, source = null, effect = null) {
		if (this.event) {
			if (!target) target = this.event.target;
			if (!source) source = this.event.source;
			if (!effect) effect = this.effect;
		}
		if (typeof effect === 'string') effect = this.dex.conditions.get(effect);
		if (!target?.hp) return 0;
		let success = null;
		boost = this.runEvent('TryBoost', target, source, effect, { ...boost });
		let i: BoostID;
		for (i in boost) {
			const currentBoost: SparseBoostsTable = {};
			currentBoost[i] = boost[i];
			if (boost[i] !== 0) {
				const boostResult = target.boostBy(currentBoost);
				if (boostResult) {
					success = true;
					let msg = '-boost';
					if (boost[i]! < 0) {
						msg = '-unboost';
						boost[i] = -boost[i]!;
					}
					if (!effect || effect.effectType === 'Move') {
						this.add(msg, target, i, boost[i]);
					} else {
						this.add(msg, target, i, boost[i], '[from] ' + effect.fullname);
					}
					this.runEvent('AfterEachBoost', target, source, effect, currentBoost);
				}
				// Tried to boost at 999 or unboost at 1. This does not count as a success: par/brn effects are not applied afterwards.
				if (boostResult === 0) {
					let msg = '-boost';
					let secondmsg = '-unboost';
					if (boost[i]! < 0) {
						msg = '-unboost';
						secondmsg = '-boost';
						boost[i] = -boost[i]!;
					}
					if (!effect || effect.effectType === 'Move') {
						this.add(msg, target, i, boost[i]);
					} else {
						this.add(msg, target, i, boost[i], '[from] ' + effect.fullname);
					}
					this.add(secondmsg, target, i, 1);
					if (msg === '-boost') {
						this.hint(`In Gen 1, boosting a stat at 999 will apply a -1 drop afterwards, and the stat remains at 999.`, true);
					} else {
						this.hint(`In Gen 1, dropping a stat at 1 will apply a +1 boost afterwards, and the stat remains at 1.`, true);
					}
					this.runEvent('AfterEachBoost', target, source, effect, currentBoost);
				}
			}
		}
		this.runEvent('AfterBoost', target, source, effect, boost);
		return success;
	},
};