Class ActorPF<Model>

alignment

alignmentChanges

changeFlags

changeOverrides

changes

classes

constructor

itemFlags

itemTypes

sourceInfo

system

type

_spellbookTargets

• get _spellbookTargets(): string[]
  Internal

  Change target paths for spellbooks on the actor.

  Returns string[]

  Deprecated

  Todo

  Move to base character model

allItems

• get allItems(): ItemPF<BaseItemModel>[]

  Returns ItemPF<BaseItemModel>[]

  All items on this actor, including those in containers.

  Deprecated

allNotes

• get allNotes(): AllNotesEntry[]

  An array of all context note data for this actor.

  Returns AllNotesEntry[]

auraStrength

• get auraStrength(): any

  Returns any

  Deprecated

  • Use HauntModel#auraStrength instead.

containerItems

• get containerItems(): ItemPF<ContainerModel>[]
  Internal

  All items this actor is holding in containers.

  Returns ItemPF<ContainerModel>[]

  Deprecated

  • Does not provide anything notable anymore

spellFailure

• get spellFailure(): number

  Spell Failure Percentage as number from 0 to 100.

  Returns number

  Deprecated

  Todo

  Move to base character datamodel

visionSharingSheet

• get visionSharingSheet(): VisionSharingSheet

  The VisionSharingSheet instance for this actor

  Returns VisionSharingSheet

_getContextConditions

• _getContextConditions(context: string): model[]
  Internal

  Get active conditions marked for context

  Parameters

  • context: string

    Context ID

  Returns model[]

  • Array of conditions

_parseResistanceEntry

• _parseResistanceEntry(
      entry: string | object,
      resistanceType?: "dr" | "er",
  ): ParsedResistanceEntry
  Internal

  Parse resistance entry

  Primarily called from parseResistances

  Parameters

  • entry: string | object
  • OptionalresistanceType: "dr" | "er" = "dr"

  Returns ParsedResistanceEntry

  Deprecated

_prepareArmorData

• _prepareArmorData(
      equipment?: { id: string; type: string },
      armorData: object,
  ): void
  Internal

  Prepare armor/shield data for roll data

  Parameters

  • equipment: { id: string; type: string } = {}

    Equipment info

    • id: string

      Item ID

    • type: string

      Armor/Shield type

  • armorData: object

    Armor data object

  Returns void

_updateTokenSize

• _updateTokenSize(): Promise<TokenDocument[] | null>
  Internal

  Resize token sizes based on actor size.

  Ignores tokens with static size set.

  Returns Promise<TokenDocument[] | null>

  • Updated token documents, or null if no update was performed.

  Todo

  Add option to update token size on all scenes.

  Throws

  • On invalid parameters

convertCurrency

• convertCurrency(
      category?: "currency" | "altCurrency",
      type?: "gp" | "cp" | "pp" | "sp",
  ): Promise<ActorPF<Model>> | undefined

  Converts currencies of the given category to the given currency type

  Parameters

  • Optionalcategory: "currency" | "altCurrency" = "currency"

    Currency category, altCurrency is for weightless

  • Optionaltype: "gp" | "cp" | "pp" | "sp" = "pp"

    Target currency.

  Returns Promise<ActorPF<Model>> | undefined

  Updated document or undefined if no update occurred.

  See

  pf1.utils.currency.convert

  Deprecated

  • Since PF1 v12

createSpellbook

