Class ActorBasePF

changeFlags

changeOverrides

changes

itemFlags

sourceInfo

Abstract_skillTargets

• get _skillTargets(): string[]

  Retrieve valid skill change targets for this actor.

  Returns string[]

  • Skill target array

activeOwner

• get activeOwner(): null | User

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

  Returns null | User

allItems

• get allItems(): ItemPF[]

  Returns ItemPF[]

  All items on this actor, including those in containers.

containerItems

• get containerItems(): ItemPF[]
  Internal

  All items this actor is holding in containers.

  Returns ItemPF[]

itemTypes

• get itemTypes(): ItemTypesMap

  Cached override

  Returns ItemTypesMap

sharesVision

• get sharesVision(): boolean

  Whether current user can see through this actor.

  Returns boolean

_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.

_configure

• _configure(options?: object): void

  Configure actor before data preparation.

  Parameters

  • options: object = {}

    Document options

  Returns void

_handleConditionTracks

• _handleConditionTracks(
      documents: ActiveEffect<"base" | ModuleSubType>[],
  ): Promise<object>
  Internal

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

  Parameters

  • documents: ActiveEffect<"base" | ModuleSubType>[]

    Updated active effect documents

  Returns Promise<object>

  • Result from ActorPF.setConditions

_initialize

• _initialize(options: any): void

  Parameters

  • options: any

  Returns void

_onCreateDescendantDocuments

• _onCreateDescendantDocuments(
      parent: Actor<"base" | ModuleSubType> | Item<"base" | ModuleSubType>,
      collection: "items" | "effects",
      documents:
          | ActiveEffect<"base" | ModuleSubType>[]
          | Item<"base" | ModuleSubType>[],
      result: object[],
      context: object,
      userId: string,
      ...args: any,
  ): void
  Internal

  Parameters

  • parent: Actor<"base" | ModuleSubType> | Item<"base" | ModuleSubType>

    Parent document

  • collection: "items" | "effects"

    Collection name

  • documents: ActiveEffect<"base" | ModuleSubType>[] | Item<"base" | ModuleSubType>[]

    Created documents

  • result: object[]

    Creation data for the documents

  • context: object

    Create context options

  • userId: string

    Triggering user's ID

  • ...args: any

  Returns void

_onDeleteDescendantDocuments

• _onDeleteDescendantDocuments(
      parent: any,
      collection: "items" | "effects",
      documents:
          | Item<"base" | ModuleSubType>
          | ActiveEffect<"base" | ModuleSubType>[],
      ids: string[],
      context: object,
      userId: string,
  ): void
  Internal

  Parameters

  • parent: any

    Parent document

  • collection: "items" | "effects"

    Collection name

  • documents: Item<"base" | ModuleSubType> | ActiveEffect<"base" | ModuleSubType>[]

    Document array

  • ids: string[]

    Document ID array

  • context: object

    Delete context

  • userId: string

    User ID

  Returns void

_prepareChangeFlags

• _prepareChangeFlags(): void

  Returns void

_prepareChanges

• _prepareChanges(): void
  Internal

  Prepare changes and changeOverrides

  Returns void

Abstract_prepareCombatManeuvers

• _prepareCombatManeuvers(): void

  Prepare combat maneuvers derived data.

  Returns void

applyActiveEffects

• applyActiveEffects(): void
  Internal

  Returns void

expireActiveEffects

• expireActiveEffects(
      options?: {
          combat?: Combat<"base" | ModuleSubType>;
          event?: string;
          initiative?: number;
          timeOffset?: number;
          worldTime?: number;
      },
      context?: any,
  ): Promise<void>

  Deletes expired temporary active effects and disables linked expired buffs.

  Parameters

  • Optionaloptions: {
        combat?: Combat<"base" | ModuleSubType>;
        event?: string;
        initiative?: number;
        timeOffset?: number;
        worldTime?: number;
    } = {}

    Additional options

    • Optionalcombat?: Combat<"base" | ModuleSubType>

      Combat to expire data in, if relevant

    • Optionalevent?: string

      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 Promise<void>

  Throws

  • With insufficient permissions to control the actor.

getCombatants

• getCombatants(
      combat?: Combat<"base" | ModuleSubType>,
  ): Combatant<"base" | ModuleSubType>[]

  Get related combatants.

  Parameters

  • Optionalcombat: Combat<"base" | ModuleSubType> = game.combat

    Combat instance

  Returns Combatant<"base" | ModuleSubType>[]

  Related combatants.

getConditionImmunities

• getConditionImmunities(): Set<string>
  Internal

  Condition immunities

  Returns Set<string>

  • Set of immunity IDs.

AbstractgetDefenses

• getDefenses(): void | Defenses

  Get Defenses

  Calls this.system.getDefenses() if not overridden by the document.

  Returns void | Defenses

  • Collected defense data

AbstractgetInitiativeOptions

• getInitiativeOptions(): object

  Per-actor type initiative options

  Returns object

  • Options object

getItemByTag

• getItemByTag(tag: string): undefined | Item<"base" | ModuleSubType>

  Get item by its identifier tag.

  Parameters

  • tag: string

    Desired tag.

  Returns undefined | Item<"base" | ModuleSubType>

  • Matching item or undefined if no item is found.

AbstractgetMovement

• getMovement(type: MovementType): undefined | MovementInfo

  Movement details for current movement

  Parameters

  • type: MovementType

  Returns undefined | MovementInfo

getRollData

• getRollData(options: any): any

  Parameters

  • options: any

  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

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")

prepareBaseData

• prepareBaseData(): void

  Prepare data related to this Document itself, before any embedded Documents or derived data is computed.

  Returns void

AbstractrefreshDerivedData

• 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

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

toggleStatusEffect

• toggleStatusEffect(
      statusId: string,
      options?: { active?: boolean; interaction?: boolean; overlay?: boolean },
  ): Promise<undefined | boolean | ActiveEffect<"base" | ModuleSubType>>

  Override to support toggling buffs and operating the system's condition tracks

  Called by TokenHUD

  Parameters

  • statusId: string

    Status/condition ID

  • Optionaloptions: { active?: boolean; interaction?: boolean; overlay?: boolean } = {}

    Additional options

    • Optionalactive?: boolean

      Force active state

    • Optionalinteraction?: boolean

      Nonstandard. Is this triggered by user interaction?

    • Optionaloverlay?: boolean

      Overlay effect

  Returns Promise<undefined | boolean | ActiveEffect<"base" | ModuleSubType>>

  Synced with Foundry v13.342

  Todo

  Add separate listener for buffs

StaticgetDefaultArtwork

• getDefaultArtwork(actorData?: object): object
  Internal

  Add default artwork.

  Parameters

  • OptionalactorData: object

    Actor data to guide creation if any

  Returns object

  • Resulting data alterations

  See

  pf1.config.defaultIcons.actors