ds4/spec/documents/item/spell/calculate-spell-price.spec.ts

// SPDX-FileCopyrightText: 2022 Johannes Loher
//
// SPDX-License-Identifier: MIT

import { describe, expect, it } from "vitest";

import { calculateSpellPrice } from "../../../../src/documents/item/spell/calculate-spell-price";

import type { CooldownDuration, DS4SpellDataSourceData } from "../../../../src/documents/item/spell/spell-data-source";

const defaultData: DS4SpellDataSourceData = {
    description: "",
    equipped: false,
    spellType: "spellcasting",
    spellModifier: {
        numerical: 0,
        complex: "",
    },
    allowsDefense: false,
    spellGroups: {
        lightning: false,
        earth: false,
        water: false,
        ice: false,
        fire: false,
        healing: false,
        light: false,
        air: false,
        transport: false,
        damage: false,
        shadow: false,
        protection: false,
        mindAffecting: false,
        demonology: false,
        necromancy: false,
        transmutation: false,
        area: false,
    },
    maxDistance: {
        value: "",
        unit: "meter",
    },
    effectRadius: {
        value: "",
        unit: "meter",
    },
    duration: {
        value: "",
        unit: "custom",
    },
    cooldownDuration: "0r",
    minimumLevels: {
        healer: null,
        wizard: null,
        sorcerer: null,
    },
};

type TestCase = {
    minimumLevel: number | null;
    expected: number | null;
};

type CombinedTestCase = {
    minimumLevels: DS4SpellDataSourceData["minimumLevels"];
    expected: number | null;
    description: string;
};

const testCases: Record<keyof DS4SpellDataSourceData["minimumLevels"], TestCase[]> = {
    healer: [
        { minimumLevel: null, expected: null },
        { minimumLevel: 1, expected: 10 },
        { minimumLevel: 2, expected: 45 },
        { minimumLevel: 3, expected: 80 },
        { minimumLevel: 4, expected: 115 },
        { minimumLevel: 5, expected: 150 },
        { minimumLevel: 6, expected: 185 },
        { minimumLevel: 7, expected: 220 },
        { minimumLevel: 8, expected: 255 },
        { minimumLevel: 9, expected: 290 },
        { minimumLevel: 10, expected: 325 },
        { minimumLevel: 11, expected: 360 },
        { minimumLevel: 12, expected: 395 },
        { minimumLevel: 13, expected: 430 },
        { minimumLevel: 14, expected: 465 },
        { minimumLevel: 15, expected: 500 },
        { minimumLevel: 16, expected: 535 },
        { minimumLevel: 17, expected: 570 },
        { minimumLevel: 18, expected: 605 },
        { minimumLevel: 19, expected: 640 },
        { minimumLevel: 20, expected: 675 },
    ],
    sorcerer: [
        { minimumLevel: null, expected: null },
        { minimumLevel: 1, expected: 10 },
        { minimumLevel: 2, expected: 75 },
        { minimumLevel: 3, expected: 140 },
        { minimumLevel: 4, expected: 205 },
        { minimumLevel: 5, expected: 270 },
        { minimumLevel: 6, expected: 335 },
        { minimumLevel: 7, expected: 400 },
        { minimumLevel: 8, expected: 465 },
        { minimumLevel: 9, expected: 530 },
        { minimumLevel: 10, expected: 595 },
        { minimumLevel: 11, expected: 660 },
        { minimumLevel: 12, expected: 725 },
        { minimumLevel: 13, expected: 790 },
        { minimumLevel: 14, expected: 855 },
        { minimumLevel: 15, expected: 920 },
        { minimumLevel: 16, expected: 985 },
        { minimumLevel: 17, expected: 1050 },
        { minimumLevel: 18, expected: 1115 },
        { minimumLevel: 19, expected: 1180 },
        { minimumLevel: 20, expected: 1245 },
    ],
    wizard: [
        { minimumLevel: null, expected: null },
        { minimumLevel: 1, expected: 10 },
        { minimumLevel: 2, expected: 60 },
        { minimumLevel: 3, expected: 110 },
        { minimumLevel: 4, expected: 160 },
        { minimumLevel: 5, expected: 210 },
        { minimumLevel: 6, expected: 260 },
        { minimumLevel: 7, expected: 310 },
        { minimumLevel: 8, expected: 360 },
        { minimumLevel: 9, expected: 410 },
        { minimumLevel: 10, expected: 460 },
        { minimumLevel: 11, expected: 510 },
        { minimumLevel: 12, expected: 560 },
        { minimumLevel: 13, expected: 610 },
        { minimumLevel: 14, expected: 660 },
        { minimumLevel: 15, expected: 710 },
        { minimumLevel: 16, expected: 760 },
        { minimumLevel: 17, expected: 810 },
        { minimumLevel: 18, expected: 860 },
        { minimumLevel: 19, expected: 910 },
        { minimumLevel: 20, expected: 960 },
    ],
};