• createSpellbook(
      casting?: {
          ability?: string;
          cantrips?: boolean;
          class?: string;
          domain?: number;
          offset?: number;
          progression?: "high" | "med" | "low";
          spells?: "arcane" | "divine" | "psychic" | "alchemy";
          type?: "prepared" | "spontaneous" | "hybrid";
      },
      options?: { commit?: boolean },
  ): Promise<ActorPF<Model>>

  Enable and configure a new spellbook.

  Parameters

  • Optionalcasting: {
        ability?: string;
        cantrips?: boolean;
        class?: string;
        domain?: number;
        offset?: number;
        progression?: "high" | "med" | "low";
        spells?: "arcane" | "divine" | "psychic" | "alchemy";
        type?: "prepared" | "spontaneous" | "hybrid";
    } = {}

    Book casting configuration

    • Optionalability?: string

      Spellcasting ability score ID

    • Optionalcantrips?: boolean

      Has cantrips?

    • Optionalclass?: string

      Class tag

    • Optionaldomain?: number

      Domain/School slots

    • Optionaloffset?: number

      Level offset

    • Optionalprogression?: "high" | "med" | "low"

      Casting progression type

    • Optionalspells?: "arcane" | "divine" | "psychic" | "alchemy"

      Spell/spellcasting type

    • Optionaltype?: "prepared" | "spontaneous" | "hybrid"

      Spellbook type

  • Optionaloptions: { commit?: boolean } = {}

    Additional options

    • Optionalcommit?: boolean

      Commit modifications. If false, update data is returned instead of committing.

  Returns Promise<ActorPF<Model>>

  • Promise to updated document

  Deprecated

  Todo

  Move to base character model

  Example

  Create spellbook for inquisitor

  actor.createSpellbook({
    type: "spontaneous",
    progression: "med",
    ability: "wis",
    spells: "divine",
    class: "inquisitor",
    cantrips: true,
    domain: 0
  });
  Copy

enrichContextNotes

• enrichContextNotes(
      notes: ItemContextNotes,
      rollData?: object,
      options?: { roll?: boolean },
  ): Promise<void>

  Enrich context notes with item specific roll data.

  Adds enriched array to each note object.

  Parameters

  • notes: ItemContextNotes

    Context notes

  • OptionalrollData: object

    Roll data instance

  • Optionaloptions: { roll?: boolean } = {}

    Additional options

    • Optionalroll?: boolean

      Handle rolls

  Returns Promise<void>

getCarryCapacity

• getCarryCapacity(): { heavy: number; light: number; medium: number }

  Calculate current carry capacity limits.

  Returns { heavy: number; light: number; medium: number }

  • Capacity info

  Deprecated

getContextNotes

• getContextNotes(context: string, all?: boolean): ItemContextNotes[]

  Generates an array with all the active context-sensitive notes for the given context on this actor.

  Parameters

  • context: string

    The context to draw from.

  • Optionalall: boolean = true

    Retrieve notes meant for all, such as notes targeting all skills.

  Returns ItemContextNotes[]

  • Context notes

getContextNotesParsed

• getContextNotesParsed(
      context: string,
      options?: { all?: boolean; roll?: boolean },
  ): Promise<ParsedContextNoteEntry[]>

  Returns a list of already parsed context notes.

  Parameters

  • context: string

    The context to draw notes from.

  • Optionaloptions: { all?: boolean; roll?: boolean } = {}

    Additional options

    • Optionalall?: boolean

      Option to pass to getContextNotes

    • Optionalroll?: boolean

      Whether to roll inline rolls or not.

  Returns Promise<ParsedContextNoteEntry[]>

  The resulting notes, already parsed.

getFeatCount

• getFeatCount(): FeatCounts

  Return feat counts.

  Returns FeatCounts

  An object with a property value which refers to the current used feats, and max which refers to the maximum available feats.

getLevelExp

• getLevelExp(level: number, options?: { rollData?: object }): number

  Amount of experience required to gain next level at specific character level.

  Parameters

  • level: number

    Desired level to level-up.

  • Optionaloptions: { rollData?: object }

    Additional options

    • OptionalrollData?: object

      Roll data instance

  Returns number

  • The XP required for next level.

  Example

  getLevelExp(1); // -> 3000, the XP needed for level 2
  Copy

  Deprecated

  • Use .system.getLevelExp() instead

  Throws

  • If invalid level is provided.

getPerceptionModifier

• getPerceptionModifier(): any

  Returns any

  Deprecated

  • Use TrapModel#getPerceptionModifier() instead.

getSkillInfo

• getSkillInfo(
      skillId: string,
      options?: { rollData?: { skills: Record<string, SkillData> } },
  ): SkillInfo | null

  Retrieve information about a skill.

  Parameters

  • skillId: string

    Skill ID

  • Optionaloptions: { rollData?: { skills: Record<string, SkillData> } } = {}

    Additional options

    • OptionalrollData?: { skills: Record<string, SkillData> }

      Roll data instance to use.

  Returns SkillInfo | null

  • Skill information or null if the skill was not found

  Example

  actor.getSkillInfo("per"); // Perception skill info
  actor.getSkillInfo("crf.alchemy"); // Craft (Alchemy) subskill info
  Copy

  Todo

  Move most functionality to base character model

