pages/dmg-calc/data.ts

/*
 * @licstart  The following is the entire license notice for the JavaScript
 * code in this page.
 *
 * This file is part of oddjobs-dmg-calc.
 *
 * oddjobs-dmg-calc is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * oddjobs-dmg-calc is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with oddjobs-dmg-calc.  If not, see <https://www.gnu.org/licenses/>.
 *
 * @licend  The above is the entire license notice for the JavaScript code in
 * this page.
 */

import {
    Attack,
    ChargeType,
    Class,
    Speed,
    Spell,
    Stats,
    WeaponType,
} from "./types.js";

export function primaryStat(
    stats: Stats,
    wepType: WeaponType,
    goodAnim: boolean,
    clazz: Class,
): number {
    switch (wepType) {
        case WeaponType.None: {
            switch (clazz) {
                case Class.Pirate:
                    return stats.str * 3;
                case Class.Pirate2nd:
                    return stats.str * 4.2;
                default:
                    return 0;
            }
        }
        case WeaponType.OneHandedSword:
            return stats.str * 4;
        case WeaponType.OneHandedAxe:
            return stats.str * (goodAnim ? 4.4 : 3.2);
        case WeaponType.OneHandedMace:
            return stats.str * (goodAnim ? 4.4 : 3.2);
        case WeaponType.Dagger:
            return clazz === Class.Rogue ? stats.luk * 3.6 : stats.str * 4;
        case WeaponType.Wand:
            return stats.str * (goodAnim ? 4.4 : 3.2);
        case WeaponType.Staff:
            return stats.str * (goodAnim ? 4.4 : 3.2);
        case WeaponType.TwoHandedSword:
            return stats.str * 4.6;
        case WeaponType.TwoHandedAxe:
            return stats.str * (goodAnim ? 4.8 : 3.4);
        case WeaponType.TwoHandedMace:
            return stats.str * (goodAnim ? 4.8 : 3.4);
        case WeaponType.Spear:
            return stats.str * (goodAnim ? 5 : 3);
        case WeaponType.Polearm:
            return stats.str * (goodAnim ? 5 : 3);
        case WeaponType.Bow:
            return stats.dex * 3.4;
        case WeaponType.Crossbow:
            return stats.dex * 3.6;
        case WeaponType.Claw:
            return stats.luk * 3.6;
        case WeaponType.Knuckler:
            return stats.str * 4.8;
        case WeaponType.Gun:
            return stats.dex * 3.6;
    }
}

export function secondaryStat(
    stats: Stats,
    wepType: WeaponType,
    clazz: Class,
): number {
    switch (wepType) {
        case WeaponType.None:
            return stats.dex;
        case WeaponType.OneHandedSword:
            return stats.dex;
        case WeaponType.OneHandedAxe:
            return stats.dex;
        case WeaponType.OneHandedMace:
            return stats.dex;
        case WeaponType.Dagger:
            return clazz === Class.Rogue ? stats.str + stats.dex : stats.dex;
        case WeaponType.Wand:
            return stats.dex;
        case WeaponType.Staff:
            return stats.dex;
        case WeaponType.TwoHandedSword:
            return stats.dex;
        case WeaponType.TwoHandedAxe:
            return stats.dex;
        case WeaponType.TwoHandedMace:
            return stats.dex;
        case WeaponType.Spear:
            return stats.dex;
        case WeaponType.Polearm:
            return stats.dex;
        case WeaponType.Bow:
            return stats.str;
        case WeaponType.Crossbow:
            return stats.str;
        case WeaponType.Claw:
            return stats.str + stats.dex;
        case WeaponType.Knuckler:
            return stats.dex;
        case WeaponType.Gun:
            return stats.str;
    }
}

/**
 * The return value of this function is a natural number of milliseconds, or
 * else `undefined`.
 *
 * The values here were extracted from:
 * <http://www.southperry.net/showthread.php?t=3217>
 */
export function magicAttackPeriod(
    spellBooster: number,
    spell: Spell,
    speed: Speed,
): number | undefined {
    switch (spell) {
        case Spell.Other:
        case Spell.HolyArrow:
        case Spell.AngelRay: {
            switch (spellBooster) {
                case -2:
                    return 720;
                case -1:
                    return 750;
                case 0:
                    return 810;
                default:
                    return;
            }
        }
        case Spell.Heal:
            return 600;
        case Spell.ChainLightning: {
            switch (spellBooster) {
                case -2:
                    return 690;
                case -1:
                    return 750;
                case 0:
                    return 780;
                default:
                    return;
            }
        }
        case Spell.ShiningRay:
        case Spell.IceStrike: {
            switch (spellBooster) {
                case -2:
                    return 930;
                case -1:
                    return 990;
                case 0:
                    return 1050;
                default:
                    return;
            }
        }
        case Spell.PoisonMist: {
            switch (spellBooster) {
                case -2:
                    return 1320;
                case -1:
                    return 1410;
                case 0:
                    return 1500;
                default:
                    return;
            }
        }
        case Spell.ElementCompositionFP:
        case Spell.ElementCompositionIL: {
            switch (spellBooster) {
                case -2:
                    return 810;
                case -1:
                    return 870;
                case 0:
                    return 900;
                default:
                    return;
            }
        }
        case Spell.Explosion: {
            switch (spellBooster) {
                case -2: {
                    switch (speed) {
                        case Speed.Fast4:
                            return 1500;
                        case Speed.Fast5:
                            return 1560;
                        case Speed.Normal:
                            return 1620;
                        case Speed.Slow7:
                            return 1680;
                        case Speed.Slow8:
                            return 1710;
                        default:
                            return;
                    }
                }
                case -1: {
                    switch (speed) {
                        case Speed.Fast4:
                            return 1620;
                        case Speed.Fast5:
                            return 1680;
                        case Speed.Normal:
                            return 1740;
                        case Speed.Slow7:
                            return 1770;
                        case Speed.Slow8:
                            return 1830;
                        default:
                            return;
                    }
                }
                case 0: {
                    switch (speed) {
                        case Speed.Fast4:
                            return 1710;
                        case Speed.Fast5:
                            return 1770;
                        case Speed.Normal:
                            return 1800;
                        case Speed.Slow7:
                            return 1860;
                        case Speed.Slow8:
                            return 1920;
                        default:
                            return;
                    }
                }
                default:
                    return;
            }
        }
        case Spell.Elquines:
        case Spell.Ifrit:
        case Spell.SummonDragon:
        case Spell.Bahamut:
            return 3030;
        case Spell.Genesis:
            return 2700;
        case Spell.MeteorShower:
        case Spell.Blizzard: {
            switch (spellBooster) {
                case -2:
                    return 3060;
                case -1:
                    return 3270;
                case 0:
                    return 3480;
                default:
                    return;
            }
        }
        case Spell.ThunderSpear: {
            switch (spellBooster) {
                case -2:
                    return 1140;
                case -1:
                    return 1230;
                case 0:
                    return 1320;
                default:
                    return;
            }
        }
    }
}

