Class ItemAction

constructor

• new ItemAction(data, parent): ItemAction

• Parameters

  • data: any

  • parent: any

  Returns ItemAction

apps

conditionals

data

parent

sheet

activation

• get activation(): any

• Returns any

actor

• get actor(): null | ActorPF

• Returns null | ActorPF

allDamageSources

• get allDamageSources(): ItemChange[]

• Returns ItemChange[]

autoDeductCharges

• get autoDeductCharges(): boolean

• Returns boolean

critRange

• get critRange(): number

• Effective critical range when accounting for broken status and action type.

  Returns number

damageSources

• get damageSources(): ItemChange[]

• An array of changes affecting this action's damage

  Returns ItemChange[]

description

• get description(): any

• Returns any

enhancementBonus

• get enhancementBonus(): any

• Returns any

hasAction

• get hasAction(): boolean

• Returns boolean

hasAttack

• get hasAttack(): boolean

• Returns boolean

hasDamage

• get hasDamage(): boolean

• Does the action implement a damage roll as part of its usage

  Returns boolean

hasEffect

• get hasEffect(): boolean

• Returns boolean

hasMultiAttack

• get hasMultiAttack(): boolean

• Returns boolean

hasRange

• get hasRange(): boolean

• Does the item have range defined.

  Returns boolean

hasSave

• get hasSave(): boolean

• Does the Item implement a saving throw as part of its usage

  Returns boolean

hasSound

• get hasSound(): boolean

• Returns boolean

hasTemplate

• get hasTemplate(): boolean

• Returns boolean

id

• get id(): any

• Returns any

img

• get img(): any

• Returns any

isCharged

• get isCharged(): boolean

• Returns boolean

isCombatManeuver

• get isCombatManeuver(): boolean

• Returns whether this action is a combat maneuver

  Returns boolean

isHealing

• get isHealing(): boolean

• Does the item provide an amount of healing instead of conventional damage?

  Returns boolean

isSelfCharged

• get isSelfCharged(): boolean

• Returns boolean

item

• get item(): ItemPF

• Returns ItemPF

maxRange

• get maxRange(): number

• Returns number

minRange

• get minRange(): number

• Returns number

name

• get name(): any

• Returns any

range

• get range(): number

• Returns number

tag

• get tag(): any

• Returns any

Static defaultDamageType

• get defaultDamageType(): {
      custom: string;
      values: never[];
  }

• Returns {
      custom: string;
      values: never[];
  }

  • custom: string

  • values: never[]

Static defaultData

• get defaultData(): {
      _id: string;
      ability: {
          attack: string;
          critMult: number;
          critRange: number;
          damage: string;
          damageMult: number;
      };
      actionType: null;
      activation: {
          cost: number;
          type: string;
          unchained: {
              cost: number;
              type: string;
          };
      };
      attackBonus: string;
      attackName: string;
      attackNotes: never[];
      attackParts: never[];
      conditionals: never[];
      critConfirmBonus: string;
      damage: {
          critParts: never[];
          nonCritParts: never[];
          parts: never[];
      };
      description: string;
      duration: {
          units: string;
          value: null;
      };
      effectNotes: never[];
      enh: {
          value: null;
      };
      formula: string;
      formulaicAttacks: {
          bonus: {
              formula: string;
          };
          count: {
              formula: string;
          };
          label: null;
      };
      img: string;
      measureTemplate: {
          customColor: string;
          customTexture: string;
          overrideColor: boolean;
          overrideTexture: boolean;
          size: string;
          type: string;
      };
      name: string;
      naturalAttack: {
          primaryAttack: boolean;
          secondary: {
              attackBonus: string;
              damageMult: number;
          };
      };
      nonlethal: boolean;
      powerAttack: {
          critMultiplier: number;
          damageBonus: number;
          multiplier: string;
      };
      range: {
          maxIncrements: number;
          minUnits: string;
          minValue: null;
          units: string;
          value: null;
      };
      save: {
          dc: string;
          description: string;
          type: string;
      };
      soundEffect: string;
      spellArea: string;
      spellEffect: string;
      tag: string;
      target: {
          value: string;
      };
      touch: boolean;
      uses: {
          autoDeductChargesCost: string;
          self: {
              maxFormula: string;
              per: string;
              value: number;
          };
      };
      usesAmmo: boolean;
  }