hasArmorProficiency

• hasArmorProficiency(item: ItemPF<EquipmentModel>): boolean

  Checks if there's any matching proficiency

  Parameters

  • item: ItemPF<EquipmentModel>

    The item to check for.

  Returns boolean

  Whether the actor is proficient with that item.

hasItemBooleanFlag

• hasItemBooleanFlag(flagName: string): boolean

  Check if actor has item with specified boolean flag.

  Parameters

  • flagName: string

    The name/key of the flag to search for.

  Returns boolean

  Whether this actor has any owned item with the given flag.

hasWeaponProficiency

• hasWeaponProficiency(
      item: ItemPF<ActionItemModel>,
      options?: { override?: boolean },
  ): boolean

  Test if actor is proficient with specified weapon.

  Parameters

  • item: ItemPF<ActionItemModel>

    Item to test

  • Optionaloptions: { override?: boolean }

    Additional options

    • Optionaloverride?: boolean

      Allow item's proficiency override to influence the result.

  Returns boolean

  • Proficiency state

  Remarks

  • Calls system.hasWeaponProficiency()

parseResistances

• parseResistances(resistanceType: "dr" | "eres"): Record<string, string>

  Helper function for actor energy resistance and damage reduction feedback.

  Parameters

  • resistanceType: "dr" | "eres"

    Value to check resistances for.

  Returns Record<string, string>

  Entry to label mapping of resistances or reductions.

  Deprecated

  Use pf1.utils.internal.parseResistances instead.

rollPerception

• rollPerception(options?: {}): Promise<any>

  Parameters

  • options: {} = {}

  Returns Promise<any>

  Deprecated

  • Use TrapModel#rollPerception() instead.

rollSkill

• rollSkill(skillId: string, options?: ActorRollOptions): Promise<any>

  Roll a Skill Check

  Parameters

  • skillId: string

    The skill id (e.g. "per", "prf.prf1", or "crf.alchemy")

  • Optionaloptions: ActorRollOptions = {}

    Options which configure how the skill check is rolled

  Returns Promise<any>

  • The chat message if one was created, or its data if not. void if the roll was cancelled.

  Example

  await actor.rollSkill("per", { skipDialog: true, bonus: "1d6", dice: "2d20kh" });
  Copy

  Todo

  Move most functionality to datamodels

StaticgetReach

• getReach(
      size?:
          | number
          | "med"
          | "fine"
          | "dim"
          | "tiny"
          | "sm"
          | "lg"
          | "huge"
          | "grg"
          | "col",
      stature?: "long" | "tall",
  ): { melee: number; reach: number }

  Get melee and reach maximum ranges.

  Parameters

  • size: number | "med" | "fine" | "dim" | "tiny" | "sm" | "lg" | "huge" | "grg" | "col" = "med"

    Actor size as size key or number

  • stature: "long" | "tall" = "tall"

    Actor stature

  Returns { melee: number; reach: number }

  • Ranges

  Deprecated

  Todo

  Move to utility functions

StaticgetReducedMovementSpeed

• getReducedMovementSpeed(value: number): number

  Reduced Movement Speed

  Parameters

  • value: number

    The non-reduced movement speed.

  Returns number

  The reduced movement speed.

  Example

  pf1.documents.actor.ActorPF.getReducedMovementSpeed(30); // => 20
  Copy

  Deprecated

  Todo

  Move to utility function

StaticgetSpellSlotIncrease

• getSpellSlotIncrease(mod: number, level: number): number

  Return increased amount of spell slots by ability score modifier.

  Parameters

  • mod: number

    The associated ability modifier.

  • level: number

    Spell level.

  Returns number

  Amount of spell levels to increase.

  Deprecated

  Example

  pf1.documents.actor.ActorPF.getSpellSlotIncrease(2, 1); // => 1
  pf1.documents.actor.ActorPF.getSpellSlotIncrease(6, 1); // => 2
  pf1.documents.actor.ActorPF.getSpellSlotIncrease(6, 7); // => 0
  Copy

_finalizeItems

• _finalizeItems(): void
  Internal

  Returns void

activeOwner

• get activeOwner(): any

  Returns first active owner, favoring players and uses active GM as fallback.

  Returns any