/**
 * The return value of this function is a natural number of milliseconds, or
 * else `undefined`.
 *
 * Not all combinations of weapon type & speed have an associated value.  For
 * example, crossbows cannot have a "Slower" speed.
 *
 * The values here were extracted from:
 * <http://www.southperry.net/showthread.php?t=3217>
 */
export function attackPeriod(
    wepType: WeaponType,
    speed: Speed,
    attack: Attack,
): number | undefined {
    /*======== Attacking skills with special attack periods ========*/

    switch (attack) {
        case Attack.Panic:
        case Attack.Coma:
        case Attack.HeavensHammerXiuz:
        case Attack.HeavensHammerXiuzCorrected:
        case Attack.Grenade:
            return;
        case Attack.Rush:
            return 1770;
        case Attack.Brandish:
        case Attack.Blast: {
            switch (speed) {
                case Speed.Faster2:
                    return 630;
                case Speed.Faster3:
                    return 690;
                case Speed.Fast4:
                    return 750;
                case Speed.Fast5:
                    return 810;
                case Speed.Normal:
                    return 840;
                case Speed.Slow7:
                    return 900;
                case Speed.Slow8:
                    return 960;
                default:
                    return;
            }
        }
        case Attack.CrusherHigh: {
            switch (speed) {
                case Speed.Faster2:
                    return 810;
                case Speed.Faster3:
                    return 870;
                case Speed.Fast4:
                    return 930;
                case Speed.Fast5:
                    return 990;
                case Speed.Normal:
                    return 1050;
                case Speed.Slow7:
                    return 1140;
                case Speed.Slow8:
                    return 1200;
                case Speed.Slower:
                    return 1260;
            }
        }
        case Attack.CrusherLow: {
            switch (speed) {
                case Speed.Faster2:
                    return 690;
                case Speed.Faster3:
                    return 750;
                case Speed.Fast4:
                    return 810;
                case Speed.Fast5:
                    return 870;
                case Speed.Normal:
                    return 900;
                case Speed.Slow7:
                    return 960;
                case Speed.Slow8:
                    return 1020;
                case Speed.Slower:
                    return 1080;
            }
        }
        case Attack.Fury: {
            switch (speed) {
                case Speed.Faster2:
                    return 600;
                case Speed.Faster3:
                    return 660;
                case Speed.Fast4:
                    return 720;
                case Speed.Fast5:
                    return 750;
                case Speed.Normal:
                    return 810;
                case Speed.Slow7:
                    return 870;
                case Speed.Slow8:
                    return 900;
                case Speed.Slower:
                    return 960;
            }
        }
        case Attack.DragonRoar: {
            switch (speed) {
                case Speed.Faster2:
                    return 1140;
                case Speed.Faster3:
                    return 1230;
                case Speed.Fast4:
                    return 1320;
                case Speed.Fast5:
                    return 1410;
                case Speed.Normal:
                    return 1500;
                case Speed.Slow7:
                    return 1620;
                case Speed.Slow8:
                    return 1710;
                case Speed.Slower:
                    return 1800;
            }
        }
        case Attack.Hurricane:
        case Attack.RapidFire:
            return 120;
        case Attack.Phoenix:
        case Attack.Frostprey:
            return 3030;
        case Attack.DoubleStab: {
            // Double Stab's attack periods are laid out to be the same as a
            // basic-attack with a weapon speed category that has been lowered
            // by two.
            switch (speed) {
                case Speed.Faster2:
                    return 600;
                case Speed.Faster3:
                    return 600;
                case Speed.Fast4:
                    return 600;
                case Speed.Fast5:
                    return 660;
                case Speed.Normal:
                    return 720;
                case Speed.Slow7:
                    return 750;
                case Speed.Slow8:
                    return 810;
                default:
                    return;
            }
        }
        case Attack.Avenger: {
            switch (speed) {
                case Speed.Faster2:
                    return 630;
                case Speed.Faster3:
                    return 690;
                case Speed.Fast4:
                    return 750;
                case Speed.Fast5:
                    return 810;
                case Speed.Normal:
                    return 840;
                default:
                    return;
            }
        }
        case Attack.Assaulter: {
            switch (speed) {
                case Speed.Faster2:
                    return 900;
                case Speed.Faster3:
                    return 990;
                case Speed.Fast4:
                    return 1050;
                case Speed.Fast5:
                    return 1140;
                default:
                    return;
            }
        }
        case Attack.NinjaAmbush:
        case Attack.VenomousStar:
        case Attack.VenomousStab:
            return 1000;
        case Attack.NinjaStorm:
            return 1440;
        case Attack.SavageBlow: {
            switch (speed) {
                case Speed.Faster2:
                    return 720;
                case Speed.Faster3:
                    return 780;
                case Speed.Fast4:
                    return 840;
                case Speed.Fast5:
                    return 900;
                default:
                    return;
            }
        }
        case Attack.BoomerangStep:
            return 1950;
        case Attack.FlashFist:
        case Attack.EnergyDrain: {
            switch (speed) {
                case Speed.Faster2:
                    return 450;
                case Speed.Faster3:
                    return 510;
                case Speed.Fast4:
                    return 540;
                case Speed.Fast5:
                    return 570;
                case Speed.Normal:
                    return 600;
                default:
                    return;
            }
        }
        case Attack.SomersaultKick: {
            // See issue #8
            switch (speed) {
                case Speed.Faster2:
                    return 660;
                case Speed.Faster3:
                    return 720;
                case Speed.Fast4:
                    return 780;
                case Speed.Fast5:
                    return 840;
                case Speed.Normal:
                    return 870;
                default:
                    return;
            }
        }
        case Attack.DoubleShot: {
            switch (speed) {
                case Speed.Faster2:
                    return 390;
                case Speed.Faster3:
                    return 420;
                case Speed.Fast4:
                    return 450;
                case Speed.Fast5:
                case Speed.Normal:
                    return 480;
                default:
                    return;
            }
        }
        case Attack.BackspinBlow:
            return 1980;
        case Attack.DoubleUppercut:
            return 2160;
        case Attack.EnergyBlast:
            return 1140;
        case Attack.Shockwave: {
            switch (speed) {
                case Speed.Faster2:
                    return 1500;
                case Speed.Faster3:
                    return 1620;
                case Speed.Fast4:
                    return 1740;
                case Speed.Fast5:
                    return 1860;
                case Speed.Normal:
                    return 1980;
                default:
                    return;
            }
        }
        case Attack.DragonStrike:
            return 2250;
        case Attack.EnergyOrb: {
            switch (speed) {
                case Speed.Faster2:
                    return 930;
                case Speed.Faster3:
                    return 990;
                case Speed.Fast4:
                    return 1050;
                case Speed.Fast5:
                    return 1140;
                case Speed.Normal:
                    return 1200;
                default:
                    return;
            }
        }
        case Attack.Demolition: {
            switch (speed) {
                case Speed.Faster2:
                    return 2340;
                case Speed.Faster3:
                    return 2550;
                case Speed.Fast4:
                    return 2730;
                case Speed.Fast5:
                    return 2940;
                case Speed.Normal:
                    return 3120;
                default:
                    return;
            }
        }
        case Attack.Snatch:
            return 1320;
        case Attack.Barrage:
            return 3240;
        case Attack.InvisibleShot: {
            switch (speed) {
                case Speed.Faster2:
                    return 630;
                case Speed.Faster3:
                    return 660;
                case Speed.Fast4:
                    return 720;
                case Speed.Fast5:
                    return 750;
                case Speed.Normal:
                    return 810;
                default:
                    return;
            }
        }
        case Attack.BlankShot:
        case Attack.BurstFire: {
            switch (speed) {
                case Speed.Faster2:
                    return 660;
                case Speed.Faster3:
                    return 690;
                case Speed.Fast4:
                    return 750;
                case Speed.Fast5:
                    return 810;
                case Speed.Normal:
                    return 840;
                default:
                    return;
            }
        }
        case Attack.RecoilShot:
            return 2310;
        case Attack.Octopus:
        case Attack.Gaviota:
            return 1530;
        case Attack.WrathOfTheOctopi:
            return 1530 / 2; // See issue #9
        case Attack.Flamethrower:
        case Attack.IceSplitter:
            return 1050;
        case Attack.AerialStrike:
            return 5000;
        case Attack.HomingBeacon:
        case Attack.BattleshipTorpedo: {
            switch (speed) {
                case Speed.Faster2:
                    return 720;
                case Speed.Faster3:
                    return 780;
                case Speed.Fast4:
                    return 840;
                case Speed.Fast5:
                    return 900;
                case Speed.Normal:
                    return 960;
                default:
                    return;
            }
        }
        case Attack.BattleshipCannon: {
            switch (speed) {
                case Speed.Faster2:
                    return 600;
                case Speed.Faster3:
                    return 630;
                case Speed.Fast4:
                    return 690;
                case Speed.Fast5:
                    return 750;
                case Speed.Normal:
                    return 780;
                default:
                    return;
            }
        }
        default:
            break;
    }

    /*======== Basic attack periods ========*/

    switch (wepType) {
        case WeaponType.None:
        case WeaponType.OneHandedSword:
        case WeaponType.OneHandedAxe:
        case WeaponType.OneHandedMace:
        case WeaponType.Dagger:
        case WeaponType.Wand:
        case WeaponType.Staff:
        case WeaponType.TwoHandedSword:
        case WeaponType.TwoHandedAxe:
        case WeaponType.TwoHandedMace:
        case WeaponType.Bow:
        case WeaponType.Claw:
        case WeaponType.Knuckler: {
            switch (speed) {
                case Speed.Faster2:
                    return 600;
                case Speed.Faster3:
                    return 660;
                case Speed.Fast4:
                    return 720;
                case Speed.Fast5:
                    return 750;
                case Speed.Normal:
                    return 810;
                case Speed.Slow7:
                    return 870;
                case Speed.Slow8:
                    return 900;
                default:
                    return;
            }
        }
        case WeaponType.Spear:
        case WeaponType.Polearm: {
            switch (speed) {
                case Speed.Faster2:
                    return 570;
                case Speed.Faster3:
                    return 630;
                case Speed.Fast4:
                    return 660;
                case Speed.Fast5:
                    return 720;
                case Speed.Normal:
                    return 750;
                case Speed.Slow7:
                    return 810;
                case Speed.Slow8:
                    return 870;
                case Speed.Slower:
                    return 900;
            }
        }
        case WeaponType.Crossbow: {
            switch (speed) {
                case Speed.Faster2:
                    return 630;
                case Speed.Faster3:
                    return 690;
                case Speed.Fast4:
                    return 720;
                case Speed.Fast5:
                    return 780;
                case Speed.Normal:
                    return 870;
                default:
                    return;
            }
        }
        case WeaponType.Gun: {
            switch (speed) {
                case Speed.Faster2:
                    return 630;
                case Speed.Faster3:
                    return 690;
                case Speed.Fast4:
                    return 750;
                case Speed.Fast5:
                    return 780;
                case Speed.Normal:
                    return 810;
                default:
                    return;
            }
        }
    }
}

