Class ItemAction

constructor

• new ItemAction(data, parent): ItemAction

• Parameters

  • data: any

  • parent: any

  Returns ItemAction

Internal _sheet

apps

conditionals

data

parent

Static FALLBACK_IMAGE

activation

• get activation(): string

• General activation accessor that removes determining which action economy is in use.

  Returns string

actor

• get actor(): undefined | ActorPF

• Returns undefined | ActorPF

addonMaterial

• get addonMaterial(): any

• Returns any

alignments

• get alignments(): null | string

• The action's alignment attributes, or null if the action has no alignment attributes

  Returns null | string

allDamageSources

• get allDamageSources(): ItemChange[]

• Returns ItemChange[]

ammoCost

• get ammoCost(): number

• Effective per-attack ammo cost.

  Returns number

ammoType

• get ammoType(): null | string

• Effective ammo type.

  Returns null | string

attackSources

• get attackSources(): ItemChange[]

• Get all appropriate context changes for attack rolls.

  Returns ItemChange[]

  See

  ItemPF.getContextChanges

autoDeductCharges

• get autoDeductCharges(): boolean

• Returns boolean

canUse

• get canUse(): boolean

• Can this action be used?

  Returns false if any known criteria for use limitation fails. Calls owning item's canUse functinality also.

  Returns boolean

  See

  pf1.documents.item.ItemBasePF.canUse

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(): null | number

• Returns null | number

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(): string

• Returns string

img

• get img(): string

• Returns string

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

isRanged

• get isRanged(): boolean

• Returns boolean

isSelfCharged

• get isSelfCharged(): boolean

• Returns boolean

isSpell

• get isSpell(): boolean

• Returns boolean

item

• get item(): undefined | ItemPF

• Returns undefined | ItemPF

maxRange

• get maxRange(): number

• Returns number

minRange

• get minRange(): number

• Returns number

misfire

• get misfire(): number

• Misfire threshold

  Returns number

name

• get name(): string

• Returns string

normalMaterial

• get normalMaterial(): any

• Returns any

range

• get range(): number

• Returns number

sheet

• get sheet(): ItemActionSheet

• Returns ItemActionSheet

tag

• get tag(): string

• Returns string

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: null;
      };
      actionType: string;
      activation: {
          cost: number;
          type: string;
          unchained: {
              cost: number;
              type: string;
          };
      };
      alignments: {
          chaotic: null;
          evil: null;
          good: null;
          lawful: null;
      };
      ammo: {
          cost: number;
          type: string;
      };
      area: string;
      attackBonus: string;
      attackName: string;
      attackNotes: never[];
      conditionals: never[];
      critConfirmBonus: string;
      damage: {
          critParts: never[];
          nonCritParts: never[];
          parts: never[];
      };
      description: string;
      duration: {
          units: string;
          value: null;
      };
      effectNotes: never[];
      enh: {
          value: null;
      };
      extraAttacks: {
          formula: {
              bonus: string;
              count: string;
              label: string;
          };
          manual: never[];
          type: string;
      };
      held: string;
      img: string;
      material: {
          addon: never[];
          normal: {};
      };
      measureTemplate: {
          color: string;
          size: string;
          texture: string;
          type: string;
      };
      name: string;
      naturalAttack: {
          primaryAttack: boolean;
          secondary: {
              attackBonus: string;
              damageMult: number;
          };
      };
      nonlethal: boolean;
      powerAttack: {
          critMultiplier: number;
          damageBonus: number;
          multiplier: null;
      };
      range: {
          maxIncrements: number;
          minUnits: string;
          minValue: null;
          units: string;
          value: null;
      };
      save: {
          dc: string;
          description: string;
          type: string;
      };
      soundEffect: string;
      spellEffect: string;
      splash: boolean;
      tag: string;
      target: {
          value: string;
      };
      touch: boolean;
      uses: {
          autoDeductChargesCost: string;
          self: {
              maxFormula: string;
              per: string;
              value: number;
          };
      };
  }