sharesVision

• get sharesVision(): boolean

  Whether current user can see through this actor.

  Returns boolean

expireActiveEffects

• expireActiveEffects(
      options?: {
          combat?: any;
          event?: "combat" | "time" | "turnStart" | "turnEnd";
          initiative?: number;
          timeOffset?: number;
          worldTime?: number;
      },
      context?: any,
  ): void

  Deletes expired temporary active effects and disables linked expired buffs.

  Parameters

  • Optionaloptions: {
        combat?: any;
        event?: "combat" | "time" | "turnStart" | "turnEnd";
        initiative?: number;
        timeOffset?: number;
        worldTime?: number;
    } = {}

    Additional options

    • Optionalcombat?: any

      Combat to expire data in, if relevant

    • Optionalevent?: "combat" | "time" | "turnStart" | "turnEnd"

      Expiration event

    • Optionalinitiative?: number

      Initiative based expiration marker

    • OptionaltimeOffset?: number

      Time offset from world time

    • OptionalworldTime?: number

      World time

  • Optionalcontext: any = {}

    Document update context

  Returns void

  Throws

  • With insufficient permissions to control the actor.

getCombatants

• getCombatants(combat?: any): Combatant[]

  Get related combatants.

  Parameters

  • Optionalcombat: any = game.combat

    Combat instance

  Returns Combatant[]

  Related combatants.

getConditionImmunities

• getConditionImmunities(): Set<string>
  Experimental

  Condition immunities

  Returns Set<string>

  • Set of immunity IDs.

AbstractgetMovement

• getMovement(type: MovementType): any

  Movement details for current movement

  Parameters

  • type: MovementType

  Returns any

getSourceDetails

• getSourceDetails(path: string): SourceInfo[]

  Retrieve source details regarding a change target.

  Parameters

  • path: string

    Change target path

  Returns SourceInfo[]

  Example

  actor.getSourceDetails("system.attributes.hp.max");
  Copy

  Todo

  • Merge sourceInfo into the change system to reduce underlying system complexity

prepareBaseData

• prepareBaseData(): void

  Prepare actor data before items are prepared.

  Returns void

  Remarks

  • Called after system.prepareBaseData() by Foundry

rollInitiative

• rollInitiative(
      options?: {
          bonus?: string | null;
          createCombatants?: boolean;
          dice?: string | null;
          initiativeOptions?: object;
          rerollInitiative?: boolean;
          rollMode?: string;
          skipDialog?: boolean;
          token?: TokenDocumentPF;
      },
  ): Promise<CombatPF | null>

  Roll initiative for one or multiple Combatants associated with this actor. If no combat exists, GMs have the option to create one. If viewing a full Actor document, all Tokens which map to that actor will be targeted for initiative rolls. If viewing a synthetic Token actor, only that particular Token will be targeted for an initiative roll.

  Parameters

  • Optionaloptions: {
        bonus?: string | null;
        createCombatants?: boolean;
        dice?: string | null;
        initiativeOptions?: object;
        rerollInitiative?: boolean;
        rollMode?: string;
        skipDialog?: boolean;
        token?: TokenDocumentPF;
    } = {}

    Options which configure how initiative is rolled

    • Optionalbonus?: string | null

      Formula for bonus to initiative

    • OptionalcreateCombatants?: boolean

      Create new Combatant entries for tokens associated with this actor.

    • Optionaldice?: string | null

      Formula override for dice to roll

    • OptionalinitiativeOptions?: object

      Options to pass to CombatPF.rollInitiative()

    • OptionalrerollInitiative?: boolean

      Reroll initiative for existing Combatants

    • OptionalrollMode?: string

      Roll mode override

    • OptionalskipDialog?: boolean

      Skip roll dialog

    • Optionaltoken?: TokenDocumentPF

      For which token this initiative roll is for

  Returns Promise<CombatPF | null>

  The updated Combat document in which initiative was rolled, or null if no initiative was rolled

  Example

  await actor.rollInitiative({ dice: "2d20kh", createCombatants: true, skipDialog: true });
  Copy

  See

  pf1.documents.CombatPF#rollInitiative

Abstract_skillTargets

• get _skillTargets(): string[]

  Retrieve valid skill change targets for this actor.

  Returns string[]

  • Skill target array

_cleanItemLinksTo