export function attackIsElemental(attack: Attack): boolean {
    switch (attack) {
        case Attack.Inferno:
        case Attack.Blizzard:
        case Attack.Phoenix:
        case Attack.Frostprey:
        case Attack.VenomousStar:
        case Attack.VenomousStab:
        case Attack.Flamethrower:
        case Attack.IceSplitter:
            return true;
        default:
            return false;
    }
}

export function isHolySpell(spell: Spell): boolean {
    switch (spell) {
        case Spell.Heal:
        case Spell.HolyArrow:
        case Spell.ShiningRay:
        case Spell.SummonDragon:
        case Spell.Bahamut:
        case Spell.AngelRay:
        case Spell.Genesis:
            return true;
        default:
            return false;
    }
}

export function isSummon(attack: Attack): boolean {
    switch (attack) {
        case Attack.Phoenix:
        case Attack.Frostprey:
        case Attack.Octopus:
        case Attack.Gaviota:
        case Attack.WrathOfTheOctopi:
            return true;
        default:
            return false;
    }
}

export function weaponTypeName(wepType: WeaponType): string {
    switch (wepType) {
        case WeaponType.None:
            return "no weapon";
        case WeaponType.OneHandedSword:
            return "one-handed sword";
        case WeaponType.OneHandedAxe:
            return "one-handed axe";
        case WeaponType.OneHandedMace:
            return "one-handed blunt weapon";
        case WeaponType.Dagger:
            return "dagger";
        case WeaponType.Wand:
            return "wand";
        case WeaponType.Staff:
            return "staff";
        case WeaponType.TwoHandedSword:
            return "two-handed sword";
        case WeaponType.TwoHandedAxe:
            return "two-handed axe";
        case WeaponType.TwoHandedMace:
            return "two-handed blunt weapon";
        case WeaponType.Spear:
            return "spear";
        case WeaponType.Polearm:
            return "polearm";
        case WeaponType.Bow:
            return "bow";
        case WeaponType.Crossbow:
            return "crossbow";
        case WeaponType.Claw:
            return "claw";
        case WeaponType.Knuckler:
            return "knuckler";
        case WeaponType.Gun:
            return "gun";
    }
}