• Returns {
      _id: string;
      ability: {
          attack: string;
          critMult: number;
          critRange: number;
          damage: string;
          damageMult: number;
      };
      actionType: null;
      activation: {
          cost: number;
          type: string;
          unchained: {
              cost: number;
              type: string;
          };
      };
      attackBonus: string;
      attackName: string;
      attackNotes: never[];
      attackParts: never[];
      conditionals: never[];
      critConfirmBonus: string;
      damage: {
          critParts: never[];
          nonCritParts: never[];
          parts: never[];
      };
      description: string;
      duration: {
          units: string;
          value: null;
      };
      effectNotes: never[];
      enh: {
          value: null;
      };
      formula: string;
      formulaicAttacks: {
          bonus: {
              formula: string;
          };
          count: {
              formula: string;
          };
          label: null;
      };
      img: string;
      measureTemplate: {
          customColor: string;
          customTexture: string;
          overrideColor: boolean;
          overrideTexture: boolean;
          size: string;
          type: string;
      };
      name: string;
      naturalAttack: {
          primaryAttack: boolean;
          secondary: {
              attackBonus: string;
              damageMult: number;
          };
      };
      nonlethal: boolean;
      powerAttack: {
          critMultiplier: number;
          damageBonus: number;
          multiplier: string;
      };
      range: {
          maxIncrements: number;
          minUnits: string;
          minValue: null;
          units: string;
          value: null;
      };
      save: {
          dc: string;
          description: string;
          type: string;
      };
      soundEffect: string;
      spellArea: string;
      spellEffect: string;
      tag: string;
      target: {
          value: string;
      };
      touch: boolean;
      uses: {
          autoDeductChargesCost: string;
          self: {
              maxFormula: string;
              per: string;
              value: number;
          };
      };
      usesAmmo: boolean;
  }

  • _id: string

  • ability: {
        attack: string;
        critMult: number;
        critRange: number;
        damage: string;
        damageMult: number;
    }

    • attack: string

    • critMult: number

    • critRange: number

    • damage: string

    • damageMult: number

  • actionType: null

  • activation: {
        cost: number;
        type: string;
        unchained: {
            cost: number;
            type: string;
        };
    }

    • cost: number

    • type: string

    • unchained: {
          cost: number;
          type: string;
      }

      • cost: number

      • type: string

  • attackBonus: string

  • attackName: string

  • attackNotes: never[]

  • attackParts: never[]

  • conditionals: never[]

  • critConfirmBonus: string

  • damage: {
        critParts: never[];
        nonCritParts: never[];
        parts: never[];
    }

    • critParts: never[]

    • nonCritParts: never[]

    • parts: never[]

  • description: string

  • duration: {
        units: string;
        value: null;
    }

    • units: string

    • value: null

  • effectNotes: never[]

  • enh: {
        value: null;
    }

    • value: null

  • formula: string

  • formulaicAttacks: {
        bonus: {
            formula: string;
        };
        count: {
            formula: string;
        };
        label: null;
    }

    • bonus: {
          formula: string;
      }

      • formula: string

    • count: {
          formula: string;
      }

      • formula: string

    • label: null

  • img: string

  • measureTemplate: {
        customColor: string;
        customTexture: string;
        overrideColor: boolean;
        overrideTexture: boolean;
        size: string;
        type: string;
    }

    • customColor: string

    • customTexture: string

    • overrideColor: boolean

    • overrideTexture: boolean

    • size: string

    • type: string

  • name: string

  • naturalAttack: {
        primaryAttack: boolean;
        secondary: {
            attackBonus: string;
            damageMult: number;
        };
    }

    • primaryAttack: boolean

    • secondary: {
          attackBonus: string;
          damageMult: number;
      }

      • attackBonus: string

      • damageMult: number

  • nonlethal: boolean

  • powerAttack: {
        critMultiplier: number;
        damageBonus: number;
        multiplier: string;
    }

    • critMultiplier: number

    • damageBonus: number

    • multiplier: string

  • range: {
        maxIncrements: number;
        minUnits: string;
        minValue: null;
        units: string;
        value: null;
    }

    • maxIncrements: number

    • minUnits: string

    • minValue: null

    • units: string

    • value: null

  • save: {
        dc: string;
        description: string;
        type: string;
    }

    • dc: string

    • description: string

    • type: string

  • soundEffect: string

  • spellArea: string

  • spellEffect: string

  • tag: string

  • target: {
        value: string;
    }

    • value: string

  • touch: boolean

  • uses: {
        autoDeductChargesCost: string;
        self: {
            maxFormula: string;
            per: string;
            value: number;
        };
    }

    • autoDeductChargesCost: string

    • self: {
          maxFormula: string;
          per: string;
          value: number;
      }

      • maxFormula: string

      • per: string

      • value: number

  • usesAmmo: boolean

_prepareConditionals

• _prepareConditionals(conditionals): Collection<any>

• Parameters

  • conditionals: any

  Returns Collection<any>

delete

• delete(): Promise<any>

• Returns Promise<any>

getChargeCost

• getChargeCost(options?): number

• Parameters

  • Optional options: {
        rollData: undefined | object;
    } = {}

    Additional options to configure behavior.

    • rollData: undefined | object

      Pre-determined roll data to pass for determining the charge cost.

  Returns number

  Cost in charges for this action.

getChatData

• getChatData(htmlOptions?, chatDataOptions?): ChatData

