roll20-character-sheets/Demon Gate/DemonGate.html

<script type="text/worker">
    on("sheet:opened", function () {
        performMigrations();

        updateAllAttributes();
        updateAllSkills();
    });

    // Latest sheet version - used for migration purposes
    const SHEET_VERSION = "2.2.0";

    function performMigrations() {
        getAttrs(["SheetVersion", "HpConverted"], function (values) {
            let sheetCurrentVersion = values.SheetVersion || "0.0.0";
            const hpConverted = values.HpConverted;

            console.log(`Current sheet version: ${sheetCurrentVersion}, Target version: ${SHEET_VERSION}`);

            // Special case: If HpConverted exists but no SheetVersion, this is a converted legacy sheet
            if (!values.SheetVersion && (hpConverted === "converted" || hpConverted === "conversion not needed")) {
                console.log("Detected legacy sheet that has already been converted. Setting version to 2.0.0.");
                setAttrs({
                    SheetVersion: "2.0.0"
                });
                sheetCurrentVersion = "2.0.0";
            }

            // Only run migrations if we need to upgrade
            if (needsMigration(sheetCurrentVersion, SHEET_VERSION)) {
                console.log("Running migrations...");

                // Run migrations in order based on version
                if (isVersionOlderThan(sheetCurrentVersion, "2.0.0")) {
                    migrateTo_2_0_0();
                }
                if (isVersionOlderThan(sheetCurrentVersion, "2.2.0")) {
                    migrateTo_2_2_0();
                }

                // Set the current version after all migrations are complete
                setAttrs({
                    SheetVersion: SHEET_VERSION
                });

                console.log(`Migrations complete. Updated to version ${SHEET_VERSION}`);
            } else {
                console.log("No migrations needed.");
            }
        });
    }

    function needsMigration(currentVersion, targetVersion) {
        return isVersionOlderThan(currentVersion, targetVersion);
    }

    function isVersionOlderThan(version1, version2) {
        // Simple version comparison (assumes semantic versioning)
        const v1Parts = version1.split(".").map(Number);
        const v2Parts = version2.split(".").map(Number);

        for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
            const v1Part = v1Parts[i] || 0;
            const v2Part = v2Parts[i] || 0;

            if (v1Part < v2Part) return true;
            if (v1Part > v2Part) return false;
        }

        return false; // versions are equal
    }

    function migrateTo_2_0_0() {
        // This migration handles the old HP/Mana/Chi conversion for truly legacy sheets only
        console.log("Running migration to version 2.0.0...");

        getAttrs(["HpConverted"], function (values) {
            // Only run the conversion if it hasn't been done before
            if (!values.HpConverted) {
                console.log("Running HP/Mana/Chi conversion for legacy sheet...");
                convertOldAttributes();
            } else {
                console.log("HP/Mana/Chi conversion already completed, skipping.");
            }
        });
    }

    // Legacy migration function - now called from migrateTo_2_0_0()
    function convertOldAttributes() {
        const converted = "converted";
        const conversionNotNeeded = "conversion not needed";

        getAttrs(
            [
                "HpConverted",
                "CurHP",
                "CurHP_max",
                "MaxHP",
                "MaxHP_max",
                "CurMana",
                "CurMana_max",
                "MaxMana",
                "MaxMana_max",
                "CurChi",
                "CurChi_max",
                "MaxChi",
                "MaxChi_max",
                "hit_points",
                "hit_points_max",
                "intelligence_mana",
                "intelligence_mana_max",
                "body_chi",
                "body_chi_max"
            ],
            function (values) {
                // If we're already converted, we don't need to do anything
                const hpConverted = values.HpConverted;
                if (hpConverted === converted || hpConverted === conversionNotNeeded) {
                    console.log("HP conversion already completed or not needed");
                    return;
                }

                // If HP isn't set, this is a new sheet and doesn't need converting
                if (values.CurHP <= 1 && values.MaxChi <= 1 && values.hit_points <= 1 && values.hit_points_max <= 1) {
                    setAttrs({
                        HpConverted: conversionNotNeeded
                    });

                    console.log("Did not need to convert HP, mana and chi");
                    return;
                }

                // Work out whether to use the current or max values of each "max" attribute
                const curHP = Math.max(numberOrZero(values.CurHP), numberOrZero(values.hit_points));
                const maxHP = Math.max(
                    numberOrZero(values.MaxHP),
                    numberOrZero(values.MaxHP_max),
                    numberOrZero(values.CurHP_max),
                    numberOrZero(values.hit_points_max)
                );
                const curMana = Math.max(numberOrZero(values.CurMana), numberOrZero(values.intelligence_mana));
                const maxMana = Math.max(
                    numberOrZero(values.CurMana_max),
                    numberOrZero(values.MaxMana),
                    numberOrZero(values.MaxMana_max),
                    numberOrZero(values.intelligence_mana_max)
                );
                const curChi = Math.max(numberOrZero(values.CurChi), numberOrZero(values.body_chi));
                const maxChi = Math.max(
                    numberOrZero(values.CurChi_max),
                    numberOrZero(values.MaxChi),
                    numberOrZero(values.MaxChi_max),
                    numberOrZero(values.body_chi_max)
                );

                setAttrs({
                    HP: curHP,
                    HP_max: maxHP,
                    Mana: curMana,
                    Mana_max: maxMana,
                    Chi: curChi,
                    Chi_max: maxChi,
                    HpConverted: converted
                });

                console.log("Converted HP, mana and chi to new attribute names");
            }
        );
    }

    function numberOrZero(input) {
        return isNaN(input) ? 0 : Number(input);
    }

    function migrateTo_2_2_0() {
        // This migration updates the "prostitute" class to "courtesan"
        console.log("Running migration to version 2.2.0 - updating class names...");

        getAttrs(["Class"], function (values) {
            if (values.Class === "prostitute") {
                setAttrs({
                    Class: "courtesan"
                });
                console.log("Updated character class from 'prostitute' to 'courtesan'");
            }
        });
    }

    // Dice Rank Utility Functions

    function getRank(att) {
        if (att <= 0) return 0;

        if (att <= 15) return Math.floor((att + 2) / 3);

        if (att <= 99) return Math.floor((att - 14) / 2) + 5;

        return att - 52;
    }

    // Optimized getDice function using lookup table for better performance
    const diceTable = [
        "", // 0 - not used
        "d2", // 1
        "d4!", // 2
        "d6!", // 3
        "d8!", // 4
        "d10!", // 5
        "d12!", // 6
        "d8!+d6!", // 7
        "2d8!", // 8
        "d10!+d8!", // 9
        "2d10!", // 10
        "d12!+d10!", // 11
        "2d12!", // 12
        "d20!+d6!", // 13
        "d20!+d8!", // 14
        "d20!+d10!", // 15
        "d20!+d12!", // 16
        "d20!+d8!+d6!", // 17
        "d20!+2d8!", // 18
        "d20!+d10!+d8!", // 19
        "d20!+2d10!", // 20
        "d20!+d12!+d10!", // 21
        "d20!+2d12!", // 22
        "2d20!+d6!", // 23
        "2d20!+d8!", // 24
        "2d20!+d10!", // 25
        "2d20!+d12!", // 26
        "2d20!+d8!+d6!", // 27
        "2d20!+2d8!", // 28
        "2d20!+d10!+d8!", // 29
        "2d20!+2d10!", // 30
        "2d20!+d12!+d10!", // 31
        "2d20!+2d12!", // 32
        "3d20!+d6!", // 33
        "3d20!+d8!", // 34
        "3d20!+d10!", // 35
        "3d20!+d12!", // 36
        "3d20!+d8!+d6!", // 37
        "3d20!+2d8!", // 38
        "3d20!+d10!+d8!", // 39
        "3d20!+2d10!", // 40
        "3d20!+d12!+d10!", // 41
        "3d20!+2d12!", // 42
        "4d20!+d6!", // 43
        "4d20!+d8!", // 44
        "4d20!+d10!", // 45
        "4d20!+d12!", // 46
        "4d20!+d6!+d8!", // 47
        "4d20!+2d8!", // 48
        "4d20!+d8!+d10!", // 49
        "4d20!+2d10!" // 50
    ];

    function getDice(rank) {
        if (rank === "" || rank === "-") {
            return "";
        }

        let rankToUse = parseInt(rank, 10);

        if (rankToUse > 50) {
            rankToUse = 50;
        }

        return diceTable[rank] || "";
    }

    // Helper function to generate race summary from modifiers
    on("change:race", function () {
        getAttrs(["Race"], function (values) {
            // Get race data from lookup table, with defaults for missing races
            const raceData = RACE_DATA[values.Race] || {};

            // Extract racial modifiers with defaults
            const {
                strengthModifier = 0,
                dexterityModifier = 0,
                bodyModifier = 0,
                perceptionModifier = 0,
                intelligenceModifier = 0,
                willpowerModifier = 0,
                charismaModifier = 0,
                beautyModifier = 0,
                racialMovement = 3,
                racialUnarmedRank = 3,
                visionType = "",
                soulPoints = 10
            } = raceData;

            // Update all racial attributes in a single batch call
            setAttrs({
                RaceMvmt: racialMovement,
                Vision: visionType,
                SoulPoints: soulPoints,
                RaceUnarmedRank: racialUnarmedRank,
                StrRace: strengthModifier,
                DexRace: dexterityModifier,
                BdyRace: bodyModifier,
                PrcRace: perceptionModifier,
                IntRace: intelligenceModifier,
                WilRace: willpowerModifier,
                ChrRace: charismaModifier,
                BtyRace: beautyModifier,
                RaceSummary: generateRaceSummary(values.Race, raceData)
            });

            updateAllAttributes();
            updateUnarmed();
        });
    });

    function generateRaceSummary(raceName, raceData) {
        const {
            strengthModifier = 0,
            dexterityModifier = 0,
            bodyModifier = 0,
            perceptionModifier = 0,
            intelligenceModifier = 0,
            willpowerModifier = 0,
            charismaModifier = 0,
            beautyModifier = 0,
            racialMovement = 3,
            racialUnarmedRank = 3,
            visionType = "",
            soulPoints = 10
        } = raceData;

        // Extract race display name from existing summaries
        const raceDisplayNames = {
            ogre: "Bogkroll (Ogre)",
            troll: "Bogkroll (Troll)",
            highelf: "Eldrynn (High)",
            halfelf: "Eldrynn (Half-Elf)",
            shadow: "Eldrynn (Shadow)",
            dungoblin: "Goblin (Dungoblin)",
            knocker: "Goblin (Knocker)",
            mungreel: "Goblin (Mungreel)",
            dark: "Kai Eldrynn (Dark)",
            halfdark: "Kai Eldrynn (Half-Dark-Elf)",
            kuthalan: "Kuthalan (Reaver)",
            mhentep: "Mhen Tep (Grimalkin)",
            minotaur: "Minotaur (Broman)",
            highdwarf: "Mongru (High Dwarf)",
            paledwarf: "Mongru (Pale Dwarf)",
            stonedwarf: "Mongru (Stone Dwarf)",
            nephilim: "Nephilim (Watcher)",
            darkorc: "Org (Dark Orc)",
            halforc: "Org (Half-Orc)",
            orc: "Org (Orc)",
            sharpheen: "Sharpheen (Lizard Kin)",
            mulpheen: "Sharpheen (Mulpheen)",
            skog: "Skog (Beastkin)",
            halfskog: "Skog (Half-Brute)",
            tarkanys: "Tarkanys (Ratkin)",
            bloodtark: "Tarkanys (Blood Tark)",
            human: "Terran (Human)",
            mutant: "Vatagi (Mutant)"
        };

        const displayName = raceDisplayNames[raceName] || "Unknown Race";
        let summary = displayName + ":";

        // Add attribute modifiers
        const modifiers = [];
        if (strengthModifier !== 0) modifiers.push((strengthModifier > 0 ? "+" : "") + strengthModifier + " Str");
        if (dexterityModifier !== 0) modifiers.push((dexterityModifier > 0 ? "+" : "") + dexterityModifier + " Dex");
        if (bodyModifier !== 0) modifiers.push((bodyModifier > 0 ? "+" : "") + bodyModifier + " Bdy");
        if (perceptionModifier !== 0) modifiers.push((perceptionModifier > 0 ? "+" : "") + perceptionModifier + " Prc");
        if (intelligenceModifier !== 0)
            modifiers.push((intelligenceModifier > 0 ? "+" : "") + intelligenceModifier + " Int");
        if (willpowerModifier !== 0) modifiers.push((willpowerModifier > 0 ? "+" : "") + willpowerModifier + " Wil");
        if (charismaModifier !== 0) modifiers.push((charismaModifier > 0 ? "+" : "") + charismaModifier + " Chr");
        if (beautyModifier !== 0) modifiers.push((beautyModifier > 0 ? "+" : "") + beautyModifier + " Bty");

        if (modifiers.length > 0) {
            summary += " " + modifiers.join(", ") + ".";
        } else {
            // Handle races with no attribute modifiers
            summary += " No attribute modifiers.";
        }

        // Add special abilities
        const specials = [];
        if (racialMovement !== 3) specials.push("Movement " + racialMovement);
        if (racialUnarmedRank !== 3) {
            const unarmedDice = getDice(racialUnarmedRank);
            specials.push("Unarmed " + unarmedDice);
        }
        if (soulPoints !== 10) specials.push(soulPoints + " Soul Points");
        if (visionType) {
            // Add "Vision" suffix for most types, except special ones
            const visionText =
                visionType === "Chromatic/Astral Sight" || visionType === "Infravision" || visionType === "Dark Sight"
                    ? visionType
                    : visionType + " Vision";
            specials.push(visionText);
        }

        if (specials.length > 0) {
            summary += " " + specials.join(", ") + ".";
        }

        return summary;
    }

    // Race data lookup table - defines racial modifiers and special attributes
    const RACE_DATA = {
        ogre: {
            strengthModifier: 4,
            dexterityModifier: -2,
            bodyModifier: 1,
            intelligenceModifier: -2,
            charismaModifier: -1,
            racialMovement: 2,
            racialUnarmedRank: 6,
            visionType: "Twilight"
        },
        troll: {
            strengthModifier: 4,
            dexterityModifier: -2,
            bodyModifier: 1,
            intelligenceModifier: -2,
            charismaModifier: -1,
            racialMovement: 2,
            racialUnarmedRank: 6,
            visionType: "Dark Sight"
        },
        highelf: {
            strengthModifier: -2,
            dexterityModifier: 1,
            bodyModifier: -2,
            perceptionModifier: 1,
            intelligenceModifier: 1,
            willpowerModifier: 1,
            beautyModifier: 2,
            visionType: "Twilight"
        },
        halfelf: {
            strengthModifier: -1,
            bodyModifier: -1,
            perceptionModifier: 1,
            intelligenceModifier: 1,
            beautyModifier: 1,
            visionType: "Twilight"
        },
        shadow: {
            strengthModifier: -2,
            dexterityModifier: 1,
            bodyModifier: -2,
            perceptionModifier: 1,
            intelligenceModifier: 1,
            willpowerModifier: 1,
            beautyModifier: 2,
            visionType: "Dark Sight"
        },
        dungoblin: {
            strengthModifier: -1,
            dexterityModifier: 1,
            perceptionModifier: 1,
            charismaModifier: -1,
            racialMovement: 4,
            visionType: "Twilight"
        },
        knocker: {
            strengthModifier: -2,
            dexterityModifier: 2,
            perceptionModifier: 1,
            charismaModifier: -1,
            racialMovement: 4,
            visionType: "Dark Sight"
        },
        mungreel: {
            strengthModifier: -2,
            dexterityModifier: 2,
            perceptionModifier: 1,
            charismaModifier: -1,
            racialMovement: 4,
            visionType: "Dark Sight"
        },
        dark: {
            strengthModifier: -1,
            dexterityModifier: 1,
            bodyModifier: -1,
            perceptionModifier: 1,
            intelligenceModifier: 1,
            willpowerModifier: 1,
            charismaModifier: -2,
            beautyModifier: 2,
            visionType: "Dark Sight"
        },
        halfdark: {
            bodyModifier: -1,
            perceptionModifier: 1,
            intelligenceModifier: 1,
            willpowerModifier: 1,
            charismaModifier: -2,
            beautyModifier: 1,
            visionType: "Twilight"
        },
        kuthalan: {
            bodyModifier: 2,
            perceptionModifier: 2,
            willpowerModifier: -1,
            charismaModifier: -3,
            visionType: "Infravision"
        },
        mhentep: {
            strengthModifier: -1,
            dexterityModifier: 2,
            bodyModifier: -1,
            perceptionModifier: 2,
            willpowerModifier: -2,
            racialMovement: 4,
            visionType: "Twilight"
        },
        minotaur: {
            strengthModifier: 3,
            dexterityModifier: -1,
            bodyModifier: 2,
            perceptionModifier: -2,
            intelligenceModifier: -2,
            racialUnarmedRank: 5,
            visionType: "Twilight"
        },
        highdwarf: {
            strengthModifier: 2,
            dexterityModifier: -1,
            bodyModifier: 1,
            charismaModifier: -2,
            racialMovement: 2,
            visionType: "Dark Sight"
        },
        paledwarf: {
            strengthModifier: 2,
            dexterityModifier: -1,
            bodyModifier: 1,
            charismaModifier: -2,
            racialMovement: 2,
            visionType: "Dark Sight"
        },
        stonedwarf: {
            strengthModifier: 2,
            dexterityModifier: -1,
            bodyModifier: 1,
            charismaModifier: -2,
            racialMovement: 2,
            visionType: "Dark Sight"
        },
        nephilim: {
            strengthModifier: 1,
            perceptionModifier: 1,
            willpowerModifier: -2,
            visionType: "Chromatic/Astral Sight"
        },
        darkorc: {
            strengthModifier: 2,
            bodyModifier: 1,
            intelligenceModifier: -1,
            charismaModifier: -2,
            racialUnarmedRank: 5,
            visionType: "Dark Sight"
        },
        halforc: {
            strengthModifier: 2,
            charismaModifier: -1,
            racialUnarmedRank: 4,
            visionType: "Twilight"
        },
        orc: {
            strengthModifier: 1,
            bodyModifier: 1,
            intelligenceModifier: -1,
            charismaModifier: -1,
            racialUnarmedRank: 4,
            visionType: "Dark Sight"
        },
        sharpheen: {
            strengthModifier: 2,
            bodyModifier: 1,
            intelligenceModifier: -1,
            charismaModifier: -2,
            racialUnarmedRank: 4,
            visionType: "Infravision"
        },
        mulpheen: {
            strengthModifier: 2,
            bodyModifier: 1,
            intelligenceModifier: -1,
            charismaModifier: -2,
            racialUnarmedRank: 4,
            visionType: "Infravision"
        },
        skog: {
            strengthModifier: 2,
            bodyModifier: 1,
            perceptionModifier: 2,
            intelligenceModifier: -1,
            willpowerModifier: -2,
            charismaModifier: -2,
            racialUnarmedRank: 4,
            visionType: "Twilight"
        },
        halfskog: {
            strengthModifier: 1,
            bodyModifier: 1,
            intelligenceModifier: -1,
            charismaModifier: -1,
            racialUnarmedRank: 4,
            visionType: "Chromatic"
        },
        tarkanys: {
            strengthModifier: -2,
            dexterityModifier: 2,
            perceptionModifier: 2,
            charismaModifier: -2,
            racialMovement: 4,
            visionType: "Dark Sight"
        },
        bloodtark: {
            strengthModifier: 2,
            dexterityModifier: -2,
            perceptionModifier: 2,
            charismaModifier: -2,
            racialUnarmedRank: 5,
            visionType: "Dark Sight"
        },
        human: {
            visionType: "Chromatic",
            soulPoints: 12
        },
        mutant: {
            racialUnarmedRank: 4,
            visionType: "Dark Sight",
            soulPoints: 8
        }
    };

    on("change:class", function () {
        getAttrs(["Class", "ClassSI", "SpiritInf"], function (values) {
            let si = 2;
            switch (values.Class) {
                case "chaplain":
                case "monk":
                case "priest":
                case "shaman":
                case "templar":
                case "zealot":
                    si = 10;
                    break;
            }

            const bonus = Number(values.SpiritInf) - Number(values.ClassSI);
            setAttrs({ ClassSI: si });
            setAttrs({ SpiritInf: Number(si) + Number(bonus) });
        });
    });

    /* LEVEL AND SAGA POINTS */

    on("change:maxsaga", function () {
        updateLevel();
    });

    function updateLevel() {
        getAttrs(["MaxSaga"], function (values) {
            setAttrs({ Level: getLevel(values.MaxSaga) });
            setAttrs({ NextLevelSaga: getSagaPointsForNextLevel(values.MaxSaga) });
        });
    }

    function getLevel(saga) {
        // Find the current level based on saga points
        for (let i = 0; i < LEVEL_THRESHOLDS.length; i++) {
            if (saga < LEVEL_THRESHOLDS[i]) {
                // index 0 = level 1
                const level = i + 1;
                return level;
            }
        }
        return 100; // Max level (when saga >= 31000)
    }

    function getSagaPointsForNextLevel(saga) {
        // Find the next level threshold that hasn't been reached yet
        for (let i = 0; i < LEVEL_THRESHOLDS.length; i++) {
            if (saga < LEVEL_THRESHOLDS[i]) {
                return LEVEL_THRESHOLDS[i];
            }
        }
        return "-"; // Max level reached (level 100)
    }

    // Saga point thresholds for each level (index 0 = level 1, index 1 = level 2, etc.)
    const LEVEL_THRESHOLDS = [
        16,
        37,
        60,
        85,
        115,
        150,
        190,
        235,
        285,
        340, // Levels 1-10
        400,
        465,
        535,
        610,
        690,
        775,
        865,
        960,
        1060,
        1165, // Levels 11-20
        1275,
        1390,
        1510,
        1635,
        1765,
        1900,
        2040,
        2185,
        2335,
        2490, // Levels 21-30
        2650,
        2815,
        2985,
        3160,
        3340,
        3525,
        3715,
        3910,
        4105,
        4300, // Levels 31-40
        4495,
        4690,
        4890,
        5095,
        5300,
        5500,
        5700,
        5900,
        6100,
        6400, // Levels 41-50
        6700,
        7000,
        7300,
        7600,
        7900,
        8200,
        8500,
        8800,
        9100,
        9500, // Levels 51-60
        9900,
        10300,
        10700,
        11100,
        11500,
        11900,
        12300,
        12700,
        13100,
        13600, // Levels 61-70
        14100,
        14600,
        15100,
        15600,
        16100,
        16600,
        17100,
        17600,
        18100,
        18700, // Levels 71-80
        19200,
        19800,
        20400,
        21000,
        21600,
        22200,
        22800,
        23400,
        24000,
        24700, // Levels 81-90
        25400,
        26100,
        26800,
        27500,
        28200,
        28900,
        29600,
        30300,
        31000 // Levels 91-99
    ];

    on("change:physmod change:menmod", function () {
        updateAllSkills();
    });

    /* STRENGTH */

    on("change:strbase change:strbonus", function () {
        updateStrength();
    });

    on("change:dmgmodbonus", function () {
        getAttrs(["StrTotal", "DmgModBonus"], function (values) {
            updateDamageModifier(Number(values.StrTotal), Number(values.DmgModBonus));
        });
    });

    on("change:strhitmodbonus", function () {
        getAttrs(["StrTotal", "StrHitModBonus"], function (values) {
            updateStrengthHitModifier(Number(values.StrTotal), Number(values.StrHitModBonus));
        });
    });

    on("change:strblockmodbonus", function () {
        getAttrs(["StrTotal", "StrBlockModBonus"], function (values) {
            updateStrengthBlockModifier(Number(values.StrTotal), Number(values.StrBlockModBonus));
        });
    });

    function updateStrength() {
        getAttrs(
            ["StrBase", "StrBonus", "StrRace", "DmgModBonus", "StrHitModBonus", "StrBlockModBonus"],
            function (values) {
                let total = Number(values.StrBase) + Number(values.StrBonus) + Number(values.StrRace);
                total = Math.max(1, Math.min(total, 100));
                const rank = getRank(total);

                setAttrs({
                    StrTotal: total,
                    StrRank: rank,
                    StrDice: getDice(rank)
                });

                const damageModifierBonus = Number(values.DmgModBonus);
                updateDamageModifier(total, damageModifierBonus);

                const strengthHitModifierBonus = Number(values.StrHitModBonus);
                updateStrengthHitModifier(total, strengthHitModifierBonus);

                const strengthBlockModifierBonus = Number(values.StrBlockModBonus);
                updateStrengthBlockModifier(total, strengthBlockModifierBonus);

                updateAllSkills();
            }
        );
    }

    function updateDamageModifier(strength, damageModifierBonus) {
        const baseDamageModifier = calculateDamageModifier(strength);
        const totalDamageModifier = baseDamageModifier + damageModifierBonus;

        setAttrs({
            DmgModBase: baseDamageModifier,
            DmgModTotal: totalDamageModifier
        });

        updateAllWeaponDmgMods();
    }

    function updateStrengthHitModifier(strength, strengthHitAndBlockModifierBonus) {
        const baseStrengthHitModifier = calculateStrengthToHitAndBlockModifier(strength);
        const totalStrengthHitModifier = baseStrengthHitModifier + strengthHitAndBlockModifierBonus;

        setAttrs({
            StrHitModBase: baseStrengthHitModifier,
            StrHitModTotal: totalStrengthHitModifier
        });
    }

    function updateStrengthBlockModifier(strength, strengthHitAndBlockModifierBonus) {
        const baseStrengthBlockModifier = calculateStrengthToHitAndBlockModifier(strength);
        const totalStrengthBlockModifier = baseStrengthBlockModifier + strengthHitAndBlockModifierBonus;

        setAttrs({
            StrBlockModBase: baseStrengthBlockModifier,
            StrBlockModTotal: totalStrengthBlockModifier
        });
    }

    function calculateDamageModifier(str) {
        if (str <= 3) return Math.min(-3, 4 - str);
        if (str >= 80) return 33;
        if (str >= 15) return Math.floor((str - 13) / 2);
        return 0;
    }

    function calculateStrengthToHitAndBlockModifier(strength) {
        return calculateSharedToHitModifier(strength);
    }

    function calculateWeightAllowance(str) {
        if (str <= 3) return "vl";
        if (str <= 9) return "l";
        if (str <= 14) return "m/2vl";
        if (str <= 19) return "h/2l";
        if (str <= 30) return "vh/2m";
        if (str <= 49) return "vh/2h";
        return "vh/2vh";
    }

    /* DEXTERITY */

    on("change:dexbase change:dexbonus", function () {
        updateDexterity();
    });

    on("change:defmodbonus", function () {
        getAttrs(["DexTotal", "DefModBonus"], function (values) {
            updateDefenceModifier(Number(values.DexTotal), Number(values.DefModBonus));
        });
    });

    on("change:dexhitmodbonus", function () {
        getAttrs(["DexTotal", "DexHitModBonus"], function (values) {
            updateDexterityHitModifier(Number(values.DexTotal), Number(values.DexHitModBonus));
        });
    });

    on("change:initmodbonus", function () {
        getAttrs(["DexTotal", "InitModBonus"], function (values) {
            updateDexterityInitiativeModifier(Number(values.DexTotal), Number(values.InitModBonus));
        });
    });

    on("change:mvmtbonus", function () {
        getAttrs(["DexTotal", "RaceMvmt", "MvmtBonus"], function (values) {
            updateMovement(Number(values.DexTotal), Number(values.RaceMvmt), Number(values.MvmtBonus));
        });
    });

    function updateDexterity() {
        getAttrs(
            ["DexBase", "DexBonus", "DexRace", "DefModBonus", "DexHitModBonus", "InitModBonus", "RaceMvmt", "MvmtBonus"],
            function (values) {
                let total = Number(values.DexBase) + Number(values.DexBonus) + Number(values.DexRace);
                total = Math.max(1, Math.min(total, 100));
                const rank = getRank(total);

                setAttrs({
                    DexTotal: total,
                    DexRank: rank,
                    DexDice: getDice(rank)
                });

                const defModBonus = Number(values.DefModBonus);
                updateDefenceModifier(total, defModBonus);

                const dexHitModBonus = Number(values.DexHitModBonus);
                updateDexterityHitModifier(total, dexHitModBonus);

                const dexInitModBonus = Number(values.InitModBonus);
                updateDexterityInitiativeModifier(total, dexInitModBonus);

                const raceMvmt = Number(values.RaceMvmt);
                const mvmtBonus = Number(values.MvmtBonus);
                updateMovement(total, raceMvmt, mvmtBonus);

                updateAllSkills();
            }
        );
    }

    function updateDefenceModifier(dexterity, defenceModifierBonus) {
        const defenseModifier = calculateDefenseModifier(dexterity);

        setAttrs({
            DefModBase: defenseModifier,
            DefModTotal: defenseModifier + defenceModifierBonus
        });
    }

    function updateDexterityHitModifier(dexterity, dexterityHitInitModifierBonus) {
        const baseDexterityHitModifier = calculateToHitAndInitiativeModifier(dexterity);
        const totalDexterityHitModifier = baseDexterityHitModifier + dexterityHitInitModifierBonus;

        setAttrs({
            DexHitModBase: baseDexterityHitModifier,
            DexHitModTotal: totalDexterityHitModifier
        });
    }

    function updateDexterityInitiativeModifier(dexterity, dexterityHitInitModifierBonus) {
        const baseDexterityInitModifier = calculateToHitAndInitiativeModifier(dexterity);
        const totalDexterityInitModifier = baseDexterityInitModifier + dexterityHitInitModifierBonus;

        setAttrs({
            InitModBase: baseDexterityInitModifier,
            InitModTotal: totalDexterityInitModifier
        });
    }

    function updateMovement(dexTotal, raceMvmt, mvmtBonus) {
        const movement = raceMvmt + calculateMovementModifier(dexTotal) + mvmtBonus;

        setAttrs({
            Mvmt: movement,
            RunMvmt: movement * 2
        });
    }

    function calculateDefenseModifier(dexterity) {
        // Defense modifier uses the same calculation as to-hit modifier
        return calculateSharedToHitModifier(dexterity);
    }

    function calculateToHitAndInitiativeModifier(dexterity) {
        // To hit and initiative modifier uses the same calculation as to-hit modifier
        return calculateSharedToHitModifier(dexterity);
    }

    function calculateMovementModifier(dexterity) {
        if (dexterity <= 3) return -1;
        if (dexterity >= 60) return 5;
        if (dexterity >= 50) return 4;
        if (dexterity >= 15) return Math.floor(dexterity / 10);
        return 0;
    }

    /* BODY */

    on("change:bdybase change:bdybonus", function () {
        updateBody();
    });

    on("change:toughbonus", function () {
        getAttrs(["BdyTotal", "ToughBonus"], function (values) {
            updateToughness(Number(values.BdyTotal), Number(values.ToughBonus));
        });
    });

    function updateBody() {
        getAttrs(["BdyBase", "BdyBonus", "BdyRace", "HPAdj", "MaxHP", "ToughBonus"], function (values) {
            let total = Number(values.BdyBase) + Number(values.BdyBonus) + Number(values.BdyRace);
            total = Math.max(1, Math.min(total, 100));
            const rank = getRank(total);

            setAttrs({
                BdyTotal: total,
                BdyRank: rank,
                BdyDice: getDice(rank),
                BdySave: calculateBodySave(total)
            });

            const toughBonus = Number(values.ToughBonus);
            updateToughness(total, toughBonus);
            updateAllSkills();

            const prevHPAdj = Number(values.HPAdj);
            const newHPAdj = calculateHPAdjustment(total);
            const prevMaxHP = Number(values.MaxHP);

            setAttrs({
                HPAdj: newHPAdj,
                MaxHP: newHPAdj - prevHPAdj + prevMaxHP
            });
        });
    }

    function updateToughness(bdyTotal, toughBonus) {
        const t = calculateToughness(bdyTotal);

        setAttrs({
            ToughBase: t,
            ToughTotal: t + toughBonus
        });

        updateTotalArmorRating();
    }

    function calculateToughness(bdy) {
        if (bdy <= 17) return 0;
        if (bdy <= 21) return bdy - 17;
        if (bdy <= 26) return Math.floor((bdy - 13) / 2);
        if (bdy <= 35) return Math.floor((bdy - 6) / 3);
        if (bdy <= 47) return Math.floor((bdy + 4) / 4);
        if (bdy <= 62) return Math.floor((bdy + 17) / 5);
        if (bdy <= 74) return Math.floor((bdy + 33) / 6);
        return 18;
    }

    function calculateHPAdjustment(bdy) {
        if (bdy <= 14) return 0;
        if (bdy == 15) return 1;
        if (bdy == 16) return 3;
        if (bdy == 17) return 6;
        if (bdy == 18) return 10;
        if (bdy == 19) return 15;
        if (bdy <= 21) return 21;
        if (bdy <= 23) return 28;
        if (bdy <= 25) return 36;
        if (bdy <= 27) return 45;
        if (bdy <= 30) return 55;
        if (bdy <= 33) return 66;
        if (bdy <= 36) return 78;
        if (bdy <= 39) return 91;
        if (bdy <= 42) return 105;
        if (bdy <= 46) return 120;
        if (bdy <= 50) return 136;
        if (bdy <= 54) return 153;
        if (bdy <= 58) return 171;
        if (bdy <= 62) return 190;
        if (bdy <= 67) return 210;
        if (bdy <= 72) return 231;
        if (bdy <= 77) return 253;
        return 276;
    }

    function calculateBodySave(bdy) {
        if (bdy <= 15) return 18;
        if (bdy <= 17) return 17;
        if (bdy <= 19) return 16;
        if (bdy <= 21) return 15;
        if (bdy <= 24) return 14;
        if (bdy <= 27) return 13;
        if (bdy <= 30) return 12;
        if (bdy <= 34) return 11;
        if (bdy <= 39) return 10;
        if (bdy <= 49) return 9;
        if (bdy <= 59) return 8;
        if (bdy <= 69) return 7;
        return 6;
    }

    function updateTotalArmorRating() {
        getAttrs(
            [
                "HelmetAR",
                "AmuletAR",
                "CloakAR",
                "PauldronsAR",
                "ClothingAR",
                "TorsoAR",
                "BracersAR",
                "GlovesAR",
                "BeltAR",
                "GreavesAR",
                "BootsAR",
                "RingAR",
                "Ring2AR",
                "OtherAR",
                "Other2AR",
                "ToughTotal"
            ],
            function (values) {
                const totalArmorRating =
                    Number(values.HelmetAR) +
                    Number(values.AmuletAR) +
                    Number(values.CloakAR) +
                    Number(values.PauldronsAR) +
                    Number(values.ClothingAR) +
                    Number(values.TorsoAR) +
                    Number(values.BracersAR) +
                    Number(values.GlovesAR) +
                    Number(values.BeltAR) +
                    Number(values.GreavesAR) +
                    Number(values.BootsAR) +
                    Number(values.RingAR) +
                    Number(values.Ring2AR) +
                    Number(values.OtherAR) +
                    Number(values.Other2AR) +
                    Number(values.ToughTotal);
                setAttrs({ TotalAR: totalArmorRating });
            }
        );
    }

    /* PERCEPTION */

    on("change:prcbase change:prcbonus", function () {
        updatePerception();
    });

    on("change:shotdmgmodbonus", function () {
        getAttrs(["PrcTotal", "ShotDmgModBonus"], function (values) {
            updateShotDmgMod(Number(values.PrcTotal), Number(values.ShotDmgModBonus));
        });
    });

    on("change:prchitmodbonus", function () {
        getAttrs(["PrcTotal", "PrcHitModBonus"], function (values) {
            updatePerceptionHitModifier(Number(values.PrcTotal), Number(values.PrcHitModBonus));
        });
    });

    on("change:rgbonus", function () {
        getAttrs(["PrcTotal", "RgBonus"], function (values) {
            updateRange(Number(values.PrcTotal), Number(values.RgBonus));
        });
    });

    function updatePerception() {
        getAttrs(["PrcBase", "PrcBonus", "PrcRace", "ShotDmgModBonus", "RgBonus", "PrcHitModBonus"], function (values) {
            let total = Number(values.PrcBase) + Number(values.PrcBonus) + Number(values.PrcRace);
            total = Math.max(1, Math.min(total, 100));
            const rank = getRank(total);

            setAttrs({
                PrcTotal: total,
                PrcRank: rank,
                PrcDice: getDice(rank)
            });

            const shotDmgModBonus = Number(values.ShotDmgModBonus);
            updateShotDmgMod(total, shotDmgModBonus);

            const rgBonus = Number(values.RgBonus);
            updateRange(total, rgBonus);

            const prcHitModBonus = Number(values.PrcHitModBonus);
            updatePerceptionHitModifier(total, prcHitModBonus);

            updateAllSkills();
        });
    }

    function updateShotDmgMod(prcTotal, shotDmgModBonus) {
        const dmg = calculateShotDamageModifier(prcTotal);

        setAttrs({
            ShotDmgModBase: dmg,
            ShotDmgModTotal: dmg + shotDmgModBonus
        });

        updateAllWeaponDmgMods();
    }

    function updateRange(prcTotal, rgBonus) {
        const rg = calculateRangeModifier(prcTotal);

        setAttrs({
            RgBase: rg,
            RgTotal: rg + rgBonus
        });
    }

    function updatePerceptionHitModifier(perception, perceptionHitModifierBonus) {
        const basePerceptionHitModifier = calculateToHitModifier(perception);
        const totalPerceptionHitModifier = basePerceptionHitModifier + perceptionHitModifierBonus;

        setAttrs({
            PrcHitModBase: basePerceptionHitModifier,
            PrcHitModTotal: totalPerceptionHitModifier
        });
    }

    function calculateShotDamageModifier(prc) {
        if (prc >= 78) return 22;
        if (prc >= 15) return Math.floor((prc - 12) / 3);
        return 0;
    }

    function calculateToHitModifier(perception) {
        return calculateSharedToHitModifier(perception);
    }

    function calculateRangeModifier(prc) {
        if (prc >= 80) return 8;
        if (prc >= 15) return Math.floor(prc / 10);
        return 0;
    }

    /* INTELLIGENCE */

    on("change:intbase change:intbonus", function () {
        updateIntelligence();
    });

    on("change:speffbonus", function () {
        getAttrs(["IntTotal", "SpEffBonus"], function (values) {
            updateSpellEffect(Number(values.IntTotal), Number(values.SpEffBonus));
        });
    });

    on("change:intcastmodbonus", function () {
        getAttrs(["IntTotal", "IntCastModBonus"], function (values) {
            updateIntelligenceCastModifier(Number(values.IntTotal), Number(values.IntCastModBonus));
        });
    });

    function updateIntelligence() {
        getAttrs(["IntBase", "IntBonus", "IntRace", "SpEffBonus", "IntCastModBonus"], function (values) {
            let total = Number(values.IntBase) + Number(values.IntBonus) + Number(values.IntRace);
            total = Math.max(1, Math.min(total, 100));
            const rank = getRank(total);

            setAttrs({
                IntTotal: total,
                IntRank: rank,
                IntDice: getDice(rank),
                SpellTime: determineSpellTime(total),
                SpText: determineSpellTimeText(total),
                Langs: calculateNumberOfFluentTongues(total)
            });

            const spEffBonus = Number(values.SpEffBonus);
            updateSpellEffect(total, spEffBonus);

            const intCastModBonus = Number(values.IntCastModBonus);
            updateIntelligenceCastModifier(total, intCastModBonus);

            updateAllSkills();
        });
    }

    function updateSpellEffect(intTotal, spEffBonus) {
        const se = calculateSpellEffectModifier(intTotal);

        setAttrs({
            SpEffBase: se,
            SpEffTotal: se + spEffBonus
        });
    }

    function updateIntelligenceCastModifier(intTotal, castModBonus) {
        const baseCastModifier = calculateCastModifier(intTotal);

        setAttrs({
            IntCastModBase: baseCastModifier,
            IntCastModTotal: baseCastModifier + castModBonus
        });
    }

    function calculateCastModifier(intelligence) {
        return calculateSharedToHitModifier(intelligence);
    }

    function calculateSpellEffectModifier(int) {
        if (int >= 80) return 8;
        if (int >= 15) return Math.floor(int / 10);
        return 0;
    }

    function determineSpellTime(int) {
        if (int <= 3) return "";
        if (int <= 6) return "d4";
        if (int <= 9) return "d12";
        if (int <= 12) return "d8";
        if (int <= 14) return "d4";
        if (int <= 19) return "2d6";
        if (int <= 24) return "d8";
        if (int <= 29) return "d6";
        if (int <= 39) return "2d10";
        if (int <= 49) return "2d6";
        if (int <= 59) return "d10";
        if (int <= 69) return "d8";
        if (int <= 79) return "d6";
        return "d4";
    }

    function determineSpellTimeText(int) {
        if (int <= 3) return "";
        if (int <= 6) return "years";
        if (int <= 14) return "months";
        if (int <= 29) return "weeks";
        return "days";
    }

    function calculateNumberOfFluentTongues(int) {
        if (int <= 3) return 0;
        if (int <= 11) return 1;
        if (int <= 14) return 2;
        if (int <= 19) return 3;
        return Math.floor(int / 10 + 2);
    }

    /* WILLPOWER */

    on("change:wilbase change:wilbonus", function () {
        updateWillpower();
    });

    on("change:mendefbonus", function () {
        getAttrs(["WilTotal", "MenDefBonus"], function (values) {
            updateMenDefMod(Number(values.WilTotal), Number(values.MenDefBonus));
        });
    });

    on("change:fortbonus", function () {
        getAttrs(["WilTotal", "FortBonus"], function (values) {
            updateFortitude(Number(values.WilTotal), Number(values.FortBonus));
        });
    });

    function updateWillpower() {
        getAttrs(["WilBase", "WilBonus", "WilRace", "ManaAdj", "MaxMana", "MenDefBonus", "FortBonus"], function (values) {
            let total = Number(values.WilBase) + Number(values.WilBonus) + Number(values.WilRace);
            total = Math.max(1, Math.min(total, 100));
            const rank = getRank(total);

            setAttrs({
                WilTotal: total,
                WilRank: rank,
                WilDice: getDice(rank)
            });

            const menDefBonus = Number(values.MenDefBonus);
            updateMenDefMod(total, menDefBonus);

            const fortBonus = Number(values.FortBonus);
            updateFortitude(total, fortBonus);

            updateAllSkills();

            const prevManaAdj = Number(values.ManaAdj);
            const newManaAdj = calculateManaAdjustment(total);
            const prevMaxMana = Number(values.MaxMana);

            setAttrs({
                ManaAdj: newManaAdj,
                MaxMana: newManaAdj - prevManaAdj + prevMaxMana
            });
        });
    }

    function updateMenDefMod(wilTotal, menDefBonus) {
        const mdef = calculateMentalDefenseModifier(wilTotal);

        setAttrs({
            MenDefBase: mdef,
            MenDefTotal: mdef + menDefBonus
        });
    }

    function updateFortitude(wilTotal, fortBonus) {
        const f = calculateFortitude(wilTotal);

        setAttrs({
            FortBase: f,
            FortTotal: f + fortBonus
        });
    }

    function calculateMentalDefenseModifier(willpower) {
        // Mental defense modifier uses the same calculation as to-hit modifier
        return calculateSharedToHitModifier(willpower);
    }

    function calculateFortitude(wil) {
        if (wil >= 80) return 33;
        if (wil >= 15) return Math.floor((wil - 13) / 2);
        return 0;
    }

    function calculateManaAdjustment(wil) {
        // Mana adjustment uses the same calculation as HP adjustment
        if (wil <= 14) return 0;
        if (wil == 15) return 1;
        if (wil == 16) return 3;
        if (wil == 17) return 6;
        if (wil == 18) return 10;
        if (wil == 19) return 15;
        if (wil <= 21) return 21;
        if (wil <= 23) return 28;
        if (wil <= 25) return 36;
        if (wil <= 27) return 45;
        if (wil <= 30) return 55;
        if (wil <= 33) return 66;
        if (wil <= 36) return 78;
        if (wil <= 39) return 91;
        if (wil <= 42) return 105;
        if (wil <= 46) return 120;
        if (wil <= 50) return 136;
        if (wil <= 54) return 153;
        if (wil <= 58) return 171;
        if (wil <= 62) return 190;
        if (wil <= 67) return 210;
        if (wil <= 72) return 231;
        if (wil <= 77) return 253;
        return 276;
    }

    /* CHARISMA */

    on("change:chrbase change:chrbonus", function () {
        updateCharisma();
    });

    on("change:socialbonus", function () {
        getAttrs(["ChrTotal", "SocialBonus"], function (values) {
            updateSocialPool(Number(values.ChrTotal), Number(values.SocialBonus));
        });
    });

    function updateCharisma() {
        getAttrs(["ChrBase", "ChrBonus", "ChrRace", "SocialBonus"], function (values) {
            let total = Number(values.ChrBase) + Number(values.ChrBonus) + Number(values.ChrRace);
            total = Math.max(1, Math.min(total, 100));
            const rank = getRank(total);

            setAttrs({
                ChrTotal: total,
                ChrRank: rank,
                ChrDice: getDice(rank),
                RepBonus: calculateReputationBonus(total)
            });

            const socialBonus = Number(values.SocialBonus);
            updateSocialPool(total, socialBonus);

            updateAllSkills();
        });
    }

    function updateSocialPool(chrTotal, socialBonus) {
        const sp = calculateSocialPool(chrTotal);

        setAttrs({
            SocialBase: sp,
            SocialPool: sp + socialBonus
        });
    }

    function calculateSocialPool(chr) {
        if (chr <= 30) return Math.max(0, Math.floor(chr / 15));
        return Math.min(Math.floor((chr + 10) / 20), 4);
    }

    function calculateReputationBonus(chr) {
        if (chr >= 80) return 40;
        if (chr >= 15) return Math.floor(chr / 10) * 5;
        return 0;
    }

    /* ALLURE */

    on("change:btybase change:btybonus", function () {
        updateAllure();
    });

    on("change:socialmodbonus", function () {
        getAttrs(["BtyTotal", "SocialModBonus"], function (values) {
            updateSocialModifier(Number(values.BtyTotal), Number(values.SocialModBonus));
        });
    });

    on("change:aluinfluencebonus", function () {
        getAttrs(["BtyTotal", "AluInfluenceBonus"], function (values) {
            updateAllureInfluence(Number(values.BtyTotal), Number(values.AluInfluenceBonus));
        });
    });

    function updateAllure() {
        getAttrs(["BtyBase", "BtyBonus", "BtyRace", "AluInfluenceBonus", "SocialModBonus"], function (values) {
            let total = Number(values.BtyBase) + Number(values.BtyBonus) + Number(values.BtyRace);
            total = Math.max(1, Math.min(total, 100));
            const rank = getRank(total);

            setAttrs({
                BtyTotal: total,
                AluRank: rank,
                AluDice: getDice(rank)
            });

            const aluInfluenceBonus = Number(values.AluInfluenceBonus);
            updateAllureInfluence(total, aluInfluenceBonus);

            const socialModBonus = Number(values.SocialModBonus);
            updateSocialModifier(total, socialModBonus);

            updateAllSkills();
        });
    }

    function updateSocialModifier(allureTotal, socialModBonus) {
        const baseSocialMod = calculateSocialModifier(allureTotal);

        setAttrs({
            SocialModBase: baseSocialMod,
            SocialModTotal: baseSocialMod + socialModBonus
        });
    }

    function updateAllureInfluence(allureTotal, influenceBonus) {
        const baseInfluence = calculateInfluence(allureTotal);

        setAttrs({
            AluInfluenceBase: baseInfluence,
            AluInfluenceTotal: baseInfluence + influenceBonus
        });
    }

    function calculateInfluence(allure) {
        if (allure <= 3) return -10;
        if (allure <= 6) return -5;
        if (allure >= 80) return 40;
        if (allure >= 15) return Math.floor(allure / 10) * 5;
        return 0;
    }

    function calculateSocialModifier(allure) {
        if (allure < 2) {
            return -3;
        }
        if (allure < 4) {
            return -2;
        }
        if (allure < 7) {
            return -1;
        }
        if (allure < 16) {
            return 0;
        }
        if (allure < 20) {
            return 1;
        }
        if (allure < 30) {
            return 2;
        }
        if (allure < 40) {
            return 3;
        }
        if (allure < 50) {
            return 4;
        }
        return 5;
    }

    /* SHARED ATTRIBUTE FUNCTIONS */

    function updateAllAttributes() {
        updateStrength();
        updateDexterity();
        updateBody();
        updatePerception();
        updateIntelligence();
        updateWillpower();
        updateCharisma();
        updateAllure();
    }

    function calculateSharedToHitModifier(score) {
        // Shared modifier calculation: -3 for 1, -2 for 2, -1 for 3, 0 for 4-14, +1 for 15-19, +2 for 20-29, +3 for 30-39, etc.
        if (score <= 1) return -3;
        if (score === 2) return -2;
        if (score === 3) return -1;
        if (score <= 14) return 0;
        if (score <= 19) return 1;
        // For 20+: 20-29→2, 30-39→3, 40-49→4, etc.
        if (score <= 100) return Math.floor(score / 10);
        return 10;
    }

    function getAttributeBonus(attribute, strRank, dexRank, bdyRank, prcRank, intRank, wilRank, chrRank, aluRank) {
        switch (attribute) {
            case "str":
                return strRank;
            case "dex":
                return dexRank;
            case "bdy":
                return bdyRank;
            case "prc":
                return prcRank;
            case "int":
                return intRank;
            case "wil":
                return wilRank;
            case "chr":
                return chrRank;
            case "alu":
                return aluRank;
            default:
                console.warn("Invalid character attribute: " + attribute);
                return 0;
        }
    }

    function getConditionModifier(attribute, physMod, menMod) {
        switch (attribute) {
            case "str":
            case "dex":
            case "bdy":
            case "prc":
                return physMod;
            case "int":
            case "wil":
            case "chr":
            case "alu":
                return menMod;
            default:
                console.warn("Invalid character attribute: " + attribute);
                return 0;
        }
    }

    on("change:unarmed", function () {
        updateUnarmed();
    });

    on(
        "change:repeating_NonCombatSkills:skillattribute change:repeating_NonCombatSkills:skillrating change:repeating_NonCombatSkills:skillbonus",
        function (eventInfo) {
            // Extract the row ID from the source attribute
            // eventInfo.sourceAttribute will be something like "repeating_NonCombatSkills_-ABC123_skillattribute"
            const rowId = eventInfo.sourceAttribute.split("_")[2];

            updateAdditionalNonCombatSkill(rowId);
        }
    );

    on("change:Skill1Attribute change:Skill1Rating change:Skill1Bonus", function () {
        updateFixedNonCombatSkill(1);
    });

    on("change:Skill2Attribute change:Skill2Rating change:Skill2Bonus", function () {
        updateFixedNonCombatSkill(2);
    });

    on("change:Skill3Attribute change:Skill3Rating change:Skill3Bonus", function () {
        updateFixedNonCombatSkill(3);
    });

    on("change:Skill4Attribute change:Skill4Rating change:Skill4Bonus", function () {
        updateFixedNonCombatSkill(4);
    });

    on("change:Skill5Attribute change:Skill5Rating change:Skill5Bonus", function () {
        updateFixedNonCombatSkill(5);
    });

    on("change:Skill6Attribute change:Skill6Rating change:Skill6Bonus", function () {
        updateFixedNonCombatSkill(6);
    });

    on("change:Skill7Attribute change:Skill7Rating change:Skill7Bonus", function () {
        updateFixedNonCombatSkill(7);
    });

    on("change:Skill8Attribute change:Skill8Rating change:Skill8Bonus", function () {
        updateFixedNonCombatSkill(8);
    });

    on("change:Skill9Attribute change:Skill9Rating change:Skill9Bonus", function () {
        updateFixedNonCombatSkill(9);
    });

    on("change:Skill10Attribute change:Skill10Rating change:Skill10Bonus", function () {
        updateFixedNonCombatSkill(10);
    });

    on("change:Skill11Attribute change:Skill11Rating change:Skill11Bonus", function () {
        updateFixedNonCombatSkill(11);
    });

    on("change:Skill12Attribute change:Skill12Rating change:Skill12Bonus", function () {
        updateFixedNonCombatSkill(12);
    });

    on("change:Skill13Attribute change:Skill13Rating change:Skill13Bonus", function () {
        updateFixedNonCombatSkill(13);
    });

    on("change:Skill14Attribute change:Skill14Rating change:Skill14Bonus", function () {
        updateFixedNonCombatSkill(14);
    });

    on("change:Skill15Attribute change:Skill15Rating change:Skill15Bonus", function () {
        updateFixedNonCombatSkill(15);
    });

    on("change:Skill16Attribute change:Skill16Rating change:Skill16Bonus", function () {
        updateFixedNonCombatSkill(16);
    });

    on("change:Skill17Attribute change:Skill17Rating change:Skill17Bonus", function () {
        updateFixedNonCombatSkill(17);
    });

    on("change:Skill18Attribute change:Skill18Rating change:Skill18Bonus", function () {
        updateFixedNonCombatSkill(18);
    });

    on("change:Skill19Attribute change:Skill19Rating change:Skill19Bonus", function () {
        updateFixedNonCombatSkill(19);
    });

    on("change:Skill20Attribute change:Skill20Rating change:Skill20Bonus", function () {
        updateFixedNonCombatSkill(20);
    });

    function updateAllSkills() {
        updateAllFixedNonCombatSkills();
        updateAllAdditionalNonCombatSkills();
    }

    function updateAllFixedNonCombatSkills() {
        console.log("Updating fixed non-combat skills");

        // Keep this in sync with the number of fixed skill rows on the sheet
        const fixedSkillSlots = 20;

        for (let row = 1; row <= fixedSkillSlots; row++) {
            updateFixedNonCombatSkill(row);
        }
    }

    function updateAllAdditionalNonCombatSkills() {
        console.log("Updating all additional skills");

        getSectionIDs("NonCombatSkills", function (ids) {
            let details = "";

            for (let i = 0; i < ids.length; i++) {
                const rowId = ids[i];

                updateAdditionalNonCombatSkill(rowId);

                const skillsRowName = `repeating_NonCombatSkills_${rowId}_`;
                if (details !== "") {
                    details += ", \r\n";
                }
                details += skillsRowName;
            }

            setAttrs({ RepeatedSkillFieldIds: details });
        });
    }

    function updateFixedNonCombatSkill(row) {
        const skillNameName = `Skill${row}Name`;
        const skillAttributeName = `Skill${row}Attribute`;
        const skillRatingName = `Skill${row}Rating`;
        const skillBonusName = `Skill${row}Bonus`;
        const skillTotalName = `Skill${row}Total`;
        const skillDiceName = `Skill${row}Dice`;
        const skillConditionModName = `Skill${row}ConditionMod`;
        updateSkill(
            skillNameName,
            skillAttributeName,
            skillRatingName,
            skillBonusName,
            skillTotalName,
            skillDiceName,
            skillConditionModName
        );
    }

    function updateAdditionalNonCombatSkill(repeatingRowId) {
        const skillNameName = `repeating_NonCombatSkills_${repeatingRowId}_SkillName`;
        const skillAttributeName = `repeating_NonCombatSkills_${repeatingRowId}_SkillAttribute`;
        const skillRatingName = `repeating_NonCombatSkills_${repeatingRowId}_SkillRating`;
        const skillBonusName = `repeating_NonCombatSkills_${repeatingRowId}_SkillBonus`;
        const skillTotalName = `repeating_NonCombatSkills_${repeatingRowId}_SkillTotal`;
        const skillDiceName = `repeating_NonCombatSkills_${repeatingRowId}_SkillDice`;
        const skillConditionModName = `repeating_NonCombatSkills_${repeatingRowId}_SkillConditionMod`;

        updateSkill(
            skillNameName,
            skillAttributeName,
            skillRatingName,
            skillBonusName,
            skillTotalName,
            skillDiceName,
            skillConditionModName
        );
    }

    function updateSkill(
        skillNameName,
        skillAttributeName,
        skillRatingName,
        skillBonusName,
        skillTotalName,
        skillDiceName,
        skillConditionModName
    ) {
        getAttrs(
            [
                "StrRank",
                "DexRank",
                "BdyRank",
                "PrcRank",
                "IntRank",
                "WilRank",
                "ChrRank",
                "AluRank",
                "PhysMod",
                "MenMod",
                skillNameName,
                skillAttributeName,
                skillRatingName,
                skillBonusName
            ],
            function (values) {
                const skillName = values[skillNameName];
                const skillAttribute = values[skillAttributeName];
                const skillRating = Number(values[skillRatingName]);
                const skillBonus = Number(values[skillBonusName]);

                console.log(`Updating skill: ${skillName}`);

                const calculatedAttributes = {};

                // If no attribute is set, we can't calculate anything. It's probably a blank row anyway.
                if (skillAttribute == "-") {
                    calculatedAttributes[skillTotalName] = "-";
                    calculatedAttributes[skillDiceName] = "";
                    calculatedAttributes[skillConditionModName] = 0;

                    setAttrs(calculatedAttributes);
                    return;
                }

                const attributeBonus = getAttributeBonus(
                    skillAttribute,
                    values.StrRank,
                    values.DexRank,
                    values.BdyRank,
                    values.PrcRank,
                    values.IntRank,
                    values.WilRank,
                    values.ChrRank,
                    values.AluRank
                );

                const conditionMod = getConditionModifier(skillAttribute, values.PhysMod, values.MenMod);

                let total = "-";
                if (skillRating > 0) {
                    total = attributeBonus + skillRating + skillBonus;
                }

                calculatedAttributes[skillTotalName] = total;
                calculatedAttributes[skillDiceName] = getDice(total);
                calculatedAttributes[skillConditionModName] = conditionMod;

                setAttrs(calculatedAttributes);
            }
        );
    }

    function updateLangSkills() {
        getAttrs(
            ["IntRank", "Lang1Rating", "Lang1Bonus", "Lang2Rating", "Lang2Bonus", "Lang3Rating", "Lang3Bonus"],
            function (values) {
                let total = "-";
                if (Number(values.Lang1Rating) > 0) {
                    total = Number(values.IntRank) + Number(values.Lang1Rating) + Number(values.Lang1Bonus);
                }
                setAttrs({ Lang1Total: total });
                setAttrs({ Lang1Dice: getDice(total) });

                total = 0;
                if (Number(values.Lang2Rating) > 0) {
                    total = Number(values.IntRank) + Number(values.Lang2Rating) + Number(values.Lang2Bonus);
                }
                setAttrs({ Lang2Total: total });
                setAttrs({ Lang2Dice: getDice(total) });

                total = 0;
                if (Number(values.Lang3Rating) > 0) {
                    total = Number(values.IntRank) + Number(values.Lang3Rating) + Number(values.Lang3Bonus);
                }
                setAttrs({ Lang3Total: total });
                setAttrs({ Lang3Dice: getDice(total) });
            }
        );
    }

    function updateAllWeaponDmgMods() {
        for (let i = 1; i <= 6; i++) {
            updateWeaponDmgMod(i);
        }
    }

    // Generic weapon damage mod update function
    function updateWeaponDmgMod(weaponNum) {
        const typeAttr = "W" + weaponNum + "Type";
        const dmgModAttr = "W" + weaponNum + "DmgMod";

        getAttrs([typeAttr, "DmgModTotal", "ShotDmgModTotal"], function (values) {
            let x = 0;
            if (values[typeAttr] == "m") {
                x = values.DmgModTotal;
            } else if (values[typeAttr] == "r") {
                x = values.ShotDmgModTotal;
            }
            const attrs = {};
            attrs[dmgModAttr] = x;
            setAttrs(attrs);
        });
    }

    function updateUnarmed() {
        getAttrs(["Unarmed", "RaceUnarmedRank", "Race"], function (values) {
            const baseRank = Math.max(0, Number(values.Unarmed) - 2);
            const rank = Number(values.RaceUnarmedRank) + Number(baseRank);
            const unarmedDamage = getDice(rank);
            const unarmedDisplayName = getUnarmedDisplayName(Number(values.Unarmed));

            let racialUnarmedAttackName = "";
            let racialUnarmedAttackDamage = getDice(rank);

            if (values.Race == "mungreel") {
                racialUnarmedAttackName = "Blade Teeth";
                racialUnarmedAttackDamage = "d12!";
            } else if (values.Race == "mhentep") {
                racialUnarmedAttackName = "Claws";
                racialUnarmedAttackDamage = unarmedDamage + "+3";
            } else {
                // Most races don't have special unarmed abilities
                racialUnarmedAttackName = "None";
            }

            // Update all attributes in a single call
            setAttrs({
                UnarmedHit: Number(values.Unarmed),
                UnarmedRank: baseRank,
                UnarmedDmg: unarmedDamage,
                UnarmedDisplayName: unarmedDisplayName,
                RacialUnarmedName: racialUnarmedAttackName,
                RacialUnarmedDmg: racialUnarmedAttackDamage
            });
        });
    }

    function getUnarmedDisplayName(unarmedValue) {
        const unarmedNames = {
            0: "Unarmed: Basic",
            1: "Unarmed: Fighter (+1)",
            2: "Unarmed: Brawler (+2)",
            3: "Unarmed: Martial Arts (+3)",
            4: "Unarmed: Martial Arts (+4)",
            5: "Unarmed: Martial Arts (+5)",
            6: "Unarmed: Champion (+6)",
            7: "Unarmed: Champion (+7)",
            8: "Unarmed: Master (+8)",
            9: "Unarmed: Master (+9)",
            10: "Unarmed: Grand Master (+10)"
        };
        return unarmedNames[unarmedValue] || "Unarmed: Basic";
    }

    on("change:honorrep change:corruptrep", function () {
        getAttrs(["HonorRep", "CorruptRep"], function (values) {
            const goodRepDetails = getReputationDetails(values.HonorRep);

            const badRepDetails = getReputationDetails(values.CorruptRep);

            const totalReputation = Number.parseInt(values.HonorRep) + Number.parseInt(values.CorruptRep);
            const totalRepDetails = getReputationDetails(totalReputation);
            const talents = totalRepDetails.level - 1;
            const totalReputationString = totalReputation.toLocaleString();

            setAttrs({
                TotalReputation: totalReputationString,
                TotalReputationForNextLevel: totalRepDetails.nextLevel,
                ReputationTalents: talents,
                Glory: totalRepDetails.glory,
                HonorTitle: goodRepDetails.goodTitle,
                CorruptionTitle: badRepDetails.badTitle
            });
        });
    });

    function getReputationDetails(reputation) {
        if (reputation < 100)
            return {
                level: 1,
                nextLevel: "100",
                glory: 0,
                goodTitle: "Unknown",
                badTitle: "Unknown"
            };
        if (reputation < 250)
            return {
                level: 2,
                nextLevel: "250",
                glory: 10,
                goodTitle: "Known",
                badTitle: "Wanted"
            };
        if (reputation < 600)
            return {
                level: 3,
                nextLevel: "600",
                glory: 20,
                goodTitle: "Respected",
                badTitle: "Hunted"
            };
        if (reputation < 1000)
            return {
                level: 4,
                nextLevel: "1,000",
                glory: 30,
                goodTitle: "Highly Respected",
                badTitle: "Feared"
            };
        if (reputation < 1450)
            return {
                level: 5,
                nextLevel: "1,450",
                glory: 40,
                goodTitle: "Local Hero",
                badTitle: "Villain"
            };
        if (reputation < 2000)
            return {
                level: 6,
                nextLevel: "2,000",
                glory: 50,
                goodTitle: "Great Hero",
                badTitle: "Infamous Villain"
            };
        if (reputation < 3000)
            return {
                level: 7,
                nextLevel: "3,000",
                glory: 55,
                goodTitle: "Immortal Hero",
                badTitle: "Immortal Villain"
            };
        if (reputation < 5000)
            return {
                level: 8,
                nextLevel: "5,000",
                glory: 60,
                goodTitle: "Epic Hero",
                badTitle: "Arch-villain"
            };
        if (reputation < 8000)
            return {
                level: 9,
                nextLevel: "8,000",
                glory: 65,
                goodTitle: "Revered Hero",
                badTitle: "Nemesis"
            };
        if (reputation < 12000)
            return {
                level: 10,
                nextLevel: "12,000",
                glory: 70,
                goodTitle: "Legendary Hero",
                badTitle: "Arch-nemesis"
            };
        if (reputation < 50000)
            return {
                level: 11,
                nextLevel: "50,000",
                glory: 80,
                goodTitle: "Great Legendary Hero",
                badTitle: "Legendary Arch-nemesis"
            };
        if (reputation < 100000)
            return {
                level: 12,
                nextLevel: "100,000",
                glory: 90,
                goodTitle: "Exalted Legendary Hero",
                badTitle: "Unhallowed Scourge"
            };
        return {
            level: 13,
            nextLevel: "-",
            glory: 99,
            goodTitle: "Demigod",
            badTitle: "Demigod"
        };
    }