export function className(clazz: Class): string {
    switch (clazz) {
        case Class.Beginner:
            return "beginner";
        case Class.Warrior:
            return "warrior";
        case Class.Magician:
            return "magician";
        case Class.Archer:
            return "archer";
        case Class.Rogue:
            return "rogue";
        case Class.Pirate:
            return "pirate";
        case Class.Pirate2nd:
            return "\u{2265}2\u{207f}\u{1d48} job pirate";
    }
}

export function attackName(attack: Attack): string {
    switch (attack) {
        case Attack.Other:
            return "basic attack";
        case Attack.BowWhack:
            return "bow whack";
        case Attack.ClawPunch:
            return "claw punch";
        case Attack.Panic:
            return "Panic";
        case Attack.Coma:
            return "Coma";
        case Attack.Rush:
            return "Rush";
        case Attack.Brandish:
            return "Brandish";
        case Attack.Blast:
            return "Blast";
        case Attack.HeavensHammerXiuz:
            return "Heaven\u{2019}s Hammer (original Xiuz)";
        case Attack.HeavensHammerXiuzCorrected:
            return "Heaven\u{2019}s Hammer (corrected Xiuz)";
        case Attack.CrusherHigh:
            return "Crusher (lvl 16\u{301c}30)";
        case Attack.CrusherLow:
            return "Crusher (lvl 1\u{301c}15)";
        case Attack.Fury:
            return "Fury";
        case Attack.DragonRoar:
            return "Dragon Roar";
        case Attack.PowerKnockBack:
            return "Power Knock-Back";
        case Attack.ArrowBombImpact:
            return "Arrow Bomb (impact)";
        case Attack.ArrowBombSplash:
            return "Arrow Bomb (splash)";
        case Attack.IronArrow:
            return "Iron Arrow";
        case Attack.Inferno:
            return "Inferno";
        case Attack.Blizzard:
            return "Blizzard";
        case Attack.Hurricane:
            return "Hurricane";
        case Attack.Phoenix:
            return "Phoenix";
        case Attack.Frostprey:
            return "Frostprey";
        case Attack.PiercingArrow:
            return "Piercing Arrow";
        case Attack.DoubleStab:
            return "Double Stab";
        case Attack.LuckySeven:
            return "Lucky Seven";
        case Attack.Avenger:
            return "Avenger";
        case Attack.TripleThrow:
            return "Triple Throw";
        case Attack.Assaulter:
            return "Assaulter";
        case Attack.NinjaAmbush:
            return "Ninja Ambush";
        case Attack.VenomousStar:
            return "Venomous Star";
        case Attack.VenomousStab:
            return "Venomous Stab";
        case Attack.NinjaStorm:
            return "Ninja Storm";
        case Attack.SavageBlow:
            return "Savage Blow";
        case Attack.BoomerangStep:
            return "Boomerang Step";
        case Attack.FlashFist:
            return "Flash Fist";
        case Attack.SomersaultKick:
            return "Somersault Kick";
        case Attack.DoubleShot:
            return "Double Shot";
        case Attack.BackspinBlow:
            return "Backspin Blow";
        case Attack.DoubleUppercut:
            return "Double Uppercut";
        case Attack.EnergyDrain:
            return "Energy Drain";
        case Attack.EnergyBlast:
            return "Energy Blast";
        case Attack.Shockwave:
            return "Shockwave";
        case Attack.DragonStrike:
            return "Dragon Strike";
        case Attack.EnergyOrb:
            return "Energy Orb";
        case Attack.Demolition:
            return "Demolition";
        case Attack.Snatch:
            return "Snatch";
        case Attack.Barrage:
            return "Barrage";
        case Attack.InvisibleShot:
            return "Invisible Shot";
        case Attack.Grenade:
            return "Grenade";
        case Attack.BlankShot:
            return "Blank Shot";
        case Attack.RecoilShot:
            return "Recoil Shot";
        case Attack.BurstFire:
            return "Burst Fire";
        case Attack.Octopus:
            return "Octopus";
        case Attack.Gaviota:
            return "Gaviota";
        case Attack.Flamethrower:
            return "Flamethrower";
        case Attack.IceSplitter:
            return "Ice Splitter";
        case Attack.HomingBeacon:
            return "Homing Beacon";
        case Attack.WrathOfTheOctopi:
            return "Wrath of the Octopi";
        case Attack.AerialStrike:
            return "Aerial Strike";
        case Attack.RapidFire:
            return "Rapid Fire";
        case Attack.BattleshipCannon:
            return "Battleship Cannon";
        case Attack.BattleshipTorpedo:
            return "Battleship Torpedo";
    }
}