• Generates ChatData for this action's parent item, but with this action's data, regardless of whether it is the first action or not.

  Parameters

  • Optional htmlOptions: any = {}

    Options passed to ItemPF#getChatData affecting text enrichment

  • Optional chatDataOptions: object = {}

    Options passed to ItemPF#getChatData affecting the chat data

  Returns ChatData

  Chat data for this action's parent and this action

  See

  ItemPF#getChatData

getConditionalCritical

• getConditionalCritical(target): {}

• Parameters

  • target: any

  Returns {}

getConditionalModifierTypes

• getConditionalModifierTypes(target): {}

• Parameters

  • target: any

  Returns {}

getConditionalSubTargets

• getConditionalSubTargets(target): Object

• Generates lists of conditional subtargets this attack can have.

  Parameters

  • target: string

    The target key, as defined in PF1.conditionTargets.

  Returns Object

  A list of conditionals

getConditionalTargets

• getConditionalTargets(): Object

• Generates a list of targets this modifier can have.

  Returns Object

  A list of targets

getDC

• getDC(rollData?): number

• Parameters

  • Optional rollData: object = null

    Data to pass to the roll. If none is given, get new roll data.

  Returns number

  The Difficulty Class for this action.

getLabels

• getLabels(options?): Record<string, string>

• Returns labels related to this particular action

  Parameters

  • Optional options: {
        rollData: undefined | object;
    } = {}

    • rollData: undefined | object

      Pre-determined roll data. If not provided, finds the action's own roll data.

  Returns Record<string, string>

  This action's labels

getRange

• getRange(options?): null | number

• Parameters

  • Optional options: {
        rollData: undefined | object;
        type: undefined | string;
    } = {}

    Additional options to configure behavior.

    • rollData: undefined | object

      Specific roll data to pass.

    • type: undefined | string

      What type of range to query. Either "single" (for a single range increment), "max" or "min".

  Returns null | number

  The given range, in system configured units, or null if no range is applicable.

getRollData

• getRollData(): object

• Returns object

parseFormulaicAttacks

• parseFormulaicAttacks(__namedParameters?): undefined | number

• Parameters

  • __namedParameters: {
        formula: undefined | null;
        rollData: any;
    } = {}

    • formula: undefined | null

    • rollData: any

  Returns undefined | number

prepareData

• prepareData(): void

• Returns void

rollAttack

• rollAttack(root0?): Promise<Evaluated<D20RollPF>>

• Place an attack roll using an item (weapon, feat, spell, or equipment)

  Parameters

  • root0: {
        bonus: undefined | null;
        data: undefined | null;
        extraParts: undefined | any[];
        primaryAttack: undefined | boolean;
    } = {}

    • bonus: undefined | null

    • data: undefined | null

    • extraParts: undefined | any[]

    • primaryAttack: undefined | boolean

  Returns Promise<Evaluated<D20RollPF>>

rollDamage

• rollDamage(options?): Promise<DamageRoll[]>

• Roll damage for an action.

  Parameters

  • Optional options: {
        conditionalParts: undefined | object;
        critical: undefined | boolean;
        data: undefined | null | object;
        extraParts: undefined | string[];
        primaryAttack: undefined | boolean;
    } = {}

    Options configuring the damage roll

    • conditionalParts: undefined | object

      Conditional data sets

    • critical: undefined | boolean

      Whether to roll critical damage

    • data: undefined | null | object

      rollData to be used

    • extraParts: undefined | string[]

      Additional strings added to the roll formula

    • primaryAttack: undefined | boolean

      Whether this is the primary attack

  Returns Promise<DamageRoll[]>

  Created damage rolls, one roll per damage part

rollEffect

• rollEffect(root0?): string

• Only roll the item's effect.

  Parameters

  • root0: {
        critical: undefined | boolean;
        primaryAttack: undefined | boolean;
    } = {}

    • critical: undefined | boolean

    • primaryAttack: undefined | boolean

  Returns string

rollFormula

• rollFormula(options?): Promise<undefined | ChatMessagePF>

• Place an attack roll using an item (weapon, feat, spell, or equipment) Rely upon the DicePF.d20Roll logic for the core implementation

  Parameters

  • options: {} = {}

  Returns Promise<undefined | ChatMessagePF>

update

• update(updateData, options?): Promise<void>

• Parameters

  • updateData: any

  • options: {} = {}

  Returns Promise<void>

use

• use(options?): Promise<void>

• Parameters

  • options: object = {}

    See ItemPF#useAttack.

  Returns Promise<void>

Static create

• create(data, context?): Promise<(undefined | ItemAction)[]>

• Creates an action.

  Parameters

  • data: object[]

    Data to initialize the action(s) with.

  • context: {
        parent: undefined | ItemPF;
    } = {}

    An object containing context information.

    • parent: undefined | ItemPF

      The parent entity to create the action within.

  Returns Promise<(undefined | ItemAction)[]>

  The resulting actions, or an empty array if nothing was created.