• _cleanItemLinksTo(items: ItemPF<BaseItemModel>[]): Promise<Document[]>
  Internal

  Parameters

  • items: ItemPF<BaseItemModel>[]

    Item documents to clean links to.

  Returns Promise<Document[]>

  • Updated documents

_conditionToggleNotify

• _conditionToggleNotify(conditions?: Record<string, boolean>): void
  Internal

  Parameters

  • conditions: Record<string, boolean> = {}

    Condition toggle state

  Returns void

  Todo

  • The condition notification needs to be smarter.

_getEquipmentEffects

• _getEquipmentEffects(): {
      acp: {
          armor: { broken: boolean; item: null; value: number };
          attack: {
              sources: { item: ItemPF<EquipmentModel>; value: number }[];
              total: number;
          };
          shield: { broken: boolean; item: null; value: number };
          skill: number;
          total: number;
      };
      maxDex: {
          armor: { item: null; value: number };
          shield: { item: null; value: number };
          total: null;
      };
  }
  Internal

  Returns {
      acp: {
          armor: { broken: boolean; item: null; value: number };
          attack: {
              sources: { item: ItemPF<EquipmentModel>; value: number }[];
              total: number;
          };
          shield: { broken: boolean; item: null; value: number };
          skill: number;
          total: number;
      };
      maxDex: {
          armor: { item: null; value: number };
          shield: { item: null; value: number };
          total: null;
      };
  }

_getItemSourceDetails

• _getItemSourceDetails(path: string, sources: SourceInfo[]): void
  Internal Experimental

  Get source details from items.

  Parameters

  • path: string
  • sources: SourceInfo[]

  Returns void

_handleConditionTracks

• _handleConditionTracks(documents: ActiveEffect[]): Promise<object>
  Internal

  Handle condition track toggling post active effect creation if there's still some issues.

  Parameters

  • documents: ActiveEffect[]

    Updated active effect documents

  Returns Promise<object>

  • Result from ActorPF.setConditions

_prepareChangeFlags

• _prepareChangeFlags(): void
  Internal

  Returns void

_prepareChanges

• _prepareChanges(): void
  Internal

  Prepare changes and changeOverrides

  Returns void

_prepareLinks

• _prepareLinks(): void
  Internal

  Returns void

_refreshDerivedData

• _refreshDerivedData(): void
  Internal

  Called just before the first change is applied, and after every change is applied. Sets additional variables (such as spellbook range)

  Returns void

_updateVision

• _updateVision(initializeVision?: boolean, refreshLighting?: boolean): void
  Internal

  Synchronize actor and token vision

  Parameters

  • initializeVision: boolean = false

    Initialize vision

  • refreshLighting: boolean = false

    Refresh lightning

  Returns void

AbstractgetInitiativeOptions

• getInitiativeOptions(): object | undefined
  Experimental

  Per-actor type initiative options

  Returns object | undefined

  • Options object

Static_getCategorizedClasses

• _getCategorizedClasses(classes: any): any[][]
  Internal

  Categorize classes

  Parameters

  • classes: any

    Class items. Must be already sorted as needed.

  Returns any[][]

  • Array of class groups in order of priority

getCarriedWeight

• getCarriedWeight(): number

  Total Carried Weight

  Returns number

  • kg or lbs of all carried things, including currency

getCurrency

• getCurrency(
      category?: "currency" | "altCurrency",
      options?: { inLowestDenomination?: boolean },
  ): number

  Get total currency in category.

  Parameters

  • Optionalcategory: "currency" | "altCurrency" = "currency"

    Currency category.

  • Optionaloptions: { inLowestDenomination?: boolean } = {}

    Additional options

    • OptionalinLowestDenomination?: boolean

      Return result in lowest denomination (default copper). If false, returns standard currency (default gold) instead.

  Returns number

  • Total currency in category.

  Todo

  • Move implementation details to datamodels

getTotalCurrency

• getTotalCurrency(options?: { inLowestDenomination?: boolean }): number

  Total coinage in both weighted and weightless.

  Parameters

  • Optionaloptions: { inLowestDenomination?: boolean }

    Additional options

    • OptionalinLowestDenomination?: boolean

      Use copper for calculations, otherwise standard denomination is used.

  Returns number

  • The total amount of currency, in copper pieces.

  Deprecated

  • Since PF1 v12