</script>

<div class="sheet-demon-gate-charsheet">
    <div class="sheet-background-flex-layout">
        <div class="sheet-background-column-fixed-left"></div>
        <div class="sheet-background-column-grow">
            <input
                type="radio"
                class="sheet-tab sheet-tab1"
                name="attr_core-tab"
                value="1"
                title="Attributes"
                checked="checked"
            />
            <span class="sheet-tab sheet-tab1">Attributes</span>
            <input type="radio" class="sheet-tab sheet-tab2" name="attr_core-tab" value="2" title="Skills" />
            <span class="sheet-tab sheet-tab2">Skills</span>
            <input type="radio" class="sheet-tab sheet-tab3" name="attr_core-tab" value="3" title="Combat" />
            <span class="sheet-tab sheet-tab3">Combat</span>
            <input type="radio" class="sheet-tab sheet-tab4" name="attr_core-tab" value="4" title="Gear" />
            <span class="sheet-tab sheet-tab4">Gear</span>
            <input type="radio" class="sheet-tab sheet-tab5" name="attr_core-tab" value="5" title="Mystic" />
            <span class="sheet-tab sheet-tab5">Mystic</span>
            <input type="radio" class="sheet-tab sheet-tab6" name="attr_core-tab" value="6" title="Abilities" />
            <span class="sheet-tab sheet-tab6">Abilities</span>
            <input type="radio" class="sheet-tab sheet-tab7" name="attr_core-tab" value="7" title="Reputation" />
            <span class="sheet-tab sheet-tab7">Reputation</span>
            <input type="radio" class="sheet-tab sheet-tab8" name="attr_core-tab" value="8" title="Notes" />
            <span class="sheet-tab sheet-tab8">Notes</span>

            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------  Attributes Tab  -----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-core">
                <div class="sheet-flex-section">
                    <div class="sheet-column-fixed">
                        <img
                            class="sheet-demon-gate-logo"
                            src="https://raw.githubusercontent.com/Roll20/roll20-character-sheets/master/Demon%20Gate/DemonGateLogo.png"
                        />
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th>Character Name:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <input
                                        type="text"
                                        class="sheet-input-wide sheet-input-full"
                                        name="attr_character_name"
                                    />
                                </td>
                            </tr>
                            <tr>
                                <th>Title or Alias:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Title" />
                                </td>
                            </tr>
                            <tr>
                                <th>Player Name:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_Player" />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th rowspan="2">Class:</th>
                                <td class="sheet-table-column-fullwidth">
                                    <select name="attr_Class" class="sheet-input-wide sheet-input-full">
                                        <option value="x">---</option>
                                        <option value="alchemist">Alchemist</option>
                                        <option value="assassin">Assassin</option>
                                        <option value="barbarian">Barbarian</option>
                                        <option value="bard">Bard</option>
                                        <option value="bowmaster">Bow Master</option>
                                        <option value="chaplain">Chaplain</option>
                                        <option value="courtesan">Courtesan</option>
                                        <option value="demonhunter">Demon Hunter</option>
                                        <option value="emissary">Emissary</option>
                                        <option value="enchanter">Enchanter</option>
                                        <option value="knighterrant">Knight Errant</option>
                                        <option value="mage">Mage</option>
                                        <option value="merchant">Merchant</option>
                                        <option value="monk">Monk</option>
                                        <option value="mudai">Mu Dai</option>
                                        <option value="pirate">Pirate</option>
                                        <option value="priest">Priest</option>
                                        <option value="ranger">Ranger</option>
                                        <option value="scout">Scout</option>
                                        <option value="shaman">Shaman</option>
                                        <option value="skaldberserker">Skald Berserker</option>
                                        <option value="slave">Slave</option>
                                        <option value="summoner">Summoner</option>
                                        <option value="swordmaster">Sword Master</option>
                                        <option value="templar">Templar</option>
                                        <option value="thief">Thief</option>
                                        <option value="warrior">Warrior</option>
                                        <option value="zealot">Zealot</option>
                                    </select>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-table-column-fullwidth">
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_AltClass" />
                                </td>
                            </tr>
                            <tr>
                                <th rowspan="2">Race:</th>
                                <td>
                                    <select name="attr_Race" class="sheet-input-wide sheet-input-full">
                                        <option value="x">---</option>
                                        <option value="ogre">Bogkroll (Ogre)</option>
                                        <option value="troll">Bogkroll (Troll)</option>
                                        <option value="highelf">Eldrynn (High)</option>
                                        <option value="halfelf">Eldrynn (Half-Elf)</option>
                                        <option value="shadow">Eldrynn (Shadow)</option>
                                        <option value="dungoblin">Goblin (Dungoblin)</option>
                                        <option value="knocker">Goblin (Knocker)</option>
                                        <option value="mungreel">Goblin (Mungreel)</option>
                                        <option value="dark">Kai Eldrynn (Dark)</option>
                                        <option value="halfdark">Kai Eldrynn (Half-Dark-Elf)</option>
                                        <option value="kuthalan">Kuthalan (Reaver)</option>
                                        <option value="mhentep">Mhen Tep (Grimalkin)</option>
                                        <option value="minotaur">Minotaur (Broman)</option>
                                        <option value="highdwarf">Mongru (High Dwarf)</option>
                                        <option value="paledwarf">Mongru (Pale Dwarf)</option>
                                        <option value="stonedwarf">Mongru (Stone Dwarf)</option>
                                        <option value="nephilim">Nephilim (Watcher)</option>
                                        <option value="darkorc">Org (Dark Orc)</option>
                                        <option value="halforc">Org (Half-Orc)</option>
                                        <option value="orc">Org (Orc)</option>
                                        <option value="sharpheen">Sharpheen (Lizard Kin)</option>
                                        <option value="mulpheen">Sharpheen (Mulpheen)</option>
                                        <option value="skog">Skog (Beastkin)</option>
                                        <option value="halfskog">Skog (Half-Brute)</option>
                                        <option value="tarkanys">Tarkanys (Ratkin)</option>
                                        <option value="bloodtark">Tarkanys (Blood Tark)</option>
                                        <option value="human">Terran (Human)</option>
                                        <option value="mutant">Vatagi (Mutant)</option>
                                    </select>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" class="sheet-input-wide sheet-input-full" name="attr_AltRace" />
                                </td>
                            </tr>
                            <tr>
                                <th colspan="2" class="sheet-cell-right">
                                    <span class="sheet-info" name="attr_RaceSummary"></span>
                                </th>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-fixed">
                        <table>
                            <tr>
                                <th>Saved Saga Points:</th>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="number"
                                        class="sheet-input-narrow"
                                        name="attr_SavedSaga"
                                        value="0"
                                        min="0"
                                    />
                                </td>
                            </tr>
                            <tr>
                                <th>Total Saga Points:</th>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="number"
                                        class="sheet-input-narrow"
                                        name="attr_MaxSaga"
                                        value="0"
                                        min="0"
                                    />
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-prominent-label">Level:</th>
                                <td>
                                    <input
                                        type="number"
                                        class="sheet-prominent-field sheet-input-narrow"
                                        name="attr_Level"
                                        min="1"
                                        value="1"
                                        readonly
                                    />
                                </td>
                            </tr>
                            <tr>
                                <th>Saga Points for Next Level:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        class="sheet-input-narrow"
                                        name="attr_NextLevelSaga"
                                        value="0"
                                        min="0"
                                        readonly
                                    />
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>

                <div class="sheet-flex-section-no-margin">
                    <div class="sheet-column-grow">
                        <div class="sheet-flex-section-centre">
                            <div class="sheet-column-prominent-stat">
                                <!-- Hidden attributes for migration tracking -->
                                <input type="hidden" name="attr_HpConverted" value="" />
                                <input type="hidden" name="attr_SheetVersion" value="" />

                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Hit Points</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input
                                                type="number"
                                                class="sheet-extra-prominent-field"
                                                name="attr_HP"
                                                min="1"
                                                value="1"
                                            />
                                            <input type="hidden" name="attr_CurHP" min="0" value="0" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <th>Max</th>
                                        <td class="sheet-cell-numeric">
                                            <input
                                                type="number"
                                                name="attr_HP_max"
                                                class="sheet-input-full"
                                                min="1"
                                                value="1"
                                            />
                                            <input type="hidden" name="attr_MaxHP" min="0" value="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>

                            <div class="sheet-column-prominent-stat">
                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Mana Pool</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input
                                                type="number"
                                                class="sheet-extra-prominent-field"
                                                name="attr_Mana"
                                                value="0"
                                                min="0"
                                                max="@{MaxMana}"
                                            />
                                            <input type="hidden" name="attr_CurMana" value="0" min="0" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <th>Max</th>
                                        <td class="sheet-cell-numeric">
                                            <input
                                                type="number"
                                                name="attr_Mana_max"
                                                class="sheet-input-full"
                                                value="0"
                                                min="0"
                                            />
                                            <input type="hidden" name="attr_MaxMana" value="0" min="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>

                            <div class="sheet-column-prominent-stat">
                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Chi Pool</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input
                                                type="number"
                                                class="sheet-extra-prominent-field"
                                                name="attr_Chi"
                                                value="0"
                                                min="0"
                                                max="@{MaxChi}"
                                            />
                                            <input type="hidden" name="attr_CurChi" value="0" min="0" max="@{MaxChi}" />
                                        </td>
                                    </tr>
                                    <tr>
                                        <th>Max</th>
                                        <td class="sheet-cell-numeric">
                                            <input
                                                type="number"
                                                class="sheet-input-full"
                                                name="attr_Chi_max"
                                                value="0"
                                                min="0"
                                            />
                                            <input type="hidden" name="attr_MaxChi" value="0" min="0" />
                                        </td>
                                    </tr>
                                </table>
                            </div>

                            <div class="sheet-column-prominent-stat">
                                <table>
                                    <tr>
                                        <th colspan="2">
                                            <h2>Frenzy</h2>
                                        </th>
                                    </tr>
                                    <tr>
                                        <td colspan="2">
                                            <input
                                                type="number"
                                                class="sheet-extra-prominent-field"
                                                name="attr_Frenzy"
                                                value="0"
                                                min="0"
                                            />
                                        </td>
                                    </tr>
                                </table>
                            </div>
                        </div>

                        <table class="sheet-vertical-margin-moderate">
                            <tr>
                                <th colspan="7">
                                    <h2>Physical Condition</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text sheet-physical-condition-0">
                                    <input type="radio" value="+0" name="attr_PhysMod" checked="true" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-1">
                                    <input type="radio" value="-0" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-2">
                                    <input type="radio" value="-1" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-3">
                                    <input type="radio" value="-2" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-4">
                                    <input type="radio" value="-3" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-5">
                                    <input type="radio" value="-4" name="attr_PhysMod" />
                                </td>
                                <td class="sheet-small-text sheet-physical-condition-6">
                                    <input type="radio" value="-5" name="attr_PhysMod" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">0%</td>
                                <td class="sheet-small-text">-10%</td>
                                <td class="sheet-small-text">-25%</td>
                                <td class="sheet-small-text">-50%</td>
                                <td class="sheet-small-text">-75%</td>
                                <td class="sheet-small-text">-90%</td>
                                <td class="sheet-small-text">-100%</td>
                            </tr>
                            <tr>
                                <th class="sheet-small-text">Rested</th>
                                <th class="sheet-small-text">Tired</th>
                                <th class="sheet-small-text">Weary</th>
                                <th class="sheet-small-text">Fatigued</th>
                                <th class="sheet-small-text">Exhausted</th>
                                <th class="sheet-small-text">Over-Exhausted</th>
                                <th class="sheet-small-text">Critical</th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">-1 rolls</td>
                                <td class="sheet-small-text">-2 rolls</td>
                                <td class="sheet-small-text">-3 rolls</td>
                                <td class="sheet-small-text">-4 rolls</td>
                                <td class="sheet-small-text">-5 rolls</td>
                            </tr>
                        </table>

                        <table class="sheet-vertical-margin-moderate">
                            <tr>
                                <th colspan="7">
                                    <h2>Mental Condition</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text sheet-mental-condition-0">
                                    <input type="radio" value="+0" name="attr_MenMod" checked="true" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-1">
                                    <input type="radio" value="-0" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-2">
                                    <input type="radio" value="-1" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-3">
                                    <input type="radio" value="-2" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-4">
                                    <input type="radio" value="-3" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-5">
                                    <input type="radio" value="-4" name="attr_MenMod" />
                                </td>
                                <td class="sheet-small-text sheet-mental-condition-6">
                                    <input type="radio" value="-5" name="attr_MenMod" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">0%</td>
                                <td class="sheet-small-text">-10%</td>
                                <td class="sheet-small-text">-25%</td>
                                <td class="sheet-small-text">-50%</td>
                                <td class="sheet-small-text">-75%</td>
                                <td class="sheet-small-text">-90%</td>
                                <td class="sheet-small-text">-100%</td>
                            </tr>
                            <tr>
                                <th class="sheet-small-text">Content</th>
                                <th class="sheet-small-text">Agitated</th>
                                <th class="sheet-small-text">Distraught</th>
                                <th class="sheet-small-text">Irrational</th>
                                <th class="sheet-small-text">Unstable</th>
                                <th class="sheet-small-text">Maniacal</th>
                                <th class="sheet-small-text">Senseless</th>
                            </tr>
                            <tr>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">No Mod</td>
                                <td class="sheet-small-text">-1 rolls</td>
                                <td class="sheet-small-text">-2 rolls</td>
                                <td class="sheet-small-text">-3 rolls</td>
                                <td class="sheet-small-text">-4 rolls</td>
                                <td class="sheet-small-text">-5 rolls</td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <h1 class="sheet-vertical-margin">Attributes</h1>

                        <!--Strength-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Strength</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_StrBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_StrBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_StrRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_StrTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_StrRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_StrDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Strength Check}} {{roll=[[@{StrDice}@{PhysMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Damage Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DmgModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DmgModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_DmgModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Hit Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_StrHitModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_StrHitModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_StrHitModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Block Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_StrBlockModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_StrBlockModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_StrBlockModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Weight Allowance:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        class="sheet-text-centred"
                                        name="attr_WtAllow"
                                        value="vl"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Dexterity-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Dexterity</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DexBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DexBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_DexRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_DexTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DexRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_DexDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Dexterity Check}} {{roll=[[@{DexDice}@{PhysMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Defense Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DefModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DefModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_DefModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Hit Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_DexHitModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_DexHitModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_DexHitModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Initiative Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_InitModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_InitModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_InitModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Movement:</th>
                                <td class="sheet-cell-numeric"></td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MvmtBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_RaceMvmt" value="0" />
                                    <input
                                        type="number"
                                        name="attr_Mvmt"
                                        value="0"
                                        readonly
                                        class="sheet-input-split"
                                    />
                                    <span class="sheet-input-spacer">/</span>
                                    <input
                                        type="number"
                                        name="attr_RunMvmt"
                                        value="0"
                                        readonly
                                        class="sheet-input-split"
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Body-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Body</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BdyBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BdyBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_BdyRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_BdyTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_BdyRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_BdyDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Body Check}} {{roll=[[@{BdyDice}@{PhysMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Toughness:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ToughBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ToughBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_ToughTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Body Save:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_HPAdj" value="0" />
                                    <input type="number" name="attr_BdySave" value="0" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:percentile} {{character=@{character_name}}} [[ ([[1d20 + ?{Modifier|0}]] - @{BdySave}) * -1]] ]] {{name=Body Save}} {{roll=$[[0]]}} {{target=@{BdySave}}} {{difference=$[[1]]}}"
                                    ></button>
                                </td>
                                <td colspan="2"></td>
                            </tr>
                        </table>

                        <!--Perception-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Perception</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_PrcBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_PrcBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_PrcRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_PrcTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_PrcRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_PrcDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Perception Check}} {{roll=[[@{PrcDice}@{PhysMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Shot Damage Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ShotDmgModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShotDmgModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_ShotDmgModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Hit Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_PrcHitModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_PrcHitModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_PrcHitModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Range Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_RgBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_RgBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_RgTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Intelligence-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Intelligence</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_IntBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_IntBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_IntRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_IntTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_IntRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_IntDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Intelligence Check}} {{roll=[[@{IntDice}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Spell Effect:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SpEffBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SpEffBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_SpEffTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Cast Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_IntCastModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_IntCastModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_IntCastModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Spell Time:</th>
                                <td></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="text" name="attr_SpellTime" readonly class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="text" name="attr_SpText" readonly class="sheet-text-centred" />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Languages:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_Langs" value="0" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Willpower-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Willpower</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_WilBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_WilBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_WilRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_WilTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_WilRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_WilDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Willpower Check}} {{roll=[[@{WilDice}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Mental Defense:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_ManaAdj" value="0" />
                                    <input type="number" name="attr_MenDefBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MenDefBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_MenDefTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Fortitude:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_FortBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_FortBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_FortTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Charisma-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Rank</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Charisma</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ChrBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ChrBonus" value="0" min="-100" max="100" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="hidden" name="attr_ChrRace" value="0" />
                                    <input
                                        type="number"
                                        name="attr_ChrTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_ChrRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_ChrDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Charisma Check}} {{roll=[[@{ChrDice}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Social Pool:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SocialBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SocialBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SocialPool" value="0" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Reputation Bonus:</th>
                                <td colspan="2"></td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_RepBonus" value="0" readonly />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>

                        <!--Allure-->
                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header sheet-header-column">Attribute</th>
                                <th class="sheet-small-table-header">Base</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header"></th>
                            </tr>
                            <tr>
                                <th>
                                    <h3>Allure</h3>
                                </th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BtyBase" value="3" min="1" max="100" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BtyBonus" value="0" min="-100" max="100" />
                                    <input type="hidden" name="attr_BtyRace" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_BtyTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_AluRank" value="0" readonly />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_AluDice"
                                        value="d1"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Allure Check}} {{roll=[[@{AluDice}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Social Modifier:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_SocialModBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SocialModBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_SocialModTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                            <tr>
                                <th>Influence:</th>
                                <td class="sheet-cell-numeric-readonly">
                                    <input type="number" name="attr_AluInfluenceBase" value="0" readonly />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_AluInfluenceBonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        name="attr_AluInfluenceTotal"
                                        value="0"
                                        class="sheet-totalfield"
                                        readonly
                                    />
                                </td>
                                <td colspan="3"></td>
                            </tr>
                        </table>
                    </div>
                </div>
            </div>
            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------  Skills Tab  ----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-skills">
                <div class="sheet-flex-section">
                    <div class="sheet-column-fixed">
                        <h1>Combat Skills</h1>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Melee</h2>
                            <div class="sheet-collapse-section">
                                <input
                                    type="checkbox"
                                    name="attr_SkillsExpandedMelee"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Unarmed</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Unarmed">
                                                    <option value="0">Basic</option>
                                                    <option value="1">Fighter (+1)</option>
                                                    <option value="2">Brawler (+2)</option>
                                                    <option value="3">Martial Arts (+3)</option>
                                                    <option value="4">Martial Arts (+4)</option>
                                                    <option value="5">Martial Arts (+5)</option>
                                                    <option value="6">Champion (+6)</option>
                                                    <option value="7">Champion (+7)</option>
                                                    <option value="8">Master (+8)</option>
                                                    <option value="9">Master (+9)</option>
                                                    <option value="10">Grand Master (+10)</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Axes</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Axes">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Flails</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Flails">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Grenades</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Grenades">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Hammers</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Hammers">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Javelins</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Javelins">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Knives</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Knives">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Maces</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Maces">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Polearms</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Polearms">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Shurikens</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Shurikens">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Staves</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Staves">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Swords</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Swords">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Whips</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Whips">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blind Fighting</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td>
                                                <select name="attr_BlindFighting">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Dual Melee</td>
                                            <td class="sheet-cell-numeric-readonly">3</td>
                                            <td>
                                                <select name="attr_DualMelee">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Throwing</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td>
                                                <select name="attr_Throwing">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td colspan="3" class="sheet-info sheet-cell-right">* = As Rating</td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Shooting</h2>
                            <div class="sheet-collapse-section">
                                <input
                                    type="checkbox"
                                    name="attr_SkillsExpandedShooting"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Black Powder</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td>
                                                <select name="attr_BlackPowder">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Lances</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Lances">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Pistols</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Pistols">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Rifles</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Rifles">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Shotguns</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Shotguns">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blind Shooting</td>
                                            <td class="sheet-cell-numeric-readonly">2</td>
                                            <td>
                                                <select name="attr_BlindShooting">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Dual Shooting</td>
                                            <td class="sheet-cell-numeric-readonly">3</td>
                                            <td>
                                                <select name="attr_DualShooting">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Projectiles</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td>
                                                <select name="attr_Projectiles">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Blow Guns</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_BlowGuns">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Bows</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Bows">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Crossbows</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Crossbows">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Hand Bows</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_HandBows">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Slings</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Slings">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Siege Weapons</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td>
                                                <select name="attr_Siege">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Ballistae</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Ballistae">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Cannons</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Cannons">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Catapults</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Catapults">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname-indented">Trebuchets</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_Trebuchets">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Magic</h2>
                            <div class="sheet-collapse-section">
                                <input
                                    type="checkbox"
                                    name="attr_SkillsExpandedMagic"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Sorcery</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td>
                                                <select name="attr_Sorcery">
                                                    <option value="0">---</option>
                                                    <option value="1">Owned</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Black Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_BlackMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Blue Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_BlueMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Brown Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_BrownMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Gold Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_GoldMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Gray Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_GrayMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Green Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_GreenMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Red Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_RedMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">White Magic</td>
                                            <td class="sheet-cell-numeric-readonly">*</td>
                                            <td>
                                                <select name="attr_WhiteMagic">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Armor</h2>
                            <div class="sheet-collapse-section">
                                <input
                                    type="checkbox"
                                    name="attr_SkillsExpandedArmor"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Cost</th>
                                            <th class="sheet-small-table-header">Owned?</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Light Armor</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-centred">
                                                <input type="checkbox" name="attr_LightArmorOwned" value="1" />
                                            </td>
                                            <td>
                                                <select name="attr_LightArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Medium Armor</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-centred">
                                                <input type="checkbox" name="attr_MedArmorOwned" value="1" />
                                            </td>
                                            <td>
                                                <select name="attr_MedArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Heavy Armor</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td class="sheet-cell-centred">
                                                <input type="checkbox" name="attr_HeavyArmorOwned" value="1" />
                                            </td>
                                            <td>
                                                <select name="attr_HeavyArmor">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                        <tr>
                                            <td class="sheet-skillname">Shields</td>
                                            <td class="sheet-cell-numeric-readonly">1</td>
                                            <td></td>
                                            <td>
                                                <select name="attr_Shields">
                                                    <option value="0">---</option>
                                                    <option value="1">+1</option>
                                                    <option value="2">+2</option>
                                                    <option value="3">+3</option>
                                                    <option value="4">+4</option>
                                                    <option value="5">+5</option>
                                                    <option value="6">+6</option>
                                                    <option value="7">+7</option>
                                                    <option value="8">+8</option>
                                                    <option value="9">+9</option>
                                                    <option value="10">+10</option>
                                                </select>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Combat Specializations</h2>
                            <div class="sheet-collapse-section">
                                <input
                                    type="checkbox"
                                    name="attr_SkillsExpandedCombatSpecs"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <table>
                                        <tr>
                                            <th class="sheet-small-table-header">Name</th>
                                            <th class="sheet-small-table-header">Rating</th>
                                        </tr>
                                        <tr>
                                            <td colspan="2">
                                                <fieldset class="repeating_wpnspecs">
                                                    <div class="sheet-repeating-section">
                                                        <table>
                                                            <tr>
                                                                <td>
                                                                    <input
                                                                        type="text"
                                                                        name="attr_WpnSpecName"
                                                                        value=""
                                                                    />
                                                                </td>
                                                                <td class="sheet-cell-numeric">
                                                                    <input
                                                                        type="number"
                                                                        name="attr_WpnSpecRating"
                                                                        value=""
                                                                    />
                                                                </td>
                                                            </tr>
                                                        </table>
                                                    </div>
                                                </fieldset>
                                            </td>
                                        </tr>
                                    </table>
                                </div>
                            </div>
                        </div>

                        <h1 class="sheet-spacer-top-margin">Languages</h1>

                        <div class="sheet-collapse-wrapper">
                            <h2 class="sheet-table-header-collapse">Fluent Languages</h2>
                            <div class="sheet-collapse-section">
                                <input
                                    type="checkbox"
                                    name="attr_SkillsExpandedFluentLanguages"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <div class="sheet-collapsible">
                                    <fieldset class="repeating_languages">
                                        <div class="sheet-repeating-section">
                                            <table>
                                                <tr>
                                                    <td>
                                                        <input type="text" name="attr_LearnedLang" value="" />
                                                    </td>
                                                </tr>
                                            </table>
                                        </div>
                                    </fieldset>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="sheet-column-grow">
                        <div>
                            <h1>Non-Combat Skills</h1>
                        </div>

                        <table class="sheet-vertical-margin">
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Cost</th>
                                <th class="sheet-small-table-header">Attr</th>
                                <th class="sheet-small-table-header">Rating</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Total</th>
                                <th class="sheet-small-table-header">Tier</th>
                                <th class="sheet-small-table-header">Dice</th>
                                <th class="sheet-small-table-header">Roll</th>
                            </tr>

                            <!-- Non-Combat Skill 1 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill1Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill1Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill1Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill1Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill1Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill1Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill1Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill1Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill1ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill1Name} Check}} {{text=Roll: [[@{Skill1Dice}@{Skill1Tier}@{Skill1ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 2 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill2Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill2Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill2Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill2Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill2Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill2Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill2Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill2Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill2ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill2Name} Check}} {{text=Roll: [[@{Skill2Dice}@{Skill2Tier}@{Skill2ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 3 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill3Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill3Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill3Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill3Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill3Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill3Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill3Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill3Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill3ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill3Name} Check}} {{text=Roll: [[@{Skill3Dice}@{Skill3Tier}@{Skill3ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 4 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill4Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill4Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill4Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill4Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill4Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill4Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill4Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill4Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill4ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill4Name} Check}} {{text=Roll: [[@{Skill4Dice}@{Skill4Tier}@{Skill4ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 5 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill5Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill5Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill5Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill5Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill5Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill5Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill5Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill5Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill5ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill5Name} Check}} {{text=Roll: [[@{Skill5Dice}@{Skill5Tier}@{Skill5ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 6 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill6Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill6Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill6Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill6Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill6Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill6Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill6Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill6Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill6ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill6Name} Check}} {{text=Roll: [[@{Skill6Dice}@{Skill6Tier}@{Skill6ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 7 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill7Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill7Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill7Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill7Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill7Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill7Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill7Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill7Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill7ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill7Name} Check}} {{text=Roll: [[@{Skill7Dice}@{Skill7Tier}@{Skill7ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 8 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill8Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill8Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill8Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill8Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill8Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill8Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill8Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill8Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill8ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill8Name} Check}} {{text=Roll: [[@{Skill8Dice}@{Skill8Tier}@{Skill8ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 9 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill9Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill9Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill9Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill9Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill9Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill9Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill9Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill9Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill9ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill9Name} Check}} {{text=Roll: [[@{Skill9Dice}@{Skill9Tier}@{Skill9ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 10 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill10Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill10Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill10Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill10Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill10Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill10Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill10Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill10Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill10ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill10Name} Check}} {{text=Roll: [[@{Skill10Dice}@{Skill10Tier}@{Skill10ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 11 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill11Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill11Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill11Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill11Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill11Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill11Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill11Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill11Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill11ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill11Name} Check}} {{text=Roll: [[@{Skill11Dice}@{Skill11Tier}@{Skill11ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 12 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill12Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill12Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill12Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill12Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill12Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill12Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill12Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill12Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill12ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill12Name} Check}} {{text=Roll: [[@{Skill12Dice}@{Skill12Tier}@{Skill12ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 13 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill13Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill13Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill13Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill13Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill13Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill13Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill13Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill13Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill13ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill13Name} Check}} {{text=Roll: [[@{Skill13Dice}@{Skill13Tier}@{Skill13ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 14 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill14Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill14Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill14Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill14Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill14Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill14Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill14Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill14Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill14ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill14Name} Check}} {{text=Roll: [[@{Skill14Dice}@{Skill14Tier}@{Skill14ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 15 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill15Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill15Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill15Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill15Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill15Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill15Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill15Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill15Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill15ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill15Name} Check}} {{text=Roll: [[@{Skill15Dice}@{Skill15Tier}@{Skill15ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 16 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill16Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill16Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill16Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill16Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill16Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill16Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill16Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill16Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill16ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill16Name} Check}} {{text=Roll: [[@{Skill16Dice}@{Skill16Tier}@{Skill16ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 17 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill17Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill17Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill17Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill17Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill17Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill17Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill17Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill17Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill17ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill17Name} Check}} {{text=Roll: [[@{Skill17Dice}@{Skill17Tier}@{Skill17ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 18 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill18Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill18Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill18Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill18Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill18Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill18Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill18Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill18Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill18ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill18Name} Check}} {{text=Roll: [[@{Skill18Dice}@{Skill18Tier}@{Skill18ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 19 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill19Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill19Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill19Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill19Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill19Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill19Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill19Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill19Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill19ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill19Name} Check}} {{text=Roll: [[@{Skill19Dice}@{Skill19Tier}@{Skill19ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>

                            <!-- Non-Combat Skill 20 -->
                            <tr>
                                <td class="sheet-skillname-input-cell">
                                    <input type="text" name="attr_Skill20Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill20Cost" value="1" />
                                </td>
                                <td>
                                    <select name="attr_Skill20Attribute" class="sheet-skill-attribute">
                                        <option value="-">---</option>
                                        <option value="str">Str</option>
                                        <option value="dex">Dex</option>
                                        <option value="bdy">Bod</option>
                                        <option value="prc">Per</option>
                                        <option value="int">Int</option>
                                        <option value="wil">Wil</option>
                                        <option value="chr">Chr</option>
                                        <option value="alu">Alu</option>
                                    </select>
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill20Rating" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Skill20Bonus" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input
                                        type="text"
                                        name="attr_Skill20Total"
                                        value="-"
                                        readonly
                                        class="sheet-totalfield"
                                    />
                                </td>
                                <td>
                                    <select name="attr_Skill20Tier">
                                        <option value="+0">Basic</option>
                                        <option value="+1">Expert</option>
                                        <option value="+2">Master</option>
                                    </select>
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Skill20Dice"
                                        value=""
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                    <input type="hidden" name="attr_Skill20ConditionMod" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:simple} {{character=@{character_name}}}{{name=@{Skill20Name} Check}} {{text=Roll: [[@{Skill20Dice}@{Skill20Tier}@{Skill20ConditionMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                        </table>

                        <div class="sheet-collapse-wrapper sheet-vertical-margin-moderate">
                            <h2 class="sheet-standalone-header">Additional Skills</h2>

                            <fieldset class="repeating_NonCombatSkills">
                                <table class="sheet-repeating-section">
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header">Cost</th>
                                        <th class="sheet-small-table-header">Attr</th>
                                        <th class="sheet-small-table-header">Rating</th>
                                        <th class="sheet-small-table-header">Bonus</th>
                                        <th class="sheet-small-table-header">Total</th>
                                        <th class="sheet-small-table-header">Tier</th>
                                        <th class="sheet-small-table-header">Dice</th>
                                        <th class="sheet-small-table-header">Roll</th>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname-input-cell">
                                            <input type="text" name="attr_SkillName" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SkillCost" value="1" />
                                        </td>
                                        <td>
                                            <select name="attr_SkillAttribute" class="sheet-skill-attribute">
                                                <option value="str">Str</option>
                                                <option value="dex">Dex</option>
                                                <option value="bdy">Bod</option>
                                                <option value="prc">Per</option>
                                                <option value="int">Int</option>
                                                <option value="wil">Wil</option>
                                                <option value="chr">Chr</option>
                                                <option value="alu">Alu</option>
                                            </select>
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SkillRating" value="0" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SkillBonus" value="0" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input
                                                type="text"
                                                name="attr_SkillTotal"
                                                value="-"
                                                readonly
                                                class="sheet-totalfield"
                                            />
                                        </td>
                                        <td>
                                            <select name="attr_SkillTier">
                                                <option value="+0">Basic</option>
                                                <option value="+1">Expert</option>
                                                <option value="+2">Master</option>
                                            </select>
                                        </td>
                                        <td>
                                            <input
                                                type="text"
                                                name="attr_SkillDice"
                                                value=""
                                                readonly
                                                class="sheet-dice-field"
                                            />
                                            <input type="hidden" name="attr_SkillConditionMod" value="0" />
                                        </td>
                                        <td class="sheet-button-cell">
                                            <button
                                                type="roll"
                                                value="&{template:simple} {{character=@{character_name}}}{{name=@{SkillName} Check}} {{text=Roll: [[@{SkillDice}@{SkillTier}@{SkillConditionMod}+?{Modifier|0}]]}}"
                                            ></button>
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>
            </div>
            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------  Combat Tab  ----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->
            <div class="sheet-section-combat">
                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Physical Attacks</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                <th class="sheet-small-table-header">Damage</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon1Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon1Name}}} {{roll=[[d20+@{Weapon1Hit}@{PhysMod}+@{Weapon1HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon1Name}}} {{damage=[[(@{Weapon1Dmg}+@{Weapon1DmgBonus}+@{W1DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon2Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon2Name}}} {{roll=[[d20+@{Weapon2Hit}@{PhysMod}+@{Weapon2HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon2Name}}} {{damage=[[(@{Weapon2Dmg}+@{Weapon2DmgBonus}+@{W2DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon3Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon3Name}}} {{roll=[[d20+@{Weapon3Hit}@{PhysMod}+@{Weapon3HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon3Name}}} {{damage=[[(@{Weapon3Dmg}+@{Weapon3DmgBonus}+@{W3DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon4Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon4Name}}} {{roll=[[d20+@{Weapon4Hit}@{PhysMod}+@{Weapon4HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon4Name}}} {{damage=[[(@{Weapon4Dmg}+@{Weapon4DmgBonus}+@{W4DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon5Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon5Name}}} {{roll=[[d20+@{Weapon5Hit}@{PhysMod}+@{Weapon5HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon5Name}}} {{damage=[[(@{Weapon5Dmg}+@{Weapon5DmgBonus}+@{W5DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon6Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon6Name}}} {{roll=[[d20+@{Weapon6Hit}@{PhysMod}+@{Weapon6HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon6Name}}} {{damage=[[(@{Weapon6Dmg}+@{Weapon6DmgBonus}+@{W6DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_UnarmedDisplayName" value="Unarmed: Basic" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=Unarmed}} {{roll=[[d20+@{UnarmedHit}@{PhysMod}+@{UnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=Unarmed}} {{damage=[[(@{UnarmedDmg}+@{UnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedName" value="Alternate Unarmed" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{AltUnarmedName}}} {{roll=[[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{AltUnarmedName}}} {{damage=[[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedName" value="Alternate Unarmed" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{AltUnarmedName}}} {{roll=[[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{AltUnarmedName}}} {{damage=[[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Spells</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                <th class="sheet-small-table-header">Damage</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell1Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{area=@{Spell1Area}}} {{duration=@{Spell1Dur}}} {{actions=@{Spell1Act}}} {{drain=@{Spell1Drain}}} {{roll=[[d20+@{Spell1HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{protection=@{Spell1Prot}}} {{roll=[[(@{Spell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell2Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{area=@{Spell2Area}}} {{duration=@{Spell2Dur}}} {{actions=@{Spell2Act}}} {{drain=@{Spell2Drain}}} {{roll=[[d20+@{Spell2HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{protection=@{Spell2Prot}}} {{roll=[[(@{Spell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell3Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{area=@{Spell3Area}}} {{duration=@{Spell3Dur}}} {{actions=@{Spell3Act}}} {{drain=@{Spell3Drain}}} {{roll=[[d20+@{Spell3HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{protection=@{Spell3Prot}}} {{roll=[[(@{Spell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell4Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{area=@{Spell4Area}}} {{duration=@{Spell4Dur}}} {{actions=@{Spell4Act}}} {{drain=@{Spell4Drain}}} {{roll=[[d20+@{Spell4HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{protection=@{Spell4Prot}}} {{roll=[[(@{Spell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell5Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{area=@{Spell5Area}}} {{duration=@{Spell5Dur}}} {{actions=@{Spell5Act}}} {{drain=@{Spell5Drain}}} {{roll=[[d20+@{Spell5HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{protection=@{Spell5Prot}}} {{roll=[[(@{Spell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell6Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{area=@{Spell6Area}}} {{duration=@{Spell6Dur}}} {{actions=@{Spell6Act}}} {{drain=@{Spell6Drain}}} {{roll=[[d20+@{Spell6HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{protection=@{Spell6Prot}}} {{roll=[[(@{Spell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell7Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{area=@{Spell7Area}}} {{duration=@{Spell7Dur}}} {{actions=@{Spell7Act}}} {{drain=@{Spell7Drain}}} {{roll=[[d20+@{Spell7HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{protection=@{Spell7Prot}}} {{roll=[[(@{Spell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell8Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{area=@{Spell8Area}}} {{duration=@{Spell8Dur}}} {{actions=@{Spell8Act}}} {{drain=@{Spell8Drain}}} {{roll=[[d20+@{Spell8HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{protection=@{Spell8Prot}}} {{roll=[[(@{Spell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell9Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{area=@{Spell9Area}}} {{duration=@{Spell9Dur}}} {{actions=@{Spell9Act}}} {{drain=@{Spell9Drain}}} {{roll=[[d20+@{Spell9HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{protection=@{Spell9Prot}}} {{roll=[[(@{Spell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Spell10Name" value="" readonly />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-cast} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{area=@{Spell10Area}}} {{duration=@{Spell10Dur}}} {{actions=@{Spell10Act}}} {{drain=@{Spell10Drain}}} {{roll=[[d20+@{Spell10HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:spell-effect} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{protection=@{Spell10Prot}}} {{roll=[[(@{Spell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                    ></button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="2">
                                    <h2>Actions</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Type</th>
                                <th class="sheet-small-table-header">Amt</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Unarmed</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_UnarmedActions" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Melee</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MeleeActions" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Projectile</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ProjActions" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Magic</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_MagicActions" value="0" />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Defense</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Type</th>
                                <th class="sheet-small-table-header">Bonus</th>
                                <th class="sheet-small-table-header">Roll</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Dodge</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        class="sheet-desctotalfield"
                                        name="attr_DefModTotal"
                                        value="0"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Dodge Roll}} {{roll=[[d20+@{DefModTotal}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Parry</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ParryBonus" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Parry Roll}} {{roll=[[d20+@{DefModTotal}+@{ParryBonus}-1+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Block w/ Melee</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BlockBonus" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Block Roll}} {{roll=[[d20+@{DefModTotal}+@{BlockBonus}+1+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Block w/ Shield</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShieldBlockBonus" value="0" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Shield Block Roll}} {{roll=[[d20+@{DefModTotal}+@{ShieldBlockBonus}+@{ShieldCover}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Mental Defense</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        class="sheet-desctotalfield"
                                        name="attr_MenDefTotal"
                                        value="0"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Mental Defense Roll}} {{roll=[[d20+@{MenDefTotal}+?{Modifier|0}]]}}"
                                    ></button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="3">
                                    <h2>Initiative</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Initiative</td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:roll} {{character=@{character_name}}} {{name=Initiative Roll}} {{roll=[[1d10!+@{InitModTotal}+?{Modifier|0}&{tracker}]]}}"
                                    ></button>
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="2">
                                    <h2>Soak</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Total Armor Value</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        class="sheet-desctotalfield"
                                        name="attr_TotalAR"
                                        value="0"
                                        readonly
                                    />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Toughness</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        class="sheet-desctotalfield"
                                        name="attr_ToughTotal"
                                        value="0"
                                        readonly
                                    />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Fortitude</td>
                                <td class="sheet-cell-numeric-readonly">
                                    <input
                                        type="number"
                                        class="sheet-desctotalfield"
                                        name="attr_FortTotal"
                                        value="0"
                                        readonly
                                    />
                                </td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <table>
                            <tr>
                                <th colspan="2">
                                    <h2>Resistances</h2>
                                </th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Fire</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_FireRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Cold</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ColdRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Toxic</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ToxicRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Electrical</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ElecRes" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Sonic</td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_SonicRes" value="0" />
                                </td>
                            </tr>
                        </table>
                    </div>
                </div>
            </div>
            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------  Gear Tab  -----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->

            <div class="sheet-section-gear">
                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <h1>Weapons</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Unarmed</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td class="sheet-read-only-field">
                                    <input type="text" name="attr_UnarmedDisplayName" value="Unarmed: Basic" readonly />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_UnarmedHitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_UnarmedHit"
                                        value="0"
                                        readonly
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=Unarmed}} {{roll=[[d20+@{UnarmedHit}@{PhysMod}+@{UnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Accessory</th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_UnarmedAccessory" value="" />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_UnarmedDmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td class="sheet-read-only-field">
                                    <input type="hidden" name="attr_UnarmedRank" value="0" />
                                    <input type="hidden" name="attr_RaceUnarmedRank" value="3" />
                                    <input
                                        type="text"
                                        name="attr_UnarmedDmg"
                                        value="d6!"
                                        readonly
                                        class="sheet-dice-field"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=Unarmed}} {{damage=[[(@{UnarmedDmg}+@{UnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedName" value="Alternate Unarmed" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_AltUnarmedHitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_AltUnarmedHit"
                                        value="0"
                                        readonly
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{AltUnarmedName}}} {{roll=[[d20+@{AltUnarmedHit}@{PhysMod}+@{AltUnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Accessory</th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_AltUnarmedAccessory" value="" />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_AltUnarmedDmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_AltUnarmedDmg" value="d6!" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{AltUnarmedName}}} {{damage=[[(@{AltUnarmedDmg}+@{AltUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_RacialUnarmedName" value="Racial Unarmed" readonly />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_RacialUnarmedHitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_RacialUnarmedHit"
                                        value="0"
                                        readonly
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{RacialUnarmedName}}} {{roll=[[d20+@{RacialUnarmedHit}@{PhysMod}+@{RacialUnarmedHitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Accessory</th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_RacialUnarmedAccessory" value="" />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_RacialUnarmedDmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_RacialUnarmedDmg"
                                        value="d6!"
                                        class="sheet-dice-field"
                                        readonly
                                    />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{RacialUnarmedName}}} {{damage=[[(@{RacialUnarmedDmg}+@{RacialUnarmedDmgBonus}+@{DmgModTotal}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                        </table>

                        <!--WEAPONS-->
                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Primary Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon1Name" value="" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_Weapon1HitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon1Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon1Name}}} {{roll=[[d20+@{Weapon1Hit}@{PhysMod}+@{Weapon1HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Weapon1DmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon1Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon1Name}}} {{damage=[[(@{Weapon1Dmg}+@{Weapon1DmgBonus}+@{W1DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon1Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td>
                                    <select name="attr_W1Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W1DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon1Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon1Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon1Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Secondary Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon2Name" value="" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_Weapon2HitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon2Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon2Name}}} {{roll=[[d20+@{Weapon2Hit}@{PhysMod}+@{Weapon2HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Weapon2DmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon2Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon2Name}}} {{damage=[[(@{Weapon2Dmg}+@{Weapon2DmgBonus}+@{W2DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon2Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td>
                                    <select name="attr_W2Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W2DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon2Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon2Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon2Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Third Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon3Name" value="" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_Weapon3HitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon3Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon3Name}}} {{roll=[[d20+@{Weapon3Hit}@{PhysMod}+@{Weapon3HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Weapon3DmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon3Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon3Name}}} {{damage=[[(@{Weapon3Dmg}+@{Weapon3DmgBonus}+@{W3DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon3Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td>
                                    <select name="attr_W3Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W3DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon3Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon3Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon3Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Fourth Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon4Name" value="" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_Weapon4HitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon4Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon4Name}}} {{roll=[[d20+@{Weapon4Hit}@{PhysMod}+@{Weapon4HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Weapon4DmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon4Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon4Name}}} {{damage=[[(@{Weapon4Dmg}+@{Weapon4DmgBonus}+@{W4DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon4Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td>
                                    <select name="attr_W4Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W4DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon4Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon4Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon4Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Fifth Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon5Name" value="" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_Weapon5HitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon5Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon5Name}}} {{roll=[[d20+@{Weapon5Hit}@{PhysMod}+@{Weapon5HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Weapon5DmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon5Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon5Name}}} {{damage=[[(@{Weapon5Dmg}+@{Weapon5DmgBonus}+@{W5DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon5Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td>
                                    <select name="attr_W5Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W5DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon5Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon5Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon5Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Sixth Weapon</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Hit Bonus</th>
                                <th class="sheet-small-table-header">Specialization</th>
                                <th class="sheet-small-table-header">Hit</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Weapon6Name" value="" />
                                </td>
                                <td>
                                    <input
                                        type="number"
                                        name="attr_Weapon6HitBonus"
                                        value="0"
                                        class="sheet-numeric-wide"
                                    />
                                </td>
                                <td>
                                    <input type="number" name="attr_Weapon6Hit" value="0" class="sheet-numeric-wide" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:attack} {{character=@{character_name}}} {{attackType=@{Weapon6Name}}} {{roll=[[d20+@{Weapon6Hit}@{PhysMod}+@{Weapon6HitBonus}+?{Modifier|0}]]}} {{actions=?{Actions|1}}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header"></th>
                                <th class="sheet-small-table-header">Bonus Dmg</th>
                                <th class="sheet-small-table-header">Damage</th>
                                <th class="sheet-small-table-header">Dmg</th>
                            </tr>
                            <tr>
                                <th>Damage:</th>
                                <td>
                                    <input
                                        type="text"
                                        name="attr_Weapon6DmgBonus"
                                        value="0"
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td>
                                    <input type="text" name="attr_Weapon6Dmg" value="0" class="sheet-dice-field" />
                                </td>
                                <td class="sheet-button-cell">
                                    <button
                                        type="roll"
                                        value="&{template:damage} {{character=@{character_name}}} {{damageType=@{Weapon6Name}}} {{damage=[[(@{Weapon6Dmg}+@{Weapon6DmgBonus}+@{W6DmgMod}+?{Modifier|0})*?{Multiplier|1}]]}}"
                                    ></button>
                                </td>
                            </tr>
                            <tr>
                                <th>Accessory:</th>
                                <td colspan="2">
                                    <input type="text" name="attr_Weapon6Acc" value="" />
                                </td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Type:</th>
                                <td>
                                    <select name="attr_W6Type">
                                        <option value="m">Melee</option>
                                        <option value="r">Shooting</option>
                                        <option value="o">Other</option>
                                    </select>
                                </td>
                                <td><input type="hidden" name="attr_W6DmgMod" value="0" /></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Durability:</th>
                                <td>
                                    <input type="text" name="attr_Weapon6Dur" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Weight:</th>
                                <td>
                                    <input type="text" name="attr_Weapon6Wgt" value="" class="sheet-text-centred" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                            <tr>
                                <th>Ammo:</th>
                                <td>
                                    <input type="number" name="attr_Weapon6Ammo" value="" class="sheet-numeric-wide" />
                                </td>
                                <td></td>
                                <td></td>
                            </tr>
                        </table>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Armor</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Shield</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Slot</th>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Weight</th>
                                <th class="sheet-small-table-header">SHP</th>
                                <th class="sheet-small-table-header">Cover</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Shield</td>
                                <td>
                                    <input type="text" name="attr_ShieldName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_ShieldWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShieldDur" value="0" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ShieldCover" value="0" />
                                </td>
                            </tr>
                        </table>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="4">
                                    <h2>Armor</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Slot</th>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Weight</th>
                                <th class="sheet-small-table-header">Durability</th>
                                <th class="sheet-small-table-header">Armor Rating</th>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Helmet</td>
                                <td>
                                    <input type="text" name="attr_HelmetName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_HelmetWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_HelmetDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_HelmetAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Amulet</td>
                                <td>
                                    <input type="text" name="attr_AmuletName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_AmuletWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_AmuletDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_AmuletAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Cloak</td>
                                <td>
                                    <input type="text" name="attr_CloakName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_CloakWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_CloakDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_CloakAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Pauldrons</td>
                                <td>
                                    <input type="text" name="attr_PauldronsName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input
                                        type="text"
                                        name="attr_PauldronsWeight"
                                        value=""
                                        class="sheet-text-centred"
                                    />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_PauldronsDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_PauldronsAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Clothing</td>
                                <td>
                                    <input type="text" name="attr_ClothingName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_ClothingWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_ClothingDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_ClothingAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Torso</td>
                                <td>
                                    <input type="text" name="attr_TorsoName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_TorsoWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_TorsoDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_TorsoAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Bracers</td>
                                <td>
                                    <input type="text" name="attr_BracersName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_BracersWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_BracersDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BracersAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Gloves</td>
                                <td>
                                    <input type="text" name="attr_GlovesName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_GlovesWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_GlovesDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_GlovesAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Belt</td>
                                <td>
                                    <input type="text" name="attr_BeltName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_BeltWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_BeltDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BeltAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Greaves</td>
                                <td>
                                    <input type="text" name="attr_GreavesName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_GreavesWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_GreavesDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_GreavesAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Boots</td>
                                <td>
                                    <input type="text" name="attr_BootsName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_BootsWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_BootsDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_BootsAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Ring</td>
                                <td>
                                    <input type="text" name="attr_RingName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_RingWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_RingDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_RingAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Ring</td>
                                <td>
                                    <input type="text" name="attr_Ring2Name" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_Ring2Weight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Ring2Dur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Ring2AR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Other</td>
                                <td>
                                    <input type="text" name="attr_OtherName" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_OtherWeight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_OtherDur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_OtherAR" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td class="sheet-skillname">Other</td>
                                <td>
                                    <input type="text" name="attr_Other2Name" value="" />
                                </td>
                                <td class="sheet-cell-centred">
                                    <input type="text" name="attr_Other2Weight" value="" class="sheet-text-centred" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="text" name="attr_Other2Dur" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Other2AR" value="0" />
                                </td>
                            </tr>
                        </table>

                        <h1 class="sheet-spacer-top-margin">Valuables</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="3">
                                    <h2>Money</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Type</th>
                                <th class="sheet-small-table-header">Amount</th>
                                <th class="sheet-small-table-header">Worth</th>
                            </tr>
                            <tr>
                                <th>Mertacullum (m)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Mertacullum" value="0" />
                                </td>
                                <td class="sheet-text-centred">1m = 20g</td>
                            </tr>
                            <tr>
                                <th>Valcrium (v)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Mertacullum" value="0" />
                                </td>
                                <td class="sheet-text-centred">1v = 12g</td>
                            </tr>
                            <tr>
                                <th>Gold (g)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Gold" value="0" />
                                </td>
                                <td class="sheet-text-centred">1g = 4s</td>
                            </tr>
                            <tr>
                                <th>Silver (s)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Silver" value="0" />
                                </td>
                                <td class="sheet-text-centred">1s = 5c</td>
                            </tr>
                            <tr>
                                <th>Copper (c)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Copper" value="0" />
                                </td>
                                <td class="sheet-text-centred">1c = 5b</td>
                            </tr>
                            <tr>
                                <th>Bones (b or p)</th>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Bones" value="0" />
                                </td>
                                <td></td>
                            </tr>
                        </table>

                        <textarea
                            name="attr_MiscMoney"
                            placeholder="Other (e.g. gems)"
                            class="sheet-textarea-gems"
                        ></textarea>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Equipment</h1>

                        <table class="sheet-spacer-top-margin">
                            <tr>
                                <th colspan="2">
                                    <h2>Equipment (Belt)</h2>
                                </th>
                            </tr>
                            <tr>
                                <th class="sheet-small-table-header">Name</th>
                                <th class="sheet-small-table-header">Amount</th>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt1Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt1Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt2Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt2Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt3Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt3Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt4Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt4Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt5Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt5Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt6Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt6Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt7Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt7Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt8Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt8Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt9Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt9Amt" value="0" />
                                </td>
                            </tr>
                            <tr>
                                <td>
                                    <input type="text" name="attr_Belt10Name" value="" />
                                </td>
                                <td class="sheet-cell-numeric">
                                    <input type="number" name="attr_Belt10Amt" value="0" />
                                </td>
                            </tr>
                        </table>

                        <h2 class="sheet-spacer-top-margin">Equipment (Backpack)</h2>

                        <fieldset class="repeating_equip">
                            <table class="sheet-repeating-section">
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header">Amount</th>
                                    <th class="sheet-small-table-header">Weight</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_EquipName" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_EquipAmt" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric-readonly">
                                        <input type="text" name="attr_EquipWgt" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header" colspan="3">Notes</th>
                                </tr>
                                <tr>
                                    <td colspan="3">
                                        <input type="text" name="attr_EquipNotes" value="" />
                                    </td>
                                </tr>
                            </table>
                        </fieldset>

                        <textarea
                            name="attr_MiscEquipment"
                            placeholder="Other (e.g. stored)"
                            class="sheet-textarea-equipment"
                        ></textarea>

                        <h2 class="sheet-spacer-top-margin">Transportation</h2>

                        <fieldset class="repeating_trans">
                            <table class="sheet-repeating-section">
                                <tr>
                                    <th class="sheet-small-table-header">Type</th>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header">Speed</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_TransType" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_TransName" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_TransSpd" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header" colspan="3">Accessories</th>
                                </tr>
                                <tr>
                                    <td valign="center" colspan="3">
                                        <textarea class="sheet-text-area-full" name="attr_TransAcc" value=""></textarea>
                                    </td>
                                </tr>
                            </table>
                        </fieldset>

                        <h1 class="sheet-spacer-top-margin">Other</h1>

                        <h2 class="sheet-spacer-top-margin">Hideouts</h2>

                        <fieldset class="repeating_hideouts">
                            <table class="sheet-repeating-section">
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header">Income</th>
                                    <th class="sheet-small-table-header">Upkeep</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_HideoutName" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_HideoutIncome" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_HideoutUpkeep" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header" colspan="3">Notes</th>
                                </tr>
                                <tr>
                                    <td valign="center" colspan="3">
                                        <textarea
                                            class="sheet-text-area-full"
                                            name="attr_HideoutNotes"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                            </table>
                        </fieldset>
                    </div>
                </div>
            </div>
            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------  Mystic Tab  ----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->

            <div class="sheet-section-mystic">
                <h1 class="sheet-spacer-top-margin">Religion</h1>

                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <div class="sheet-religion-table">
                            <h2>Details</h2>

                            <table>
                                <tr>
                                    <td class="sheet-skillname">Soul Points</td>
                                    <td>
                                        <input
                                            type="number"
                                            name="attr_SoulPoints"
                                            value="0"
                                            class="sheet-numeric-wide"
                                        />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Path</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_ReligionPath" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname" rowspan="3">Gods</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_Gods1" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_Gods2" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_Gods3" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Spirit Animal</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_SpiritAnimal" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Astrological Sign</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_AstSign" value="" />
                                    </td>
                                </tr>
                                <tr>
                                    <td class="sheet-skillname">Fate Power</td>
                                    <td class="sheet-cell-numeric">
                                        <input type="text" name="attr_FatePower" value="" />
                                    </td>
                                </tr>
                            </table>
                        </div>
                    </div>

                    <div class="sheet-column-grow">
                        <h2 class="sheet-spiritual-influence-header">Spiritual Influence</h2>

                        <div class="sheet-centred-section">
                            <div class="sheet-spiritual-influence-image">
                                <input type="hidden" name="attr_ClassSI" value="2" />
                                <input
                                    type="number"
                                    class="sheet-spiritual-influence"
                                    name="attr_SpiritInf"
                                    value="2"
                                />
                            </div>

                            <button
                                type="roll"
                                value="&{template:percentile} {{character=@{character_name}}} [[ [[1d100 + ?{Modifier|0}]] - @{SpiritInf}]] ]] {{name=Spiritual Influence Check}} {{roll=$[[0]]}} {{target=@{SpiritInf}}} {{difference=$[[1]]}}"
                            >
                                Roll Spiritual Influence
                            </button>
                        </div>
                    </div>
                </div>

                <h1 class="sheet-spacer-top-margin">Spells</h1>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Attack Spells</h2>
                    <div class="sheet-collapse-section">
                        <input
                            type="checkbox"
                            name="attr_AttackSpellsExpanded"
                            checked="true"
                            class="sheet-expand-collapse-checkbox"
                        />
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <table>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell1Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell1Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell1Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell1Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell1Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell1Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell1Name}}} {{area=@{Spell1Area}}} {{duration=@{Spell1Dur}}} {{protection=@{Spell1Prot}}} {{actions=@{Spell1Act}}} {{drain=@{Spell1Drain}}} {{description=@{Spell1Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell1Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell1HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{area=@{Spell1Area}}} {{duration=@{Spell1Dur}}} {{actions=@{Spell1Act}}} {{drain=@{Spell1Drain}}} {{roll=[[d20+@{Spell1HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell1Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell1Name}}} {{character=@{character_name}}} {{protection=@{Spell1Prot}}} {{roll=[[(@{Spell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell2Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell2Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell2Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell2Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell2Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell2Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell2Name}}} {{area=@{Spell2Area}}} {{duration=@{Spell2Dur}}} {{protection=@{Spell2Prot}}} {{actions=@{Spell2Act}}} {{drain=@{Spell2Drain}}} {{description=@{Spell2Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell2Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell2HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{area=@{Spell2Area}}} {{duration=@{Spell2Dur}}} {{actions=@{Spell2Act}}} {{drain=@{Spell2Drain}}} {{roll=[[d20+@{Spell2HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell2Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell2Name}}} {{character=@{character_name}}} {{protection=@{Spell2Prot}}} {{roll=[[(@{Spell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell3Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell3Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell3Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell3Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell3Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell3Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell3Name}}} {{area=@{Spell3Area}}} {{duration=@{Spell3Dur}}} {{protection=@{Spell3Prot}}} {{actions=@{Spell3Act}}} {{drain=@{Spell3Drain}}} {{description=@{Spell3Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell3Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell3HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{area=@{Spell3Area}}} {{duration=@{Spell3Dur}}} {{actions=@{Spell3Act}}} {{drain=@{Spell3Drain}}} {{roll=[[d20+@{Spell3HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell3Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell3Name}}} {{character=@{character_name}}} {{protection=@{Spell3Prot}}} {{roll=[[(@{Spell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell4Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell4Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell4Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell4Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell4Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell4Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell4Name}}} {{area=@{Spell4Area}}} {{duration=@{Spell4Dur}}} {{protection=@{Spell4Prot}}} {{actions=@{Spell4Act}}} {{drain=@{Spell4Drain}}} {{description=@{Spell4Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell4Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell4HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{area=@{Spell4Area}}} {{duration=@{Spell4Dur}}} {{actions=@{Spell4Act}}} {{drain=@{Spell4Drain}}} {{roll=[[d20+@{Spell4HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell4Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell4Name}}} {{character=@{character_name}}} {{protection=@{Spell4Prot}}} {{roll=[[(@{Spell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell5Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell5Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell5Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell5Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell5Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell5Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell5Name}}} {{area=@{Spell5Area}}} {{duration=@{Spell5Dur}}} {{protection=@{Spell5Prot}}} {{actions=@{Spell5Act}}} {{drain=@{Spell5Drain}}} {{description=@{Spell5Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell5Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell5HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{area=@{Spell5Area}}} {{duration=@{Spell5Dur}}} {{actions=@{Spell5Act}}} {{drain=@{Spell5Drain}}} {{roll=[[d20+@{Spell5HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell5Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell5Name}}} {{character=@{character_name}}} {{protection=@{Spell5Prot}}} {{roll=[[(@{Spell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell6Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell6Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell6Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell6Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell6Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell6Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell6Name}}} {{area=@{Spell6Area}}} {{duration=@{Spell6Dur}}} {{protection=@{Spell6Prot}}} {{actions=@{Spell6Act}}} {{drain=@{Spell6Drain}}} {{description=@{Spell6Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell6Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell6HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{area=@{Spell6Area}}} {{duration=@{Spell6Dur}}} {{actions=@{Spell6Act}}} {{drain=@{Spell6Drain}}} {{roll=[[d20+@{Spell6HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell6Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell6Name}}} {{character=@{character_name}}} {{protection=@{Spell6Prot}}} {{roll=[[(@{Spell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell7Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell7Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell7Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell7Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell7Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell7Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell7Name}}} {{area=@{Spell7Area}}} {{duration=@{Spell7Dur}}} {{protection=@{Spell7Prot}}} {{actions=@{Spell7Act}}} {{drain=@{Spell7Drain}}} {{description=@{Spell7Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell7Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell7HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{area=@{Spell7Area}}} {{duration=@{Spell7Dur}}} {{actions=@{Spell7Act}}} {{drain=@{Spell7Drain}}} {{roll=[[d20+@{Spell7HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell7Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell7Name}}} {{character=@{character_name}}} {{protection=@{Spell7Prot}}} {{roll=[[(@{Spell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell8Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell8Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell8Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell8Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell8Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell8Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell8Name}}} {{area=@{Spell8Area}}} {{duration=@{Spell8Dur}}} {{protection=@{Spell8Prot}}} {{actions=@{Spell8Act}}} {{drain=@{Spell8Drain}}} {{description=@{Spell8Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell8Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell8HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{area=@{Spell8Area}}} {{duration=@{Spell8Dur}}} {{actions=@{Spell8Act}}} {{drain=@{Spell8Drain}}} {{roll=[[d20+@{Spell8HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell8Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell8Name}}} {{character=@{character_name}}} {{protection=@{Spell8Prot}}} {{roll=[[(@{Spell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell9Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell9Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell9Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell9Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell9Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell9Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell9Name}}} {{area=@{Spell9Area}}} {{duration=@{Spell9Dur}}} {{protection=@{Spell9Prot}}} {{actions=@{Spell9Act}}} {{drain=@{Spell9Drain}}} {{description=@{Spell9Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell9Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell9HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{area=@{Spell9Area}}} {{duration=@{Spell9Dur}}} {{actions=@{Spell9Act}}} {{drain=@{Spell9Drain}}} {{roll=[[d20+@{Spell9HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell9Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell9Name}}} {{character=@{character_name}}} {{protection=@{Spell9Prot}}} {{roll=[[(@{Spell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_Spell10Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell10Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_Spell10Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell10Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell10Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_Spell10Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{Spell10Name}}} {{area=@{Spell10Area}}} {{duration=@{Spell10Dur}}} {{protection=@{Spell10Prot}}} {{actions=@{Spell10Act}}} {{drain=@{Spell10Drain}}} {{description=@{Spell10Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell10Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_Spell10HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{area=@{Spell10Area}}} {{duration=@{Spell10Dur}}} {{actions=@{Spell10Act}}} {{drain=@{Spell10Drain}}} {{roll=[[d20+@{Spell10HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_Spell10Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{Spell10Name}}} {{character=@{character_name}}} {{protection=@{Spell10Prot}}} {{roll=[[(@{Spell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                            </table>
                        </div>
                    </div>
                </div>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Non-Combat Spells</h2>
                    <div class="sheet-collapse-section">
                        <input
                            type="checkbox"
                            name="attr_NonCombatSpellsExpanded"
                            checked="true"
                            class="sheet-expand-collapse-checkbox"
                        />
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <table>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell1Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell1Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell1Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell1Name}}} {{area=@{NCSpell1Area}}} {{duration=@{NCSpell1Dur}}} {{protection=@{NCSpell1Prot}}} {{actions=@{NCSpell1Act}}} {{drain=@{NCSpell1Drain}}} {{description=@{NCSpell1Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell1Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell1HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell1Name}}} {{character=@{character_name}}} {{area=@{NCSpell1Area}}} {{duration=@{NCSpell1Dur}}} {{actions=@{NCSpell1Act}}} {{drain=@{NCSpell1Drain}}} {{roll=[[d20+@{NCSpell1HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell1Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell1Name}}} {{character=@{character_name}}} {{protection=@{NCSpell1Prot}}} {{roll=[[(@{NCSpell1Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell2Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell2Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell2Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell2Name}}} {{area=@{NCSpell2Area}}} {{duration=@{NCSpell2Dur}}} {{protection=@{NCSpell2Prot}}} {{actions=@{NCSpell2Act}}} {{drain=@{NCSpell2Drain}}} {{description=@{NCSpell2Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell2Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell2HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell2Name}}} {{character=@{character_name}}} {{area=@{NCSpell2Area}}} {{duration=@{NCSpell2Dur}}} {{actions=@{NCSpell2Act}}} {{drain=@{NCSpell2Drain}}} {{roll=[[d20+@{NCSpell2HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell2Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell2Name}}} {{character=@{character_name}}} {{protection=@{NCSpell2Prot}}} {{roll=[[(@{NCSpell2Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell3Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell3Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell3Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell3Name}}} {{area=@{NCSpell3Area}}} {{duration=@{NCSpell3Dur}}} {{protection=@{NCSpell3Prot}}} {{actions=@{NCSpell3Act}}} {{drain=@{NCSpell3Drain}}} {{description=@{NCSpell3Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell3Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell3HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell3Name}}} {{character=@{character_name}}} {{area=@{NCSpell3Area}}} {{duration=@{NCSpell3Dur}}} {{actions=@{NCSpell3Act}}} {{drain=@{NCSpell3Drain}}} {{roll=[[d20+@{NCSpell3HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell3Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell3Name}}} {{character=@{character_name}}} {{protection=@{NCSpell3Prot}}} {{roll=[[(@{NCSpell3Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell4Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell4Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell4Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell4Name}}} {{area=@{NCSpell4Area}}} {{duration=@{NCSpell4Dur}}} {{protection=@{NCSpell4Prot}}} {{actions=@{NCSpell4Act}}} {{drain=@{NCSpell4Drain}}} {{description=@{NCSpell4Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell4Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell4HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell4Name}}} {{character=@{character_name}}} {{area=@{NCSpell4Area}}} {{duration=@{NCSpell4Dur}}} {{actions=@{NCSpell4Act}}} {{drain=@{NCSpell4Drain}}} {{roll=[[d20+@{NCSpell4HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell4Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell4Name}}} {{character=@{character_name}}} {{protection=@{NCSpell4Prot}}} {{roll=[[(@{NCSpell4Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell5Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell5Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell5Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell5Name}}} {{area=@{NCSpell5Area}}} {{duration=@{NCSpell5Dur}}} {{protection=@{NCSpell5Prot}}} {{actions=@{NCSpell5Act}}} {{drain=@{NCSpell5Drain}}} {{description=@{NCSpell5Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell5Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell5HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell5Name}}} {{character=@{character_name}}} {{area=@{NCSpell5Area}}} {{duration=@{NCSpell5Dur}}} {{actions=@{NCSpell5Act}}} {{drain=@{NCSpell5Drain}}} {{roll=[[d20+@{NCSpell5HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell5Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell5Name}}} {{character=@{character_name}}} {{protection=@{NCSpell5Prot}}} {{roll=[[(@{NCSpell5Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell6Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell6Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell6Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell6Name}}} {{area=@{NCSpell6Area}}} {{duration=@{NCSpell6Dur}}} {{protection=@{NCSpell6Prot}}} {{actions=@{NCSpell6Act}}} {{drain=@{NCSpell6Drain}}} {{description=@{NCSpell6Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell6Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell6HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell6Name}}} {{character=@{character_name}}} {{area=@{NCSpell6Area}}} {{duration=@{NCSpell6Dur}}} {{actions=@{NCSpell6Act}}} {{drain=@{NCSpell6Drain}}} {{roll=[[d20+@{NCSpell6HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell6Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell6Name}}} {{character=@{character_name}}} {{protection=@{NCSpell6Prot}}} {{roll=[[(@{NCSpell6Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell7Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell7Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell7Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell7Name}}} {{area=@{NCSpell7Area}}} {{duration=@{NCSpell7Dur}}} {{protection=@{NCSpell7Prot}}} {{actions=@{NCSpell7Act}}} {{drain=@{NCSpell7Drain}}} {{description=@{NCSpell7Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell7Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell7HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell7Name}}} {{character=@{character_name}}} {{area=@{NCSpell7Area}}} {{duration=@{NCSpell7Dur}}} {{actions=@{NCSpell7Act}}} {{drain=@{NCSpell7Drain}}} {{roll=[[d20+@{NCSpell7HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell7Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell7Name}}} {{character=@{character_name}}} {{protection=@{NCSpell7Prot}}} {{roll=[[(@{NCSpell7Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell8Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell8Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell8Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell8Name}}} {{area=@{NCSpell8Area}}} {{duration=@{NCSpell8Dur}}} {{protection=@{NCSpell8Prot}}} {{actions=@{NCSpell8Act}}} {{drain=@{NCSpell8Drain}}} {{description=@{NCSpell8Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell8Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell8HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell8Name}}} {{character=@{character_name}}} {{area=@{NCSpell8Area}}} {{duration=@{NCSpell8Dur}}} {{actions=@{NCSpell8Act}}} {{drain=@{NCSpell8Drain}}} {{roll=[[d20+@{NCSpell8HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell8Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell8Name}}} {{character=@{character_name}}} {{protection=@{NCSpell8Prot}}} {{roll=[[(@{NCSpell8Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell9Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell9Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell9Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell9Name}}} {{area=@{NCSpell9Area}}} {{duration=@{NCSpell9Dur}}} {{protection=@{NCSpell9Prot}}} {{actions=@{NCSpell9Act}}} {{drain=@{NCSpell9Drain}}} {{description=@{NCSpell9Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell9Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell9HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell9Name}}} {{character=@{character_name}}} {{area=@{NCSpell9Area}}} {{duration=@{NCSpell9Dur}}} {{actions=@{NCSpell9Act}}} {{drain=@{NCSpell9Drain}}} {{roll=[[d20+@{NCSpell9HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell9Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell9Name}}} {{character=@{character_name}}} {{protection=@{NCSpell9Prot}}} {{roll=[[(@{NCSpell9Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                                <tr class="sheet-spell-spacer-row">
                                    <td colspan="7"></td>
                                </tr>
                                <tr>
                                    <th class="sheet-small-table-header">Name</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                    <th class="sheet-small-table-header" colspan="2">Duration</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                    <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                    <th class="sheet-small-table-header">Description</th>
                                </tr>
                                <tr>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Name" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Area" value="" />
                                    </td>
                                    <td colspan="2">
                                        <input type="text" name="attr_NCSpell10Dur" value="" />
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Prot" value="" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell10Act" value="0" />
                                    </td>
                                    <td rowspan="4">
                                        <textarea
                                            class="sheet-spell-description"
                                            name="attr_NCSpell10Desc"
                                            value=""
                                        ></textarea>
                                    </td>
                                </tr>
                                <tr>
                                    <td rowspan="3" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button"
                                            value="&{template:spell-description} {{name=@{NCSpell10Name}}} {{area=@{NCSpell10Area}}} {{duration=@{NCSpell10Dur}}} {{protection=@{NCSpell10Prot}}} {{actions=@{NCSpell10Act}}} {{drain=@{NCSpell10Drain}}} {{description=@{NCSpell10Desc}}}"
                                        >
                                            Display Info
                                        </button>
                                    </td>
                                    <th class="sheet-small-table-header">Drain</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                    <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                    <th class="sheet-small-table-header">Effect</th>
                                    <th class="sheet-small-table-header">Roll</th>
                                </tr>
                                <tr>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell10Drain" value="0" />
                                    </td>
                                    <td class="sheet-cell-numeric">
                                        <input type="number" name="attr_NCSpell10HitMod" value="0" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-cast} {{name=@{NCSpell10Name}}} {{character=@{character_name}}} {{area=@{NCSpell10Area}}} {{duration=@{NCSpell10Dur}}} {{actions=@{NCSpell10Act}}} {{drain=@{NCSpell10Drain}}} {{roll=[[d20+@{NCSpell10HitMod}@{MenMod}+?{Modifier|0}]]}}"
                                        ></button>
                                    </td>
                                    <td>
                                        <input type="text" name="attr_NCSpell10Dmg" value="" />
                                    </td>
                                    <td rowspan="2" class="sheet-button-cell">
                                        <button
                                            type="roll"
                                            value="&{template:spell-effect} {{name=@{NCSpell10Name}}} {{character=@{character_name}}} {{protection=@{NCSpell10Prot}}} {{roll=[[(@{NCSpell10Dmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                        ></button>
                                    </td>
                                </tr>
                                <tr class="sheet-spell-padding-row"></tr>
                            </table>
                        </div>
                    </div>
                </div>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Additional Spells</h2>
                    <div class="sheet-collapse-section">
                        <input
                            type="checkbox"
                            name="attr_AdditionalSpellsExpanded"
                            checked="true"
                            class="sheet-expand-collapse-checkbox"
                        />
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <fieldset class="repeating_spells">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header sheet-cell-moderate-width">Area</th>
                                        <th class="sheet-small-table-header" colspan="2">Duration</th>
                                        <th class="sheet-small-table-header sheet-cell-moderate-width">Protection</th>
                                        <th class="sheet-small-table-header sheet-cell-moderate-width">Actions</th>
                                        <th class="sheet-small-table-header">Description</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_SpellName" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SpellArea" value="" />
                                        </td>
                                        <td colspan="2">
                                            <input type="text" name="attr_SpellDur" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SpellProt" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SpellAct" value="0" />
                                        </td>
                                        <td rowspan="4">
                                            <textarea
                                                class="sheet-spell-description"
                                                name="attr_SpellDesc"
                                                value=""
                                            ></textarea>
                                        </td>
                                    </tr>
                                    <tr>
                                        <td rowspan="3" class="sheet-button-cell">
                                            <button
                                                type="roll"
                                                class="sheet-display-text-button"
                                                value="&{template:spell-description} {{name=@{SpellName}}} {{area=@{SpellArea}}} {{duration=@{SpellDur}}} {{protection=@{SpellProt}}} {{actions=@{SpellAct}}} {{drain=@{SpellDrain}}} {{description=@{SpellDesc}}}"
                                            >
                                                Display Info
                                            </button>
                                        </td>
                                        <th class="sheet-small-table-header">Drain</th>
                                        <th class="sheet-small-table-header sheet-cell-narrow">+ To Hit</th>
                                        <th class="sheet-small-table-header sheet-cell-narrow">Attack</th>
                                        <th class="sheet-small-table-header">Effect</th>
                                        <th class="sheet-small-table-header">Roll</th>
                                    </tr>
                                    <tr>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SpellDrain" value="0" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_SpellHitMod" value="0" />
                                        </td>
                                        <td rowspan="2" class="sheet-button-cell">
                                            <button
                                                type="roll"
                                                value="&{template:spell-cast} {{name=@{SpellName}}} {{character=@{character_name}}} {{area=@{SpellArea}}} {{duration=@{SpellDur}}} {{actions=@{SpellAct}}} {{drain=@{SpellDrain}}} {{roll=[[d20+@{SpellHitMod}@{MenMod}+?{Modifier|0}]]}}"
                                            ></button>
                                        </td>
                                        <td>
                                            <input type="text" name="attr_SpellDmg" value="" />
                                        </td>
                                        <td rowspan="2" class="sheet-button-cell">
                                            <button
                                                type="roll"
                                                value="&{template:spell-effect} {{name=@{SpellName}}} {{character=@{character_name}}} {{protection=@{SpellProt}}} {{roll=[[(@{SpellDmg}+@{SpEffTotal}+?{Modifier|0})*?{Multiplier}]]}}"
                                            ></button>
                                        </td>
                                    </tr>
                                    <tr class="sheet-spell-padding-row"></tr>
                                    <tr class="sheet-spell-spacer-row">
                                        <td colspan="7"></td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>

                <h1 class="sheet-spacer-top-margin">Chi Abilities</h1>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Abilities</h2>
                    <div class="sheet-collapse-section">
                        <input
                            type="checkbox"
                            name="attr_ChiAbilitiesExpanded"
                            checked="true"
                            class="sheet-expand-collapse-checkbox"
                        />
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <fieldset class="repeating_chiabilities">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header">Rating</th>
                                        <th class="sheet-small-table-header">Drain</th>
                                        <th class="sheet-small-table-header">Description</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_ChiAbilityName" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_ChiAbilityRating" value="1" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_ChiAbilityDrain" value="" />
                                        </td>
                                        <td rowspan="3">
                                            <textarea
                                                class="sheet-chi-ability-description"
                                                name="attr_ChiAbilityDesc"
                                                value=""
                                            ></textarea>
                                        </td>
                                    </tr>
                                    <tr class="sheet-spell-padding-row"></tr>
                                    <tr class="sheet-spell-padding-row"></tr>
                                    <tr class="sheet-spell-spacer-row">
                                        <td colspan="4"></td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>

                <h1 class="sheet-spacer-top-margin">Alchemical Formulae</h1>

                <div class="sheet-collapse-wrapper">
                    <h2 class="sheet-table-header-collapse">Formulae</h2>
                    <div class="sheet-collapse-section">
                        <input
                            type="checkbox"
                            name="attr_AlchemicalFormulaeExpanded"
                            checked="true"
                            class="sheet-expand-collapse-checkbox"
                        />
                        <span class="sheet-expand-collapse-symbol"></span>
                        <div class="sheet-collapsible">
                            <fieldset class="repeating_alchemical">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Item</th>
                                        <th class="sheet-small-table-header">Ingredients Necessary</th>
                                        <th class="sheet-small-table-header">Units Harvested</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_FormulaName" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_FormulaIngr" value="" />
                                        </td>
                                        <td>
                                            <input type="text" name="attr_FormulaHarv" value="" />
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>
            </div>

            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------  Abilities Tab  --------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->

            <div class="sheet-section-abilities">
                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <h1>Traits</h1>

                        <fieldset class="repeating_traits">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input
                                            type="text"
                                            name="attr_TraitName"
                                            value=""
                                            class="sheet-tall-control"
                                            placeholder="Name of trait"
                                        />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button-small"
                                            value="&{template:text} {{character=@{character_name}}} {{title=@{TraitName}}} {{text=@{TraitDesc}}}"
                                        >
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input
                                        type="checkbox"
                                        name="attr_TraitExpanded"
                                        checked="true"
                                        class="sheet-expand-collapse-checkbox"
                                    />
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea
                                        class="sheet-text-area-full sheet-collapsible"
                                        name="attr_TraitDesc"
                                        value=""
                                        placeholder="Description of trait"
                                    ></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Racial Abilities</h1>

                        <div class="sheet-repeating-section">
                            <div class="sheet-flex-form-container">
                                <div class="sheet-flex-form-grow">
                                    <div class="sheet-input-wide sheet-tall-control sheet-input-like">Vision</div>
                                </div>
                                <div class="sheet-flex-form-fixed sheet-tall-control">
                                    <button
                                        type="roll"
                                        class="sheet-display-text-button-small"
                                        value="&{template:text} {{character=@{character_name}}} {{title=Vision}} {{text=@{Vision}}}"
                                    >
                                        Display in Chat
                                    </button>
                                </div>
                            </div>
                            <div>
                                <input
                                    type="checkbox"
                                    name="attr_VisionExpanded"
                                    checked="true"
                                    class="sheet-expand-collapse-checkbox"
                                />
                                <span class="sheet-expand-collapse-symbol"></span>
                                <textarea
                                    class="sheet-text-area-full sheet-collapsible"
                                    name="attr_Vision"
                                    value=""
                                    placeholder="Description of type of vision"
                                ></textarea>
                            </div>
                        </div>

                        <fieldset class="repeating_raceabilities">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input
                                            type="text"
                                            name="attr_RaceAbilName"
                                            value=""
                                            class="sheet-tall-control"
                                            placeholder="Name of racial ability"
                                        />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button-small"
                                            value="&{template:text} {{character=@{character_name}}} {{title=@{RaceAbilName}}} {{text=@{RaceAbilDesc}}}"
                                        >
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input
                                        type="checkbox"
                                        name="attr_RaceAbilExpanded"
                                        checked="true"
                                        class="sheet-expand-collapse-checkbox"
                                    />
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea
                                        class="sheet-text-area-full sheet-collapsible"
                                        name="attr_RaceAbilDesc"
                                        value=""
                                        placeholder="Description of racial ability"
                                    ></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Talents</h1>
                        <fieldset class="repeating_talents">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input
                                            type="text"
                                            name="attr_TalentName"
                                            value=""
                                            class="sheet-tall-control"
                                            placeholder="Name of talent"
                                        />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button-small"
                                            value="&{template:text} {{character=@{character_name}}} {{title=@{TalentName}}} {{text=@{TalentDesc}}}"
                                        >
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input
                                        type="checkbox"
                                        name="attr_TalentExpanded"
                                        checked="true"
                                        class="sheet-expand-collapse-checkbox"
                                    />
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea
                                        class="sheet-text-area-full sheet-collapsible"
                                        name="attr_TalentDesc"
                                        value=""
                                        placeholder="Description of talent"
                                    ></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Class Abilities</h1>

                        <fieldset class="repeating_classabilities">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <div class="sheet-flex-form-grow">
                                        <input
                                            type="text"
                                            name="attr_ClassAbilName"
                                            value=""
                                            class="sheet-tall-control"
                                            placeholder="Name of class ability"
                                        />
                                    </div>
                                    <div class="sheet-flex-form-fixed sheet-tall-control">
                                        <button
                                            type="roll"
                                            class="sheet-display-text-button-small"
                                            value="&{template:class-ability-text} {{name=@{ClassAbilName}}} {{character=@{character_name}}} {{rating=@{ClassAbilRating}}} {{maxRating=@{ClassAbilMaxRating}}} {{power=@{ClassAbilPower}}} {{description=@{ClassAbilDesc}}}"
                                        >
                                            Display in Chat
                                        </button>
                                    </div>
                                </div>
                                <div>
                                    <input
                                        type="checkbox"
                                        name="attr_ClassAbilExpanded"
                                        checked="true"
                                        class="sheet-expand-collapse-checkbox"
                                    />
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <div class="sheet-collapsible">
                                        <table class="sheet-embedded-table">
                                            <tr>
                                                <th>Rating</th>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_ClassAbilRating" value="1" />
                                                </td>
                                                <th>Max. Rating</th>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_ClassAbilMaxRating" value="1" />
                                                </td>
                                                <th>Power</th>
                                                <td class="sheet-cell-numeric">
                                                    <input type="number" name="attr_ClassAbilPower" value="1" />
                                                </td>
                                            </tr>
                                        </table>
                                        <textarea
                                            name="attr_ClassAbilDesc"
                                            value=""
                                            class="sheet-text-area-full"
                                            placeholder="Description of class ability"
                                        />
                                    </div>
                                </div>
                            </div>
                        </fieldset>
                    </div>
                </div>
            </div>
            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------  Reputation Tab  --------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->

            <div class="sheet-section-reputation">
                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <h1 class="sheet-remove-margin-bottom">Reputation</h1>

                        <div class="sheet-flex-section">
                            <div class="sheet-column-grow">
                                <h2>Honor (Good Reputation)</h2>
                                <table>
                                    <tr>
                                        <td class="sheet-skillname">Honor</td>
                                        <td>
                                            <input
                                                type="number"
                                                name="attr_HonorRep"
                                                value="0"
                                                class="sheet-numeric-wide"
                                            />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Title</td>
                                        <td class="sheet-read-only-field">
                                            <input
                                                type="text"
                                                name="attr_HonorTitle"
                                                value="Unknown"
                                                readonly
                                                class="sheet-text-centred"
                                            />
                                        </td>
                                    </tr>
                                </table>

                                <div class="sheet-collapse-wrapper">
                                    <h2 class="sheet-table-header-collapse">Good Renown</h2>
                                    <div class="sheet-collapse-section">
                                        <input
                                            type="checkbox"
                                            name="attr_GoodRenownExpanded"
                                            checked="true"
                                            class="sheet-expand-collapse-checkbox"
                                        />
                                        <span class="sheet-expand-collapse-symbol"></span>
                                        <div class="sheet-collapsible">
                                            <fieldset class="repeating_honorrep">
                                                <table>
                                                    <tr>
                                                        <th class="sheet-small-table-header">Location</th>
                                                        <th class="sheet-small-table-header">Amount</th>
                                                    </tr>
                                                    <tr>
                                                        <td>
                                                            <input type="text" name="attr_HonorRepName" value="" />
                                                        </td>
                                                        <td class="sheet-cell-numeric">
                                                            <input type="number" name="attr_HonorRepAmt" value="0" />
                                                        </td>
                                                    </tr>
                                                </table>
                                            </fieldset>
                                        </div>
                                    </div>
                                </div>
                            </div>

                            <div class="sheet-column-grow">
                                <h2>Corruption (Bad Reputation)</h2>
                                <table>
                                    <tr>
                                        <td class="sheet-skillname">Corruption</td>
                                        <td>
                                            <input
                                                type="number"
                                                name="attr_CorruptRep"
                                                value="0"
                                                class="sheet-numeric-wide"
                                            />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Title</td>
                                        <td class="sheet-read-only-field">
                                            <input
                                                type="text"
                                                name="attr_CorruptionTitle"
                                                value="Unknown"
                                                readonly
                                                class="sheet-text-centred"
                                            />
                                        </td>
                                    </tr>
                                </table>

                                <div class="sheet-collapse-wrapper">
                                    <h2 class="sheet-table-header-collapse">Bad Renown</h2>
                                    <div class="sheet-collapse-section">
                                        <input
                                            type="checkbox"
                                            name="attr_BadRenownExpanded"
                                            checked="true"
                                            class="sheet-expand-collapse-checkbox"
                                        />
                                        <span class="sheet-expand-collapse-symbol"></span>
                                        <div class="sheet-collapsible">
                                            <fieldset class="repeating_corruptrep">
                                                <table>
                                                    <tr>
                                                        <th class="sheet-small-table-header">Location</th>
                                                        <th class="sheet-small-table-header">Amount</th>
                                                    </tr>
                                                    <tr>
                                                        <td>
                                                            <input type="text" name="attr_CorruptRepName" value="" />
                                                        </td>
                                                        <td class="sheet-cell-numeric">
                                                            <input type="number" name="attr_CorruptRepAmt" value="0" />
                                                        </td>
                                                    </tr>
                                                </table>
                                            </fieldset>
                                        </div>
                                    </div>
                                </div>
                            </div>

                            <div class="sheet-column-grow">
                                <h2>Total Reputation</h2>
                                <table>
                                    <tr>
                                        <td class="sheet-skillname">Total Reputation</td>
                                        <td class="sheet-read-only-field">
                                            <input
                                                type="text"
                                                name="attr_TotalReputation"
                                                value="0"
                                                readonly
                                                class="sheet-text-centred"
                                            />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Next Tier</td>
                                        <td class="sheet-read-only-field">
                                            <input
                                                type="text"
                                                name="attr_TotalReputationForNextLevel"
                                                value="0"
                                                readonly
                                                class="sheet-text-centred"
                                            />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Additional Talents</td>
                                        <td class="sheet-cell-numeric-readonly">
                                            <input type="number" name="attr_ReputationTalents" value="0" readonly />
                                        </td>
                                    </tr>
                                    <tr>
                                        <td class="sheet-skillname">Fame</td>
                                        <td class="sheet-cell-numeric-readonly">
                                            <input type="number" name="attr_Glory" value="0" readonly />%
                                        </td>
                                    </tr>
                                </table>

                                <div class="sheet-centred-section sheet-vertical-margin-moderate">
                                    <button
                                        type="roll"
                                        value="&{template:percentile} {{character=@{character_name}}} [[ [[1d100 + ?{Modifier|0}]] - @{Glory}]] ]] {{name=Glory Check}} {{roll=$[[0]]}} {{target=@{Glory}}} {{difference=$[[1]]}}"
                                    >
                                        Roll Fame Check
                                    </button>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Known Characters</h1>

                        <div class="sheet-spacer-top-margin">
                            <fieldset class="repeating_knownchars">
                                <table>
                                    <tr>
                                        <th class="sheet-small-table-header">Name</th>
                                        <th class="sheet-small-table-header">Rank</th>
                                    </tr>
                                    <tr>
                                        <td>
                                            <input type="text" name="attr_KnownCharName" value="" />
                                        </td>
                                        <td class="sheet-cell-numeric">
                                            <input type="number" name="attr_KnownCharRank" value="0" />
                                        </td>
                                    </tr>
                                </table>
                            </fieldset>
                        </div>
                    </div>
                </div>
            </div>
            <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------  Notes Tab  ----------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->

            <div class="sheet-section-notes">
                <div class="sheet-flex-section">
                    <div class="sheet-column-grow">
                        <h1>Notes</h1>
                        <fieldset class="repeating_notes1">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <input
                                        type="text"
                                        name="attr_Note1Title"
                                        value=""
                                        class="sheet-tall-control"
                                        placeholder="Note title"
                                    />
                                </div>
                                <div>
                                    <input
                                        type="checkbox"
                                        name="attr_Note1Expanded"
                                        checked="true"
                                        class="sheet-expand-collapse-checkbox"
                                    />
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea
                                        class="sheet-text-area-large sheet-collapsible"
                                        name="attr_Note1Content"
                                        value=""
                                        placeholder="Note"
                                    ></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>

                    <div class="sheet-column-grow">
                        <h1>Notes</h1>
                        <fieldset class="repeating_notes2">
                            <div class="sheet-repeating-section">
                                <div class="sheet-flex-form-container">
                                    <input
                                        type="text"
                                        name="attr_Note2Title"
                                        value=""
                                        class="sheet-tall-control"
                                        placeholder="Note title"
                                    />
                                </div>
                                <div>
                                    <input
                                        type="checkbox"
                                        name="attr_Note2Expanded"
                                        checked="true"
                                        class="sheet-expand-collapse-checkbox"
                                    />
                                    <span class="sheet-expand-collapse-symbol"></span>
                                    <textarea
                                        class="sheet-text-area-large sheet-collapsible"
                                        name="attr_Note2Content"
                                        value=""
                                        placeholder="Note"
                                    ></textarea>
                                </div>
                            </div>
                        </fieldset>
                    </div>
                </div>
            </div>
        </div>
        <div class="sheet-background-column-fixed-right"></div>
    </div>
    <!-- ----------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------  Roll Templates  --------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------ -->

    <rolltemplate class="sheet-rolltemplate-text">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{title}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <div class="sheet-template-text">{{text}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-class-ability-text">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Rating</th>
                        <td>{{rating}}</td>
                    </tr>
                    <tr>
                        <th>Max. Rating</th>
                        <td>{{maxRating}}</td>
                    </tr>
                    <tr>
                        <th>Power</th>
                        <td>{{power}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <div class="sheet-template-text">{{description}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-percentile">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                {{#rollGreater() difference 0}}
                <div class="sheet-template-failure">Failure</div>
                {{/rollGreater() difference 0}} {{#^rollGreater() difference 0}}
                <div class="sheet-template-success">Success</div>
                {{/^rollGreater() difference 0}}

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Roll</th>
                        <td>{{roll}}</td>
                    </tr>
                    <tr>
                        <th>Target</th>
                        <td>{{target}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-attack">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{attackType}} Attack</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Total To Hit</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Actions</th>
                        <td>{{actions}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-damage">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{damageType}} Damage</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Damage</th>
                        <td>{{damage}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-roll">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Roll</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-simple">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <div class="sheet-template-text-prominent">{{text}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-two-part">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <div class="sheet-template-text-prominent">{{text}}</div>

                <div class="sheet-template-hr"></div>

                <div class="sheet-template-text-supplementary">{{supplementary}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-spell-description">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}}</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Area</th>
                        <td>{{area}}</td>
                    </tr>
                    <tr>
                        <th>Duration</th>
                        <td>{{duration}}</td>
                    </tr>
                    <tr>
                        <th>Protection</th>
                        <td>{{protection}}</td>
                    </tr>
                    <tr>
                        <th>Mana Drain</th>
                        <td>{{drain}}</td>
                    </tr>
                    <tr>
                        <th>Magic Actions</th>
                        <td>{{actions}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <div class="sheet-template-text">{{description}}</div>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-spell-cast">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}} Cast Roll</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Total to Cast</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Area</th>
                        <td>{{area}}</td>
                    </tr>
                    <tr>
                        <th>Duration</th>
                        <td>{{duration}}</td>
                    </tr>
                    <tr>
                        <th>Mana Drain</th>
                        <td>{{drain}}</td>
                    </tr>
                    <tr>
                        <th>Magic Actions</th>
                        <td>{{actions}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>

    <rolltemplate class="sheet-rolltemplate-spell-effect">
        <div class="sheet-template-container">
            <div class="sheet-template-box">
                <div class="sheet-template-title">{{name}} Effect Roll</div>
                <div class="sheet-template-subtitle">{{character}}</div>

                <table>
                    <tr>
                        <th>Total Spell Effect</th>
                        <td>{{roll}}</td>
                    </tr>
                </table>

                <div class="sheet-template-hr"></div>

                <table>
                    <tr>
                        <th>Protection</th>
                        <td>{{protection}}</td>
                    </tr>
                </table>
            </div>
        </div>
    </rolltemplate>
</div>