foundry-dsa41-game/src/module/data/specialAbility.mjs

import BaseItem from "./base-item.mjs";

const {
    AnyField,
    BooleanField,
    NumberField,
    SchemaField,
    ArrayField,
    StringField,
    HTMLField,
    ObjectField
} = foundry.data.fields;

export class SpecialAbilityDataModel extends BaseItem {

    static defineSchema() {
        return {
            name: new StringField(),
            value: new StringField(),
            auswahl: new ArrayField(
                new SchemaField({
                    name: new StringField(),
                    requirement: new ArrayField(
                        new SchemaField({
                            attribute: new StringField(),
                            minValue: new NumberField(),
                            maxValue: new NumberField(),
                            sonderfertigkeit: new StringField(),
                            talent: new StringField(),
                        })
                    ),
                    mod: new ArrayField(new SchemaField({
                        name: new StringField(),
                        value: new NumberField(),
                    }))
                }),
            ),
            seite: new NumberField(),
            aktionsText: new HTMLField(),
            text: new HTMLField(),
            requirement: new ArrayField(
                new SchemaField({
                    attribute: new StringField(),
                    minValue: new NumberField(),
                    maxValue: new NumberField(),
                    sonderfertigkeit: new StringField(),
                    talent: new StringField(),
                })
            ),
            waffenLimit: new ArrayField(
                new SchemaField({
                    waffe: new StringField(),
                    gruppe: new StringField(),
                    mod: new NumberField(),
                })
            ),
            mod: new ArrayField(new SchemaField({
                name: new StringField(),
                value: new NumberField(),
            })),
            mehrereAktionen: new BooleanField(),
        }
    }

    #getRequirements() {
        if (this.value && this.auswahl.find(p => p.name === this.value)) {
            const auswahl = this.auswahl.find(p => p.name === this.value)
            return auswahl.requirement
        } else {
            return this.requirement
        }
    }

    isActive(options) {

        const requirements = this.#getRequirements()

        let passes = true
        let mod = 0

        const flatActor = foundry.utils.flattenObject(this.parent.actor.system)
        for (let requirement of requirements) {

            let targetField = null

            if (requirement.attribute) {
                targetField = flatActor?.[requirement.attribute.toLocaleLowerCase()]
            }
            if (requirement.talent) {
                targetField = this.parent.actor.itemTypes["Skill"].find(p => p.name.toLocaleLowerCase() === requirement.talent.toLocaleLowerCase()).taw
            }
            if (requirement.minValue) {
                passes = requirement.minValue <= targetField
                if (!passes) console.log(`fails requirement ${requirement.attribute ?? requirement.talent} (${requirement.minValue} <= ${targetField})`)
            }
            if (requirement.maxValue) {
                passes = targetField <= requirement.maxValue
                if (!passes) console.log(`fails requirement ${requirement.attribute ?? requirement.talent} (${targetField} <= ${requirement.maxValue})`)
            }
            if (requirement.sonderfertigkeit) {
                passes = this.parent.actor.itemTypes["SpecialAbility"].find(p => p.name === requirement.sonderfertigkeit) != undefined
                if (!passes) console.log(`fails requirement ${requirement.sonderfertigkeit} (not in possession)`)
            }
            if (requirement["compare"]) {
                const {ownAttribute, operation, targetAttribute} = requirement["compare"]
                if (options.target) {
                    const flatTarget = foundry.utils.flattenObject(options.target.system)
                    const foreignTargetField = flatTarget[targetAttribute]
                    const ourTargetField = flatActor[ownAttribute]
                    switch (operation) {
                        case "lt":
                            passes = ourTargetField < foreignTargetField;
                            break;
                        case "lte":
                            passes = ourTargetField <= foreignTargetField;
                            break;
                        case "eq":
                            passes = ourTargetField == foreignTargetField;
                            break;
                        case "neq":
                            passes = ourTargetField != foreignTargetField;
                            break;
                        case "gte":
                            passes = ourTargetField >= foreignTargetField;
                            break;
                        case "gt":
                            passes = ourTargetField > foreignTargetField;
                            break;
                    }
                    if (!passes) {
                        console.log(`fails compare requirement ${ownAttribute} ${operation} ${targetAttribute}`)
                    }
                } else {
                    console.log(`fails compare requirement as no target has been selected`)
                    return false // cant pass as we dont have a target
                }
            }
            if (!passes) {
                console.log("fails atleast 1 requirement of ", this)
                break
            }
        }
        console.log(this.name, "requirements", passes)
        if (passes) {
            if (options?.weapon) {
                for (const waff of this.waffenLimit) {
                    if (waff.waffe) {
                        passes = options?.weapon?.name === waff.waffe ?? false
                        if (waff.mod) mod = waff.mod
                        if (passes)
                            break
                    }
                    if (waff.gruppe) {
                        passes = options?.skill?.name === waff.gruppe ?? false
                        if (waff.mod) mod = waff.mod
                        if (passes)
                            break
                    }
                }
            }
        }
        console.log("return value", {passes, mod})
        return {passes, mod}
    }
}