• Returns {
      _id: string;
      ability: {
          attack: string;
          critMult: number;
          critRange: number;
          damage: string;
          damageMult: null;
      };
      actionType: string;
      activation: {
          cost: number;
          type: string;
          unchained: {
              cost: number;
              type: string;
          };
      };
      alignments: {
          chaotic: null;
          evil: null;
          good: null;
          lawful: null;
      };
      ammo: {
          cost: number;
          type: string;
      };
      area: string;
      attackBonus: string;
      attackName: string;
      attackNotes: never[];
      conditionals: never[];
      critConfirmBonus: string;
      damage: {
          critParts: never[];
          nonCritParts: never[];
          parts: never[];
      };
      description: string;
      duration: {
          units: string;
          value: null;
      };
      effectNotes: never[];
      enh: {
          value: null;
      };
      extraAttacks: {
          formula: {
              bonus: string;
              count: string;
              label: string;
          };
          manual: never[];
          type: string;
      };
      held: string;
      img: string;
      material: {
          addon: never[];
          normal: {};
      };
      measureTemplate: {
          color: string;
          size: string;
          texture: string;
          type: string;
      };
      name: string;
      naturalAttack: {
          primaryAttack: boolean;
          secondary: {
              attackBonus: string;
              damageMult: number;
          };
      };
      nonlethal: boolean;
      powerAttack: {
          critMultiplier: number;
          damageBonus: number;
          multiplier: null;
      };
      range: {
          maxIncrements: number;
          minUnits: string;
          minValue: null;
          units: string;
          value: null;
      };
      save: {
          dc: string;
          description: string;
          type: string;
      };
      soundEffect: string;
      spellEffect: string;
      splash: boolean;
      tag: string;
      target: {
          value: string;
      };
      touch: boolean;
      uses: {
          autoDeductChargesCost: string;
          self: {
              maxFormula: string;
              per: string;
              value: number;
          };
      };
  }

  • _id: string

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

    • attack: string

    • critMult: number

    • critRange: number

    • damage: string

    • damageMult: null

  • actionType: string

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

    • cost: number

    • type: string

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

      • cost: number

      • type: string

  • alignments: {
        chaotic: null;
        evil: null;
        good: null;
        lawful: null;
    }

    • chaotic: null

    • evil: null

    • good: null

    • lawful: null

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

    • cost: number

    • type: string

  • area: string

  • attackBonus: string

  • attackName: string

  • attackNotes: 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

  • extraAttacks: {
        formula: {
            bonus: string;
            count: string;
            label: string;
        };
        manual: never[];
        type: string;
    }

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

      • bonus: string

      • count: string

      • label: string

    • manual: never[]

    • type: string

  • held: string

  • img: string

  • material: {
        addon: never[];
        normal: {};
    }

    • addon: never[]

    • normal: {}

  • measureTemplate: {
        color: string;
        size: string;
        texture: string;
        type: string;
    }

    • color: string

    • size: string

    • texture: 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: null;
    }

    • critMultiplier: number

    • damageBonus: number

    • multiplier: null

  • 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

  • spellEffect: string

  • splash: boolean

  • 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

_prepareConditionals

• _prepareConditionals(conditionals): any
• Internal

  Parameters

  • conditionals: any[]

  Returns any

delete

• delete(): Item

• Delete this action

  Returns Item

  • Updated parent item document.

getAttacks

• getAttacks(options?): object[]

• Generate attacks.

  Parameters

  • Optional options: {
        bonuses: undefined | boolean;
        conditionals: undefined | boolean;
        full: undefined | boolean;
        resolve: undefined | boolean;
        rollData: undefined | object;
    } = {}

    Options

    • bonuses: undefined | boolean

      Include other bonuses. Requires resolve to be enabled.

    • conditionals: undefined | boolean

      Include conditional modifications. Requires resolve to be enabled.

    • full: undefined | boolean

      Full attack

    • resolve: undefined | boolean

      If the bonuses are to be resolved directly.

    • rollData: undefined | object

      Roll data

  Returns object[]

  • Array of attack data

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(chatDataOptions?): Promise<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 chatDataOptions: object = {}

    Options passed to ItemPF#getChatData affecting the chat data

  Returns Promise<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): {}

• Generates lists of conditional subtargets this attack can have.

  Parameters

  • target: string

    The target key, as defined in PF1.conditionTargets.

  Returns {}

  A list of conditionals

getConditionalTargets

• getConditionalTargets(): {}

• Generates a list of targets this modifier can have.

  Returns {}

  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

getPowerAttackMult

• getPowerAttackMult(options?): number

• Get power attack, deadly aim or piranha strike multiplier.

  Parameters

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

    Additional options

    • rollData: undefined | object

      Roll data instance

  Returns number

  • Effective multiplier

getRange

• getRange(options?): null | number

• Parameters

  • Optional options: {
        rollData: undefined | object;
        type: undefined | "min" | "max" | "single";
    } = {}

    Additional options to configure behavior.

    • rollData: undefined | object

      Specific roll data to pass.

    • type: undefined | "min" | "max" | "single"

      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
• Internal

  Returns object

prepareData

• prepareData(): void
• Internal

  Data preparation

  Returns void

render

• render(force?, context?): void

• Render all connected application instances.

  Parameters

  • Optional force: boolean = false

    Force rendering

  • Optional context: object = {}

    Optional context

  Returns void

rollAttack

• rollAttack(options?): D20RollPF

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

  Parameters

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

    Options

    • bonus: undefined | string

      Additional attack bonus

    • data: undefined | object

      Roll data

    • extraParts: undefined | string[]

      Additional attack parts

    • primaryAttack: undefined | boolean

      Treat as primary natural attack

  Returns 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

update

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

• Update the action

  Parameters

  • updateData: object

    Update data

  • context: object = {}

    Update context

  Returns Promise<void>

use

• use(options?): Promise<void>

• Use action.

  Wrapper for () ItemPF.use()

  Parameters

  • options: object = {}

    Options passed to ItemPF.use().

  Returns Promise<void>

  • Returns what ItemPF.use() returns.

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.