'use strict';

exports.BattleMovedex = {
willowisp: {
		inherit: true,
		accuracy: 100
	},
leechseed: {
		inherit: true,
		accuracy: 100
	},
magmastorm: {
		inherit: true,
		accuracy: 100,
		basePower: 80
	},
hyperfang: {
		inherit: true,
		accuracy: 100,
		basePower: 100
	},
skydrop: {
		inherit: true,
		basePower: 75
	},
dragontail: {
		inherit: true,
		accuracy: true
	},
circlethrow: {
		inherit: true,
		accuracy: true
	},
outrage: {
		inherit: true,
		target: "Normal",
		basePower: 150,
		pp: 5,
		self: {
			boosts: {
				spe: -1,
				def: -1,
				spd: -1
			}
		},
	},
petaldance: {
		inherit: true,
		target: "Normal",
		basePower: 150,
		pp: 5,
		self: {
			boosts: {
				spe: -1,
				def: -1,
				spd: -1
			}
		},
	},
thrash: {
		inherit: true,
		target: "Normal",
		basePower: 150,
		pp: 5,
		self: {
			boosts: {
				spe: -1,
				def: -1,
				spd: -1
			}
		},
	},
rage: {
		inherit: true,
		Type: "Dark",
		basePower: 80,
		pp: 20,
		self: {
			boosts: {
				atk: 1,
				def: -1,
				spd: -1
			}
		},
	},
megapunch: {
		inherit: true,
		priority: 1,
		accuracy: 100,
		self: {
			boosts: {
				def: -1,
				spd: -1
			}
		},
	},
megakick: {
		inherit: true,
		priority: 1,
		accuracy: 100,
		self: {
			volatileStatus: 'mustrecharge'
		},
	},
crushgrip: {
		inherit: true,
		basePowerCallback: function (pokemon, target) {
			return Math.floor(Math.floor((150 * (100 * Math.floor(target.hp * 4096 / target.maxhp)) + 2048 - 1) / 4096) / 100) || 1;
		},
	},
crushclaw: {
		inherit: true,
		accuracy: 100,
		secondary: {
			chance: 100,
			boosts: {
				def: -1
			}
		},
	},
stealthrock: {
		inherit: true,
		effect: {
			// this is a side condition
			onStart: function (side) {
				this.add('-sidestart', side, 'move: Stealth Rock');
			},
			onSwitchIn: function (pokemon) {
				var typeMod = this.clampIntRange(pokemon.runEffectiveness('Rock'), -6, 6);
				this.damage(pokemon.maxhp * Math.pow(2, typeMod) / 12);
			}
		},
	},
hyperbeam: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
gigaimpact: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
rockwrecker: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
roaroftime: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
hydrocannon: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
blastburn: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
frenzyplant: {
		inherit: true,
		accuracy: 100,
		forceSwitch: true
		},
dreameater: {
		inherit: true,
		basePower: 120
		},
rockslide: {
		inherit: true,
		accuracy: 100,
		basePower: 70
		},
airslash: {
		inherit: true,
		accuracy: 100
		},
wringout: {
		inherit: true,
		type: "Grass"
		},
psychoboost: {
		inherit: true,
		accuracy: 100
		},
leafstorm: {
		inherit: true,
		accuracy: 100
		},
overheat: {
		inherit: true,
		accuracy: 100
		},
dracometeor: {
		inherit: true,
		accuracy: 100
		},
spacialrend: {
		inherit: true,
		accuracy: 100
		},
firespin: {
		inherit: true,
		accuracy: 100
		},
wrap: {
		inherit: true,
		accuracy: 100
		},
clamp: {
		inherit: true,
		accuracy: 100
		},
bind: {
		inherit: true,
		accuracy: 100
		},
whirlpool: {
		inherit: true,
		accuracy: 100
		},
sandtomb: {
		inherit: true,
		accuracy: 100
		},
crabhammer: {
		inherit: true,
		accuracy: 100
		},
superfang: {
		inherit: true,
		accuracy: 100
		},
sacredfire: {
		inherit: true,
		accuracy: 100
		},
aeroblast: {
		inherit: true,
		accuracy: 100
		},
dynamicpunch: {
		inherit: true,
		basePower: 110
		},
meteormash: {
		inherit: true,
		accuracy: 100
		},
firefang: {
		inherit: true,
		accuracy: 100
		},
thunderfang: {
		inherit: true,
		accuracy: 100
		},
icefang: {
		inherit: true,
		accuracy: 100
		},
zenheadbutt: {
		inherit: true,
		accuracy: 100
		},
drillrun: {
		inherit: true,
		accuracy: 100
		},
aircutter: {
		inherit: true,
		accuracy: 100
		},
snarl: {
		inherit: true,
		accuracy: 100
		},
cometpunch: {
		inherit: true,
		accuracy: 100,
		basePower: 25
		},
hypervoice: {
		inherit: true,
		basePower: 100
		},
playrough: {
		inherit: true,
		accuracy: 100,
		basePower: 85
		},
iciclecrash: {
		inherit: true,
		accuracy: 100,
		basePower: 80
		},
spikecannon: {
		inherit: true,
		priority: 1
		},
paraboliccharge: {
		inherit: true,
		basepower: 65
		},
belch: {
		inherit: true,
		accuracy: 100,
		basePower: 135
		},
selfdestruct: {
		inherit: true,
		basePower: 180,
		type: "Fire"
		},
octazooka: {
		inherit: true,
		accuracy: 100,
		priority: 1,
		basePower: 80,
		self: {
			boosts: {
			spa: -2
			}
		},
	},
quash: {
		inherit: true,
		priority: 1
		},
blazekick: {
	inherit: true,
	onEffectiveness: function (typeMod, type, move) {
			return typeMod + this.getEffectiveness('Fighting', type);
		},
	},
skullbash: {
		inherit: true,
		secondary: {
		boosts: {
			def: -2
		}
	},
},
razorwind: {
		inherit: true,
		basePower: 120,
		accuracy: 100,
		onHit: function (target) {
			target.clearBoosts();
			this.add('-clearboost', target);
		},
	},
quickguard: {
		inherit: true,
		priority: 4
		},
craftyshield :{
		inherit: true,
		sideCondition: 'craftyshield',
		onTryHitSide: function (side, source) {
			return !!this.willAct();
		},
		effect: {
			duration: 3,
			onStart: function (target, source) {
				this.add('-singleturn', source, 'Crafty Shield');
			},
			onTryHitPriority: 3,
			onTryHit: function (target, source, move) {
				if (move.breaksProtect) {
					target.side.removeSideCondition('craftyshield');
					return;
				}
				if (move && (move.target === 'self' || move.category !== 'Status')) return;
				this.add('-activate', target, 'Crafty Shield');
				return null;
			}
		},
	},
iondeluge: {
		inherit: true,
		pseudoWeather: 'iondeluge',
		effect: {
			duration: 4,
			onStart: function (target) {
				this.add('-fieldactivate', 'move: Ion Deluge');
			},
			onModifyMovePriority: -2,
			onModifyMove: function (move) {
				if (move.type === 'Normal') {
					move.type = 'Electric';
					this.debug(move.name + "'s type changed to Electric");
				}
			}
		},
	},
bonemerang: {
		inherit: true,
		accuracy: 100,
		basePower: 45,
		onEffectiveness: function (typeMod, type) {
			if (type === 'Flying') return 1;
			if (move.type !== 'Ground') return;
			var target = this.activeTarget;
			// only the attack that grounds the target ignores effectiveness
			// if called from a chat plugin, don't ignore effectiveness
			if (!this.runEvent || !this.runEvent('NegateImmunity', target, 'Ground')) return;
			if (!this.getImmunity('Ground', target)) return 0;
		},
	},
bonerush: {
		inherit: true,
		accuracy: 100,
		onEffectiveness: function (typeMod, type, move) {
			if (move.type !== 'Ground') return;
			var target = this.activeTarget;
			// only the attack that grounds the target ignores effectiveness
			// if called from a chat plugin, don't ignore effectiveness
			if (!this.runEvent || !this.runEvent('NegateImmunity', target, 'Ground')) return;
			if (!this.getImmunity('Ground', target)) return 0;
		},
	},
boneclub: {
		inherit: true,
		accuracy: 100,
		onEffectiveness: function (typeMod, type, move) {
			if (move.type !== 'Ground') return;
			var target = this.activeTarget;
			// only the attack that grounds the target ignores effectiveness
			// if called from a chat plugin, don't ignore effectiveness
			if (!this.runEvent || !this.runEvent('NegateImmunity', target, 'Ground')) return;
			if (!this.getImmunity('Ground', target)) return 0;
		},
		volatileStatus: 'smackdown',
		effect: {
			onStart: function (pokemon) {
				var applies = false;
				if (pokemon.hasType('Flying') || pokemon.hasAbility('levitate')) applies = true;
				if (pokemon.hasItem('ironball') || pokemon.volatiles['ingrain'] || this.getPseudoWeather('gravity')) applies = false;
				if (pokemon.removeVolatile('fly') || pokemon.removeVolatile('bounce')) {
					applies = true;
					this.cancelMove(pokemon);
					pokemon.removeVolatile('twoturnmove');
				}
				if (pokemon.volatiles['magnetrise']) {
					applies = true;
					delete pokemon.volatiles['magnetrise'];
				}
				if (pokemon.volatiles['telekinesis']) {
					applies = true;
					delete pokemon.volatiles['telekinesis'];
				}
				if (!applies) return false;
				this.add('-start', pokemon, 'Smack Down');
			},
			onRestart: function (pokemon) {
				if (pokemon.removeVolatile('fly') || pokemon.removeVolatile('bounce')) {
					this.cancelMove(pokemon);
					this.add('-start', pokemon, 'Smack Down');
				}
			},
			onNegateImmunity: function (pokemon, type) {
				if (type === 'Ground') return false;
			}
		},
	},
acidspray: {
		inherit: true,
		onEffectiveness: function (typeMod, type) {
			if (type === 'Steel') return 1;
		},
	},
acid: {
		inherit: true,
		basePower: 65,
		secondary: {
			chance: 20,
			boosts: {
				spd: -1
			}
		},
		onEffectiveness: function (typeMod, type) {
			if (type === 'Steel') return 1;
		},
	},
waterspout: {
		inherit: true,
		basePower: 140,
		basePowerCallback: function (pokemon) {
			return 140 * pokemon.hp / pokemon.maxhp;
		},
	},
eruption: {
		inherit: true,
		basePower: 140,
		basePowerCallback: function (pokemon) {
			return 140 * pokemon.hp / pokemon.maxhp;
		},
	},
chargebeam: {
		inherit: true,
		accuracy: 100,
		basePower: 40,
		self: {
			boost: {
			spa: 1
			}
		},
	},
slash: {
		inherit: true,
		basePower: 65,
		willCrit: true
		},
muddywater: {
		inherit: true,
		basePower: 80,
		accuracy: 100,
		secondary: {
			chance: 100,
			boosts: {
				spe: -1
			}
		},
	},
nightdaze: {
		inherit: true,
		basePower: 80,
		accuracy: 100,
		selfSwitch: true,
		secondary: false
		},
relicsong: {
		inherit: true,
		basePower: 60,
		volatileStatus: 'yawn',
		onTryHit: function (target) {
			if (target.status || !target.runImmunity('slp')) {
				return false;
			}
		},
		effect: {
			noCopy: true, // doesn't get copied by Baton Pass
			duration: 2,
			onStart: function (target, source) {
				this.add('-start', target, 'move: Yawn', '[of] ' + source);
			},
			onEnd: function (target) {
				this.add('-end', target, 'move: Yawn', '[silent]');
				target.trySetStatus('slp');
			}
		},
	},
mysticalfire: {
		inherit: true,
		secondary: {
			chance: 100,
			boosts: {
				spa: -1,
				spd: -1
			}
		},
	},
drillpeck: {
		inherit: true,
		critRatio: 2
		},
rocksmash: {
		inherit: true,
		secondary: {
			chance: 100,
			boosts: {
				def: -1
			}
		},
	},

poisontail: {
		inherit: true,
		basePower: 60,
		secondary: {
			chance: 30,
			status: 'psn'
			},
		},
payback: {
		inherit: true,
		basePower: 65,
		basePowerCallback: function (pokemon, target) {
			if (target.newlySwitched) {
				this.debug('Payback NOT boosted on a switch');
				return 65;
			}
			if (this.willMove(target)) {
				this.debug('Payback NOT boosted');
				return 65;
			}
			this.debug('Payback damage boost');
			return 130;
		},
	},
punishment: {
		inherit: true,
		basePower: 0,
		basePowerCallback: function (pokemon, target) {
			return 60 + 30 * target.positiveBoosts();
		},
	},
razorshell: {
		inherit: true,
		accuracy: 100,
		secondary: {
			chance: 100,
			boosts: {
				def: -1
			}
		},
	},
diamondstorm: {
		inherit: true,
		accuracy: 100,
		secondary: {
		self: {
			chance: 100,
			boosts: {
			def: 1
			}
		}
	}
},
fellstinger: {
		inherit: true,
		basePower: 20,
		priority: 1
		},
landswrath: {
		inherit: true,
		onHit: function (target) {
			target.clearBoosts();
			this.add('-clearboost', target);
		},
	},
mistball: {
		inherit: true,
		secondary: {
			chance: 100,
			boosts: {
				spa: -1
			}
		},
	},
lusterpurge: {
		inherit: true,
		secondary: {
			chance: 100,
			boosts: {
				spd: -1
			}
		},
	},
wideguard: {
		inherit: true,
		effect: {
			duration: 1,
			onStart: function (target, source) {
				this.add('-singleturn', source, 'Wide Guard');
			},
			onTryHitPriority: 4,
			onTryHit: function (target, source, effect) {
				// Wide Guard blocks damaging spread moves
				if (effect && (effect.target !== 'allAdjacent' && effect.target !== 'allAdjacentFoes')) {
					return;
				}
				this.add('-activate', target, 'Wide Guard');
				var lockedmove = source.getVolatile('lockedmove');
				if (lockedmove) {
					// Outrage counter is reset
					if (source.volatiles['lockedmove'].duration === 2) {
						delete source.volatiles['lockedmove'];
					}
				}
				return null;
			}
		},
	},
grassyterrain: {
		inherit: true,
		effect: {
			duration: 5,
			onBasePower: function (basePower, attacker, defender, move) {
				var weakenedMoves = {'earthquake':1, 'bulldoze':1, 'magnitude':1};
				if (move.id in weakenedMoves) {
					this.debug('move weakened by grassy terrain');
					return this.chainModify(0.5);
				}
				if (Pokemon.hasType === ('Grass') && attacker.isGrounded()) {
					this.debug('grassy terrain boost');
					return this.chainModify(1.3);
				}
			},
			onStart: function (target, source) {
				this.add('-fieldstart', 'move: Grassy Terrain');
			},
			onResidualOrder: 5,
			onResidualSubOrder: 2,
			onResidual: function (battle) {
				this.debug('onResidual battle');
				var pokemon;
				for (var s in battle.sides) {
					for (var p in battle.sides[s].active) {
						pokemon = battle.sides[s].active[p];
						if (pokemon.isGrounded() && !pokemon.isSemiInvulnerable()) {
							this.debug('Pokemon is grounded, healing through Grassy Terrain.');
							this.heal(pokemon.maxhp / 8, pokemon, pokemon);
						}
					}
				}
			},
			onEnd: function () {
				this.add('-fieldend', 'move: Grassy Terrain');
			}
		},
	},
mistyterrain: {
		inherit: true,
		effect: {
			duration: 5,
			onSetStatus: function (status, target, source, effect) {
				if (!target.isGrounded() || target.isSemiInvulnerable()) return;
				this.debug('misty terrain preventing status');
				return false;
			},
			onBasePower: function (basePower, attacker, defender, move) {
				if (pokemon.hasType === ('Dragon') && defender.isGrounded() && !defender.isSemiInvulnerable()) {
					this.debug('misty terrain weaken');
					return this.chainModify(0.5);
				}
			},
			onStart: function (side) {
				this.add('-fieldstart', 'Misty Terrain');
			},
			onResidualOrder: 21,
			onResidualSubOrder: 2,
			onEnd: function (side) {
				this.add('-fieldend', 'Misty Terrain');
			}
		},
	},
electricterrain: {
		inherit: true,
		effect: {
			duration: 5,
			onSetStatus: function (status, target, source, effect) {
				if (status.id === 'slp' && target.isGrounded() && !target.isSemiInvulnerable()) {
					this.debug('Interrupting sleep from Electric Terrain');
					return false;
				}
			},
			onTryHit: function (target, source, move) {
				if (!target.isGrounded() || target.isSemiInvulnerable()) return;
				if (move && move.id === 'yawn') {
					return false;
				}
			},
			onBasePower: function (basePower, attacker, defender, move) {
				if (pokemon.hasType === ('Electric') && attacker.isGrounded() && !attacker.isSemiInvulnerable()) {
					this.debug('electric terrain boost');
					return this.chainModify(1.3);
				}
			},
			onUpdate: function (pokemon) {
			if (pokemon.status === 'slp'&& target.isGrounded() && !target.isSemiInvulnerable()) {
				pokemon.cureStatus();
			}
		},
			onStart: function () {
				this.add('-fieldstart', 'move: Electric Terrain');
			},
			onResidualOrder: 21,
			onResidualSubOrder: 2,
			onEnd: function () {
				this.add('-fieldend', 'move: Electric Terrain');
			}
		},
	},
teleport: {
		inherit: true,
		onTryHit: function (pokemon, target, move) {
			if (move.id === 'pursuit') {
				this.add('-immune', pokemon, '[msg]');
				return null;
			}
		},
		priority: 1,
		selfSwitch: true,
		},
present: {
		inherit: true,
		category: "Status",
		priority: 3,
		effect: {
			duration: 1,
			onStart: function (target) {
				this.add('-start', target, 'Present');
			},
			onTryMove: function (pokemon, target, move) {
				if (move.category === 'Status') {
					this.add('-activate', pokemon, 'Present');
					this.damage(this.clampIntRange(Math.round(pokemon.maxhp / 2), 1));
					return false;
				}
			}
		},
	},
ominouswind: {
		inherit: true,
		priority: -3,
		beforeTurnCallback: function (pokemon) {
			pokemon.addVolatile('ominouswind');
		},
		beforeMoveCallback: function (pokemon) {
			if (!pokemon.removeVolatile('ominouswind')) {
				return false;
			}
			if (pokemon.lastAttackedBy && pokemon.lastAttackedBy.thisTurn && pokemon.lastAttackedBy.damage > 0 && this.getMove(pokemon.lastAttackedBy.move).category !== 'Status') {
				this.add('cant', pokemon, 'Ominous Wind', 'Ominous Wind');
				return true;
			}
		},
		effect: {
			duration: 1,
			onStart: function (pokemon) {
				this.add('-singleturn', pokemon, 'move: Ominous Wind');
			}
		},
	secondary: {
			chance: 100,
			self: {
				boosts: {
					atk: 1,
					def: 1,
					spa: 1,
					spd: 1,
					spe: 1
				}
			},
		},
	},
silverwind: {
		inherit: true,
		priority: -3,
		beforeTurnCallback: function (pokemon) {
			pokemon.addVolatile('silverwind');
		},
		beforeMoveCallback: function (pokemon) {
			if (!pokemon.removeVolatile('silverwind')) {
				return false;
			}
			if (pokemon.lastAttackedBy && pokemon.lastAttackedBy.thisTurn && pokemon.lastAttackedBy.damage > 0 && this.getMove(pokemon.lastAttackedBy.move).category !== 'Status') {
				this.add('cant', pokemon, 'Silver Wind', 'Silver Wind');
				return true;
			}
		},
		effect: {
			duration: 1,
			onStart: function (pokemon) {
				this.add('-singleturn', pokemon, 'move: Silver Wind');
			}
		},
	secondary: {
			chance: 100,
			self: {
				boosts: {
					atk: 1,
					def: 1,
					spa: 1,
					spd: 1,
					spe: 1
				}
			},
		},
	},
ancientpower: {
		inherit: true,
		priority: -3,
		beforeTurnCallback: function (pokemon) {
			pokemon.addVolatile('ancientpower');
		},
		beforeMoveCallback: function (pokemon) {
			if (!pokemon.removeVolatile('ancientpower')) {
				return false;
			}
			if (pokemon.lastAttackedBy && pokemon.lastAttackedBy.thisTurn && pokemon.lastAttackedBy.damage > 0 && this.getMove(pokemon.lastAttackedBy.move).category !== 'Status') {
				this.add('cant', pokemon, 'Ancient Power', 'Ancient Power');
				return true;
			}
		},
		effect: {
			duration: 1,
			onStart: function (pokemon) {
				this.add('-singleturn', pokemon, 'move: Ancient Power');
			}
		},
	secondary: {
			chance: 100,
			self: {
				boosts: {
					atk: 1,
					def: 1,
					spa: 1,
					spd: 1,
					spe: 1
				}
			},
		},
	},
endure: {
		inherit: true,
		onTryHit: function (pokemon) {
			return this.willAct() && this.runEvent('StallMove', pokemon);
		},
		onHit: function (pokemon) {
			pokemon.addVolatile('stall');
		},
		effect: {
			duration: 1,
			onStart: function (target) {
				this.add('-singleturn', target, 'move: Endure');
			},
			onDamagePriority: -10,
			onDamage: function (damage, target, source, effect) {
				if (effect && effect.effectType === 'Move' && damage >= target.hp) {
					this.add('-activate', target, 'move: Endure');
					return target.hp - 1;
					this.boost({spe:1});
				}
			}
		},
	},
charge: {
		inherit: true,
		effect: {
			onBasePowerPriority: 3,
			onBasePower: function (basePower, attacker, defender, move) {
				if (move.type === 'Electric') {
					this.debug('charge boost');
					return this.chainModify(2);
				}
			}
		},
	},
aromaticmist: {
		inherit: true,
		target: "AllySide",
		},
uproar: {
		inherit: true,
		basePower: 80,
		sleepUsable: true,
		target: "Normal",
		onBasePower: function (basePower, pokemon) {
			if (pokemon.status && pokemon.status == 'slp') {
				return this.chainModify(2);
			}
		},
	},
swallow: {
		inherit: true,
		onTryHit: true,
		onHit: function (pokemon) {
			var healAmount = [0.20, 0.40, 0.60, 0.80];
			this.heal(this.modify(pokemon.maxhp, healAmount[(pokemon.volatiles['stockpile'].layers)]));
		},
	},
spitup: {
		inherit: true,
		basePower: 0,
		basePowerCallback: function (pokemon) {
			return 50 + pokemon.volatiles['stockpile'].layers * 50
		},
		onTry: true,
		onAfterMove: false,
	},
flyingpress: {
		inherit: true,
		accuracy: 100,
		onEffectiveness: function (typeMod, type) {
			if (type === 'Bug') return 1;
			if (type === 'Grass') return 1;
			if (type === 'Fighting') return 1;
		},
	},
nightmare: {
		inherit: true,
		effect: {
			duration: 5,
		onResidualOrder: 26,
		onResidualSubOrder: 1,
		onResidual: function (pokemon) {
			if (!pokemon.hp) return;
			for (var i = 0; i < pokemon.side.foe.active.length; i++) {
				var target = pokemon.side.foe.active[i];
				if (!target || !target.hp) continue;
				if (target.status === 'slp') {
					this.damage(target.maxhp / 4, target);
				}
			}
		},
	onStart: function (side) {
				this.add('-sidestart', side, 'move: Nightmare');
			},
			onResidualOrder: 21,
			onResidualSubOrder: 1,
			onEnd: function (side) {
				this.add('-sideend', side, 'move: Nightmare');
			}
		},
	},
}