_applyArmorPenalties

• _applyArmorPenalties(): MobilityPenaltyResult
  Internal

  Computes armor penalties for this actor.

  Returns MobilityPenaltyResult

  The resulting penalties from armor.

  Todo

  Move to base character model

allSkills

• get allSkills(): string[]

  All skill IDs relevant to this actor

  Returns string[]

  Todo

  Move most functionality to base character datamodel

race

• get race(): ItemPF<RaceModel> | null

  Actor's current race item.

  Returns ItemPF<RaceModel> | null

addTempHP

• addTempHP(
      value: number,
      options?: { set?: boolean },
  ): Promise<ActorPF<Model> | undefined>

  Adjust temporary hit points.

  Parameters

  • value: number

    Value to add to temp HP

  • Optionaloptions: { set?: boolean } = {}

    Additional options

    • Optionalset?: boolean

      If true, the temporary hit points are set to the provide value instead of added to existing.

  Returns Promise<ActorPF<Model> | undefined>

  • Updated document or undefined if no update occurred

  Example

  Gain 50 THP

  actor.addTempHP(50);
  Copy

  Lose 10 THP

  actor.addTempHP(-10);
  Copy

  Set THP to zero

  actor.addTempHP(0, { set: true });
  Copy

applyDamage

• applyDamage(value?: number, options?: ApplyDamageOptions): Promise<any>

  Apply damage or healing to actor.

  Does not handle ER/DR or anything else special.

  Parameters

  • value: number = 0

    Value to adjust health by. Positive values deal damage, negative values heal.

  • Optionaloptions: ApplyDamageOptions = {}

    Additional options. This object will be transformed in-place as the damage application is processed.

  Returns Promise<any>

  • Updated actor or false.

  See

  ActorPF.applyDamage - For more general use.

  Example

  Cause 10 damage

  await actor.applyDamage(10);
  Copy

  Heal 10 damage

  await actor.applyDamage(-10);
  Copy

  Apply 3 damage directly to Wounds instead of Vigor

  await actor.applyDamage(3, { asWounds: true });
  Copy

  Hooks

  • pf1ApplyDamage

displayDefenseCard

• displayDefenseCard(
      options?: { rollMode?: string | null; token?: any },
  ): Promise<any>

  Show defenses in chat

  Parameters

  • Optionaloptions: { rollMode?: string | null; token?: any }

    Additional options

    • OptionalrollMode?: string | null

      The roll mode to use for the roll; defaults to the user's current preference when null.

    • Optionaltoken?: any

      Relevant token if any.

  Returns Promise<any>

  • Created message

  Throws

getCR

• getCR(options?: object): number
  Internal

  Get challenge rating. Applies CR offset modifications from templates.

  Parameters

  • Optionaloptions: object

    Additional options

  Returns number

  • CR

  Deprecated

getDefenses

• getDefenses(): void | Defenses

  Get Defenses

  Calls this.system.getDefenses().

  Returns void | Defenses

  • Collected defense data

getItemByTag

• getItemByTag(tag: string): any

  Get item by its identifier tag.

  Parameters

  • tag: string

    Desired tag.

  Returns any

  • Matching item or undefined if no item is found.

hasCondition

• hasCondition(conditionId: string): boolean

  Easy way to determine whether this actor has a condition.

  Parameters

  • conditionId: string

    A direct condition key, as per pf1.registry.conditions, such as shaken or dazed.

  Returns boolean

  Condition state

  Example

  Test if user is grappled

  actor.hasCondition("grappled");
  Copy

  Deprecated

  This is identical to actor.statuses.has("conditionId")

performRest

• performRest(options?: Partial<ActorRestOptions>): Promise<void | ActorRestData>

  Perform all changes related to an actor resting, including restoring HP, ability scores, item uses, etc.

  Parameters

  • options: Partial<ActorRestOptions> = {}

    Options affecting an actor's resting

  Returns Promise<void | ActorRestData>

  Updates applied to the actor, if resting was completed

  Example

  Rest with default settings

  await actor.performRest();
  Copy

  Remarks

  • Calls system.onRestUpdate, resetSpellbookUsage and rechargeItems to perform actual modifications functions.

  Hooks

  • pf1PreActorRest - Called just before committing changes.
  • pf1ActorRest - Called after the changes have been committed.

  See

  • pf1PreActorRest hook
  • pf1ActorRest hook