export function spellName(spell: Spell): string {
    switch (spell) {
        case Spell.Other:
            return "a spell";
        case Spell.Explosion:
            return "Explosion";
        case Spell.PoisonMist:
            return "Poison Mist";
        case Spell.ElementCompositionFP:
            return "Element Composition [F/P]";
        case Spell.Elquines:
            return "Elquines";
        case Spell.MeteorShower:
            return "Meteor Shower";
        case Spell.IceStrike:
            return "Ice Strike";
        case Spell.ThunderSpear:
            return "Thunder Spear";
        case Spell.ElementCompositionIL:
            return "Element Composition [I/L]";
        case Spell.Ifrit:
            return "Ifrit";
        case Spell.ChainLightning:
            return "Chain Lightning";
        case Spell.Blizzard:
            return "Blizzard";
        case Spell.Heal:
            return "Heal";
        case Spell.HolyArrow:
            return "Holy Arrow";
        case Spell.ShiningRay:
            return "Shining Ray";
        case Spell.SummonDragon:
            return "Summon Dragon";
        case Spell.Bahamut:
            return "Bahamut";
        case Spell.AngelRay:
            return "Angel Ray";
        case Spell.Genesis:
            return "Genesis";
    }
}

export function chargeTypeFromValue(val: string): ChargeType | undefined {
    switch (val) {
        case "no-ele-charge":
            return ChargeType.None;
        case "holy-ele-charge":
            return ChargeType.Holy;
        case "other-ele-charge":
            return ChargeType.Other;
        default:
            return;
    }
}

export function chargeTypeToValue(chargeType: ChargeType): string {
    switch (chargeType) {
        case ChargeType.None:
            return "no-ele-charge";
        case ChargeType.Holy:
            return "holy-ele-charge";
        case ChargeType.Other:
            return "other-ele-charge";
    }
}