function buildCombinedTestCases(): CombinedTestCase[] {
    const combinedTestCases: CombinedTestCase[] = [];

    // permutation test cases
    const isRelevantPermutationTestCase = (t: TestCase) =>
        ([null, 1, 10, 20] as (number | null)[]).includes(t.minimumLevel);

    for (const healerTestCase of testCases.healer.filter(isRelevantPermutationTestCase)) {
        for (const sorcererTestCase of testCases.sorcerer.filter(isRelevantPermutationTestCase)) {
            for (const wizardTestCase of testCases.wizard.filter(isRelevantPermutationTestCase)) {
                const expected =
                    healerTestCase.expected !== null ||
                    sorcererTestCase.expected !== null ||
                    wizardTestCase.expected !== null
                        ? Math.min(
                              healerTestCase.expected ?? Infinity,
                              sorcererTestCase.expected ?? Infinity,
                              wizardTestCase.expected ?? Infinity,
                          )
                        : null;
                const minimumLevels = {
                    healer: healerTestCase.minimumLevel,
                    sorcerer: sorcererTestCase.minimumLevel,
                    wizard: wizardTestCase.minimumLevel,
                };
                const description = JSON.stringify(minimumLevels);
                combinedTestCases.push({
                    minimumLevels,
                    expected,
                    description,
                });
            }
        }
    }

    // single test cases
    const isRelevantSingleTestCase = (t: TestCase) => t.minimumLevel !== null;

    for (const spellCasterClass of ["healer", "sorcerer", "wizard"] as const) {
        for (const testCase of testCases[spellCasterClass].filter(isRelevantSingleTestCase)) {
            const minimumLevels = {
                ...defaultData.minimumLevels,
                [spellCasterClass]: testCase.minimumLevel,
            };
            const description = JSON.stringify(minimumLevels);
            combinedTestCases.push({
                minimumLevels,
                expected: testCase.expected,
                description,
            });
        }
    }

    return combinedTestCases;
}

describe("calculateSpellPrice", () => {
    const cooldownDurations: { cooldownDuration: CooldownDuration; factor: number }[] = [
        { cooldownDuration: "0r", factor: 1 },
        { cooldownDuration: "1r", factor: 1 },
        { cooldownDuration: "2r", factor: 1 },
        { cooldownDuration: "5r", factor: 1 },
        { cooldownDuration: "10r", factor: 1 },
        { cooldownDuration: "100r", factor: 1 },
        { cooldownDuration: "1d", factor: 2 },
        { cooldownDuration: "d20d", factor: 3 },
    ];

    describe.each(cooldownDurations)(
        "with cooldown duration set to $cooldownDuration",
        ({ cooldownDuration, factor }) => {
            const dataWithCooldownDuration = {
                ...defaultData,
                cooldownDuration,
            };

            it.each(buildCombinedTestCases())(
                `returns ${factor} × $expected if the minimum leves are $description`,
                ({ minimumLevels, expected }) => {
                    // given
                    const data: DS4SpellDataSourceData = {
                        ...dataWithCooldownDuration,
                        minimumLevels,
                    };

                    // when
                    const spellPrice = calculateSpellPrice(data);

                    // then
                    expect(spellPrice).toBe(expected !== null ? expected * factor : expected);
                },
            );
        },
    );
});