Ghoul King's Pet Mod Moves

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');
            }
        },
    },
}