rechargeItems

• rechargeItems(options?: RechargeActorItemsOptions): Promise<any[] | object[]>

  Recharge all owned items.

  Parameters

  • Optionaloptions: RechargeActorItemsOptions = {}

    Additional options

  Returns Promise<any[] | object[]>

  • Result of an update or the update data.

  See

  pf1.documents.item.ItemPF.recharge

  Example

  Recharge items with default settings.

  await actor.rechargeItems();
  Copy

  Recharge items as if week had passed.

  await actor.rechargeItems({ period: "week" });
  Copy

resetSpellbookUsage

• resetSpellbookUsage(
      options?: { commit?: boolean; rollData?: object },
  ): Promise<object | ActorPF<Model>>

  Restore spellbook used slots and spellpoints.

  Parameters

  • Optionaloptions: { commit?: boolean; rollData?: object } = {}

    Additional options

    • Optionalcommit?: boolean

      If false, return update data object instead of directly updating the actor.

    • OptionalrollData?: object

      Roll data

  Returns Promise<object | ActorPF<Model>>

  Result of update or the update data.

  Deprecated

rollAbilityTest

• rollAbilityTest(
      abilityId: "str" | "dex" | "con" | "int" | "wis" | "cha",
      options?: ActorRollOptions,
  ): Promise<any>

  Roll an Ability Test Prompt the user for input regarding Advantage/Disadvantage and any Situational Bonus

  Parameters

  • abilityId: "str" | "dex" | "con" | "int" | "wis" | "cha"

    The ability ID (e.g. "str")

  • Optionaloptions: ActorRollOptions = {}

    Additional options

  Returns Promise<any>

  The chat message if one was created, or its data if not. void if the roll was cancelled.

  Example

  await actor.rollAbilityTest("str");
  Copy

rollAttack

• rollAttack(options?: ActorRollOptions): Promise<any>

  Roll a generic attack

  Parameters

  • Optionaloptions: ActorRollOptions = {}

    Roll options

    • Optionalaction?: string

      The selected sub-action depending on the context.

    • Optionalbonus?: string

      Bonus to the roll.

    • OptionalchatMessage?: boolean

      Whether a chat message should be created.

      Default Value

      true

    • Optionaldc?: number

      DC threshold

    • Optionaldice?: string

      The roll's d20 die (replacement), or the static result the d20 should have.

      Default Value

      "1d20"

    • OptionalformData?: PromptFormData

      Dialog form data from external source

    • Optionalitem?: any

      Associated item

    • Optionalmaneuver?: string | boolean | null

      Whether this is a maneuver and its id.

    • OptionalmessageData?: object

      Additional data to add to the chat message.

    • OptionalnoSound?: boolean

      Whether no dice sound should be played when the chat message is created.

      Default Value

      false

    • OptionalrollMode?: string

      The rollMode with which the chat message is created.

      Default Value

      game.settings.get("core", "rollMode")

    • OptionalskipDialog?: boolean

      Whether a user facing dialog should be shown.

      Default Value

      true

    • Optionalsl?: number

      Spell level

    • OptionalstaticRoll?: number

      A number used as a static roll result of the d20. If null, the d20 is rolled normally and the result is used.

      Default Value

      undefined

    • Optionaltoken?: any

      Associated token if any.

  Returns Promise<any>

  The chat message if one was created, or its data if not. void if the roll was cancelled.

  Example

  Basic ranged attack

  await actor.rollAttack({ ranged: true });
  Copy

  Basic melee maneuver

  await actor.rollAttack({ maneuver: true });
  Copy

rollBAB

• rollBAB(options?: ActorRollOptions): Promise<any>

  Roll basic BAB check

  Parameters

  • Optionaloptions: ActorRollOptions = {}

    Additional options

  Returns Promise<any>

  The chat message if one was created, or its data if not. void if the roll was cancelled.

  Todo

  Move most functionality to datamodels

rollCL