export const BAD_WEPS = new Map([
    [
        Class.Beginner,
        new Set([
            WeaponType.None,
            WeaponType.TwoHandedAxe,
            WeaponType.Staff,
            WeaponType.Bow,
            WeaponType.Crossbow,
            WeaponType.Knuckler,
            WeaponType.Gun,
        ]),
    ],
    [
        Class.Warrior,
        new Set([
            WeaponType.None,
            WeaponType.Staff,
            WeaponType.Bow,
            WeaponType.Crossbow,
            WeaponType.Knuckler,
            WeaponType.Gun,
        ]),
    ],
    [
        Class.Magician,
        new Set([
            WeaponType.None,
            WeaponType.TwoHandedAxe,
            WeaponType.Bow,
            WeaponType.Crossbow,
            WeaponType.Knuckler,
            WeaponType.Gun,
        ]),
    ],
    [
        Class.Archer,
        new Set([
            WeaponType.None,
            WeaponType.Staff,
            WeaponType.Knuckler,
            WeaponType.Gun,
        ]),
    ],
    [
        Class.Rogue,
        new Set([
            WeaponType.None,
            WeaponType.Staff,
            WeaponType.Bow,
            WeaponType.Crossbow,
            WeaponType.Knuckler,
            WeaponType.Gun,
        ]),
    ],
    [
        Class.Pirate,
        new Set([
            WeaponType.TwoHandedAxe,
            WeaponType.Staff,
            WeaponType.Bow,
            WeaponType.Crossbow,
        ]),
    ],
    [
        Class.Pirate2nd,
        new Set([
            WeaponType.TwoHandedAxe,
            WeaponType.Staff,
            WeaponType.Bow,
            WeaponType.Crossbow,
        ]),
    ],
]);

export const ATTACK_REQS: Map<
    Attack,
    [Set<Class>, number, Set<WeaponType>]