• rollCL(bookId: string, options?: ActorRollOptions): Promise<any>

  Roll a Caster Level check using a particular spellbook of this actor

  Parameters

  • bookId: string

    Spellbook identifier

  • Optionaloptions: ActorRollOptions = {}

    Roll options

  Returns Promise<any>

  The chat message if one was created, or its data if not. void if the roll was cancelled.

  Example

  Roll caster level check for primary spellbook.

  await actor.rollCL("primary");
  Copy

  Todo

  Move most functionality to datamodels

rollConcentration

• rollConcentration(bookId: string, options?: ActorRollOptions): Promise<any>

  Roll a concentration check using a particular spellbook of this actor

  Parameters

  • bookId: string

    Spellbook identifier

  • Optionaloptions: ActorRollOptions = {}

    Roll options

  Returns Promise<any>

  The chat message if one was created, or its data if not. void if the roll was cancelled.

  Todo

  Add support for concentration check type, e.g. defensive casting

  Todo

  Move most functionality to datamodels

rollSavingThrow

• rollSavingThrow(
      saveId: "fort" | "ref" | "will",
      options?: ActorRollOptions,
  ): Promise<any>

  Roll a specific saving throw

  Parameters

  • saveId: "fort" | "ref" | "will"

    Identifier for saving throw type.

  • Optionaloptions: ActorRollOptions = {}

    Roll options.

  Returns Promise<any>

  The chat message if one was created, or its data if not. void if the roll was cancelled.

  Example

  await actor.rollSavingThrow("ref", { skipDialog: true, dice: "2d20kh", bonus: "4" });
  Copy

  Deprecated

setCondition

• setCondition(
      conditionId: string,
      enabled: boolean | object,
      context?: object,
  ): Promise<object>

  Easy way to set a condition.

  Parameters

  • conditionId: string

    A direct condition key, as per pf1.registry.conditions, such as shaken or dazed.

  • enabled: boolean | object

    Whether to enable (true) the condition, or disable (false) it. Or object for merging into the active effect as part of enabling.

  • Optionalcontext: object

    Update context

  Returns Promise<object>

  Condition ID to boolean mapping of actual updates.

  Example

  Enable Dazzled

  await actor.setCondition("dazzled", true);
  Copy

  Enable Sleep for 10 rounds

  await actor.setCondition("sleep", { duration: { seconds: 60 } });
  Copy

setConditions

• setConditions(conditions?: object, context?: object): Record<string, boolean>

  Set state of multiple conditions. Also handles condition tracks to minimize number of updates.

  Parameters

  • conditions: object = {}

    Condition ID to boolean (or update data) mapping of new condition states. See ()

  • Optionalcontext: object = {}

    Update context

  Returns Record<string, boolean>

  Condition ID to boolean mapping of actual updates.

  Example

  Enable Blinded and Shaken conditions but disable Sleeping

  await actor.setConditions({ blind: true, sleep: false, shaken:true });
  Copy

  Enable Deafened with UI notification if immune

  await actor.setConditions({ deaf: true }, { pf1: { interactive: true } });
  Copy

  Remarks

  • If the interactive flag is not set, UI noise is reduced to avoid out of context notifications.

toggleCondition

• toggleCondition(
      conditionId: boolean,
      aeData?: object,
      context?: object,
  ): Promise<object>

  Easy way to toggle a condition.

  Parameters

  • conditionId: boolean

    A direct condition key, as per pf1.registry.conditions, such as shaken or dazed.

  • OptionalaeData: object

    Extra data to add to the AE if it's being enabled

  • Optionalcontext: object

    Additional context options to pass to ()

  Returns Promise<object>

  Condition ID to boolean mapping of actual updates.

  Example

  Toggle Dazzled

  await actor.toggleCondition("dazzled");
  Copy

  Toggle Blinded, set duration for 3 rounds if it's being enabled.

  await actor.toggleCondition("blinded", { duration: { seconds: 18 } });
  Copy

StaticapplyDamage

• applyDamage(
      value?: number,
      options?: TargetedApplyDamageOptions,
  ): Promise<false | any[]>

  Apply damage to the token or tokens which are currently controlled.

  If Shift is held, will prompt for adjustments based on damage reduction and energy resistances.

  Parameters

  • value: number = 0

    The amount of damage to deal. Negative values heal instead.

  • Optionaloptions: TargetedApplyDamageOptions = {}

    Object containing default settings for overriding

  Returns Promise<false | any[]>

  • False if cancelled or array of updated actors.

  Throws

  • If no valid targets are provided.