> = new Map([
    [
        Attack.Other,
        [
            new Set([
                Class.Beginner,
                Class.Warrior,
                Class.Magician,
                Class.Archer,
                Class.Rogue,
                Class.Pirate,
                Class.Pirate2nd,
            ]),
            0,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.BowWhack,
        [
            new Set([
                Class.Beginner,
                Class.Warrior,
                Class.Magician,
                Class.Archer,
                Class.Rogue,
                Class.Pirate,
                Class.Pirate2nd,
            ]),
            0,
            new Set([WeaponType.Bow, WeaponType.Crossbow]),
        ],
    ],
    [
        Attack.ClawPunch,
        [
            new Set([
                Class.Beginner,
                Class.Warrior,
                Class.Magician,
                Class.Archer,
                Class.Rogue,
                Class.Pirate,
                Class.Pirate2nd,
            ]),
            0,
            new Set([WeaponType.Claw]),
        ],
    ],
    [
        Attack.Panic,
        [
            new Set([Class.Warrior]),
            71,
            new Set([
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
            ]),
        ],
    ],
    [
        Attack.Coma,
        [
            new Set([Class.Warrior]),
            71,
            new Set([
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
            ]),
        ],
    ],
    [
        Attack.Rush,
        [
            new Set([Class.Warrior]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.Brandish,
        [
            new Set([Class.Warrior]),
            120,
            new Set([
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
            ]),
        ],
    ],
    [
        Attack.Blast,
        [
            new Set([Class.Warrior]),
            120,
            new Set([
                WeaponType.OneHandedSword,
                WeaponType.OneHandedMace,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedMace,
            ]),
        ],
    ],
    [
        Attack.HeavensHammerXiuz,
        [
            new Set([Class.Warrior]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.HeavensHammerXiuzCorrected,
        [
            new Set([Class.Warrior]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.CrusherHigh,
        [
            new Set([Class.Warrior]),
            75,
            new Set([WeaponType.Spear, WeaponType.Polearm]),
        ],
    ],
    [
        Attack.CrusherLow,
        [
            new Set([Class.Warrior]),
            70,
            new Set([WeaponType.Spear, WeaponType.Polearm]),
        ],
    ],
    [
        Attack.Fury,
        [
            new Set([Class.Warrior]),
            70,
            new Set([WeaponType.Spear, WeaponType.Polearm]),
        ],
    ],
    [
        Attack.DragonRoar,
        [
            new Set([Class.Warrior]),
            71,
            new Set([WeaponType.Spear, WeaponType.Polearm]),
        ],
    ],
    [
        Attack.PowerKnockBack,
        [
            new Set([Class.Archer]),
            30,
            new Set([WeaponType.Bow, WeaponType.Crossbow]),
        ],
    ],
    [
        Attack.ArrowBombImpact,
        [new Set([Class.Archer]), 30, new Set([WeaponType.Bow])],
    ],
    [
        Attack.ArrowBombSplash,
        [new Set([Class.Archer]), 30, new Set([WeaponType.Bow])],
    ],
    [
        Attack.IronArrow,
        [new Set([Class.Archer]), 30, new Set([WeaponType.Crossbow])],
    ],
    [Attack.Inferno, [new Set([Class.Archer]), 70, new Set([WeaponType.Bow])]],
    [
        Attack.Blizzard,
        [new Set([Class.Archer]), 70, new Set([WeaponType.Crossbow])],
    ],
    [
        Attack.Hurricane,
        [new Set([Class.Archer]), 120, new Set([WeaponType.Bow])],
    ],
    [
        Attack.Phoenix,
        [
            new Set([Class.Archer]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.Frostprey,
        [
            new Set([Class.Archer]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.PiercingArrow,
        [new Set([Class.Archer]), 120, new Set([WeaponType.Crossbow])],
    ],
    [
        Attack.LuckySeven,
        [new Set([Class.Rogue]), 10, new Set([WeaponType.Claw])],
    ],
    [Attack.Avenger, [new Set([Class.Rogue]), 70, new Set([WeaponType.Claw])]],
    [
        Attack.TripleThrow,
        [new Set([Class.Rogue]), 120, new Set([WeaponType.Claw])],
    ],
    [
        Attack.Assaulter,
        [new Set([Class.Rogue]), 70, new Set([WeaponType.Dagger])],
    ],
    [
        Attack.NinjaAmbush,
        [
            new Set([Class.Rogue]),
            122,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.VenomousStar,
        [new Set([Class.Rogue]), 120, new Set([WeaponType.Claw])],
    ],
    [
        Attack.VenomousStab,
        [new Set([Class.Rogue]), 120, new Set([WeaponType.Dagger])],
    ],
    [
        Attack.NinjaStorm,
        [
            new Set([Class.Rogue]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.SavageBlow,
        [new Set([Class.Rogue]), 30, new Set([WeaponType.Dagger])],
    ],
    [
        Attack.BoomerangStep,
        [new Set([Class.Rogue]), 120, new Set([WeaponType.Dagger])],
    ],
    [
        Attack.FlashFist,
        [
            new Set([Class.Pirate, Class.Pirate2nd]),
            10,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.SomersaultKick,
        [
            new Set([Class.Pirate, Class.Pirate2nd]),
            10,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.DoubleShot,
        [
            new Set([Class.Pirate, Class.Pirate2nd]),
            10,
            new Set([WeaponType.Gun]),
        ],
    ],
    [
        Attack.BackspinBlow,
        [
            new Set([Class.Pirate2nd]),
            30,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.DoubleUppercut,
        [
            new Set([Class.Pirate2nd]),
            30,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.EnergyDrain,
        [
            new Set([Class.Pirate2nd]),
            71,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.EnergyBlast,
        [
            new Set([Class.Pirate2nd]),
            71,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.Shockwave,
        [
            new Set([Class.Pirate2nd]),
            71,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.DragonStrike,
        [
            new Set([Class.Pirate2nd]),
            120,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.EnergyOrb,
        [
            new Set([Class.Pirate2nd]),
            120,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.Demolition,
        [
            new Set([Class.Pirate2nd]),
            121,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.Snatch,
        [
            new Set([Class.Pirate2nd]),
            121,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.Barrage,
        [
            new Set([Class.Pirate2nd]),
            120,
            new Set([WeaponType.None, WeaponType.Knuckler]),
        ],
    ],
    [
        Attack.InvisibleShot,
        [new Set([Class.Pirate2nd]), 30, new Set([WeaponType.Gun])],
    ],
    [
        Attack.Grenade,
        [new Set([Class.Pirate2nd]), 30, new Set([WeaponType.Gun])],
    ],
    [
        Attack.BlankShot,
        [new Set([Class.Pirate2nd]), 30, new Set([WeaponType.Gun])],
    ],
    [
        Attack.RecoilShot,
        [new Set([Class.Pirate2nd]), 30, new Set([WeaponType.Gun])],
    ],
    [
        Attack.BurstFire,
        [new Set([Class.Pirate2nd]), 70, new Set([WeaponType.Gun])],
    ],
    [
        Attack.Octopus,
        [
            new Set([Class.Pirate2nd]),
            70,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.Gaviota,
        [
            new Set([Class.Pirate2nd]),
            70,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.Flamethrower,
        [new Set([Class.Pirate2nd]), 70, new Set([WeaponType.Gun])],
    ],
    [
        Attack.IceSplitter,
        [new Set([Class.Pirate2nd]), 70, new Set([WeaponType.Gun])],
    ],
    [
        Attack.HomingBeacon,
        [new Set([Class.Pirate2nd]), 70, new Set([WeaponType.Gun])],
    ],
    [
        Attack.WrathOfTheOctopi,
        [
            new Set([Class.Pirate2nd]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.AerialStrike,
        [
            new Set([Class.Pirate2nd]),
            120,
            new Set([
                WeaponType.None,
                WeaponType.OneHandedSword,
                WeaponType.OneHandedAxe,
                WeaponType.OneHandedMace,
                WeaponType.Dagger,
                WeaponType.Wand,
                WeaponType.Staff,
                WeaponType.TwoHandedSword,
                WeaponType.TwoHandedAxe,
                WeaponType.TwoHandedMace,
                WeaponType.Spear,
                WeaponType.Polearm,
                WeaponType.Bow,
                WeaponType.Crossbow,
                WeaponType.Claw,
                WeaponType.Knuckler,
                WeaponType.Gun,
            ]),
        ],
    ],
    [
        Attack.RapidFire,
        [new Set([Class.Pirate2nd]), 120, new Set([WeaponType.Gun])],
    ],
    [
        Attack.BattleshipCannon,
        [new Set([Class.Pirate2nd]), 121, new Set([WeaponType.Gun])],
    ],
    [
        Attack.BattleshipTorpedo,
        [new Set([Class.Pirate2nd]), 121, new Set([WeaponType.Gun])],
    ],
]);

export const SPELL_LVL_REQS: Map<Spell, number> = new Map([
    [Spell.Other, 0],
    [Spell.Explosion, 70],
    [Spell.PoisonMist, 70],
    [Spell.ElementCompositionFP, 70],
    [Spell.Elquines, 120],
    [Spell.MeteorShower, 120],
    [Spell.IceStrike, 70],
    [Spell.ThunderSpear, 70],
    [Spell.ElementCompositionIL, 70],
    [Spell.Ifrit, 120],
    [Spell.ChainLightning, 120],
    [Spell.Blizzard, 120],
    [Spell.Heal, 30],
    [Spell.HolyArrow, 30],
    [Spell.ShiningRay, 70],
    [Spell.SummonDragon, 70],
    [Spell.Bahamut, 120],
    [Spell.AngelRay, 120],
    [Spell.Genesis, 120],
]);

export const JOB_LVL_REQS: Map<Class, number> = new Map([
    [Class.Beginner, 0],
    [Class.Warrior, 10],
    [Class.Magician, 8],
    [Class.Archer, 10],
    [Class.Rogue, 10],
    [Class.Pirate, 10],
    [Class.Pirate2nd, 30],
]);

/**
 * The first two numbers of the 3-tuple represent the minimum and maximum
 * number of lines, respectively.  The last number represents the maximum
 * number of targets.
 */
export const ATTACK_LINES: Map<Attack, [number, number, number]> = new Map([
    [Attack.Other, [1, 32767, 15]],
    [Attack.BowWhack, [1, 1, 1]],
    [Attack.ClawPunch, [1, 1, 1]],
    [Attack.Panic, [1, 1, 1]],
    [Attack.Coma, [1, 1, 6]],
    [Attack.Rush, [1, 1, 10]],
    [Attack.Brandish, [2, 2, 3]],
    [Attack.Blast, [1, 1, 1]],
    [Attack.HeavensHammerXiuz, [1, 1, 15]],
    [Attack.HeavensHammerXiuzCorrected, [1, 1, 15]],
    [Attack.CrusherHigh, [3, 3, 3]],
    [Attack.CrusherLow, [2, 2, 3]],
    [Attack.Fury, [1, 1, 6]],
    [Attack.DragonRoar, [1, 1, 6]],
    [Attack.PowerKnockBack, [1, 1, 6]],
    [Attack.ArrowBombImpact, [1, 1, 1]],
    [Attack.ArrowBombSplash, [1, 1, 5]],
    [Attack.IronArrow, [1, 1, 6]],
    [Attack.Inferno, [1, 1, 6]],
    [Attack.Blizzard, [1, 1, 6]],
    [Attack.Hurricane, [1, 1, 1]],
    [Attack.Phoenix, [1, 1, 4]],
    [Attack.Frostprey, [1, 1, 4]],
    [Attack.PiercingArrow, [1, 1, 6]],
    [Attack.LuckySeven, [2, 2, 1]],
    [Attack.Avenger, [1, 1, 6]],
    [Attack.TripleThrow, [3, 3, 1]],
    [Attack.Assaulter, [1, 1, 1]],
    [Attack.NinjaAmbush, [1, 1, 6]],
    [Attack.VenomousStar, [1, 1, 1]],
    [Attack.VenomousStab, [1, 1, 1]],
    [Attack.NinjaStorm, [1, 1, 6]],
    [Attack.SavageBlow, [4, 6, 1]],
    [Attack.BoomerangStep, [2, 2, 4]],
    [Attack.FlashFist, [1, 1, 1]],
    [Attack.SomersaultKick, [1, 1, 6]],
    [Attack.DoubleShot, [2, 2, 1]],
    [Attack.BackspinBlow, [1, 1, 3]],
    [Attack.DoubleUppercut, [2, 2, 1]],
    [Attack.EnergyDrain, [1, 1, 1]],
    [Attack.EnergyBlast, [1, 1, 4]],
    [Attack.Shockwave, [1, 1, 6]],
    [Attack.DragonStrike, [1, 1, 6]],
    [Attack.EnergyOrb, [1, 1, 6]],
    [Attack.Demolition, [8, 8, 1]],
    [Attack.Snatch, [1, 1, 6]],
    [Attack.Barrage, [6, 6, 1]],
    [Attack.InvisibleShot, [1, 1, 3]],
    [Attack.BlankShot, [1, 1, 3]],
    [Attack.RecoilShot, [1, 1, 1]],
    [Attack.BurstFire, [3, 3, 1]],
    [Attack.Octopus, [1, 1, 1]],
    [Attack.Gaviota, [1, 1, 6]],
    [Attack.Flamethrower, [1, 1, 6]],
    [Attack.IceSplitter, [1, 1, 6]],
    [Attack.HomingBeacon, [1, 1, 1]],
    [Attack.WrathOfTheOctopi, [1, 1, 1]],
    [Attack.AerialStrike, [1, 1, 15]],
    [Attack.RapidFire, [1, 1, 1]],
    [Attack.BattleshipCannon, [3, 4, 1]],
    [Attack.BattleshipTorpedo, [1, 1, 6]],
]);

/**
 * The first two numbers of the 3-tuple represent the minimum and maximum
 * number of lines, respectively.  The last number represents the maximum
 * number of targets.
 */
export const SPELL_LINES: Map<Spell, [number, number, number]> = new Map([
    [Spell.Other, [1, 32767, 15]],
    [Spell.Explosion, [1, 1, 6]],
    [Spell.PoisonMist, [1, 1, 6]],
    [Spell.ElementCompositionFP, [1, 1, 1]],
    [Spell.Elquines, [1, 1, 3]],
    [Spell.MeteorShower, [1, 1, 15]],
    [Spell.IceStrike, [1, 1, 6]],
    [Spell.ThunderSpear, [1, 1, 1]],
    [Spell.ElementCompositionIL, [1, 1, 1]],
    [Spell.Ifrit, [1, 1, 3]],
    [Spell.ChainLightning, [1, 1, 6]],
    [Spell.Blizzard, [1, 1, 15]],
    [Spell.Heal, [1, 1, 5]],
    [Spell.HolyArrow, [1, 1, 1]],
    [Spell.ShiningRay, [1, 1, 6]],
    [Spell.SummonDragon, [1, 1, 1]],
    [Spell.Bahamut, [1, 1, 3]],
    [Spell.AngelRay, [1, 1, 1]],
    [Spell.Genesis, [1, 1, 15]],
]);