Class ActorPF

_rollData

classes

_spellbookTargets

• get _spellbookTargets(): string[]
  Internal

  Change target paths for spellbooks on the actor.

  Returns string[]

allNotes

• get allNotes(): { item: ItemPF; notes: ContextNote[] }[]

  An array of all context note data for this actor.

  Returns { item: ItemPF; notes: ContextNote[] }[]

allSkills

• get allSkills(): string[]

  All skill IDs relevant to this actor

  Returns string[]

race

• get race(): null | ItemRacePF

  Actor's current race item.

  Returns null | ItemRacePF

spellFailure

• get spellFailure(): number

  Spell Failure Percentage as number from 0 to 100.

  Returns number

visionSharingSheet

• get visionSharingSheet(): VisionSharingSheet

  The VisionSharingSheet instance for this actor

  Returns VisionSharingSheet

_applyArmorPenalties

• _applyArmorPenalties(): MobilityPenaltyResult
  Internal

  Computes armor penalties for this actor.

  Returns MobilityPenaltyResult

  The resulting penalties from armor.

_cleanItemLinksTo

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

  Parameters

  • items: ItemPF[]

    Item documents to clean links to.

  Returns Promise<Document[]>

  • Updated documents

_configure

• _configure(options?: object): void

  Configure actor before data preparation.

  Parameters

  • options: object = {}

    Document options

  Returns void

_getContextConditions

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

  Get active conditions marked for context

  Parameters

  • context: string

    Context ID

  Returns model[]

  • Array of conditions

_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

_onUpdate

• _onUpdate(changed: object, context: object, userId: string): void

  Parameters

  • changed: object

    Changed data

  • context: object

    Context

  • userId: string

    User ID

  Returns void

_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(sizeKey?: string): Promise<null | TokenDocument[]>
  Internal

  Resize token sizes based on actor size.

  Ignores tokens with static size set.

  Parameters

  • OptionalsizeKey: string

    Size key to update to. If not provided, will use actor's current size.

  Returns Promise<null | TokenDocument[]>

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

  Todo

  Add option to update token size on all scenes.

  Throws

  • On invalid parameters

addTempHP

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

  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<undefined | ActorPF>

  • 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<false | Actor<"base" | ModuleSubType>>

  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<false | Actor<"base" | ModuleSubType>>

  • 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

convertCurrency

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

  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 undefined | Promise<ActorPF>

  Updated document or undefined if no update occurred.

  See

  pf1.utils.currency.convert

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>

  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>

  • Promise to updated document

  Example

  Create spellbook for inquisitor

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

displayDefenseCard

• displayDefenseCard(
      options?: { rollMode?: null | string; token?: TokenDocument },
  ): Promise<undefined | ChatMessage<"base" | ModuleSubType>>

  Show defenses in chat

  Parameters

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

    Additional options

    • OptionalrollMode?: null | string

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

    • Optionaltoken?: TokenDocument

      Relevant token if any.

  Returns Promise<undefined | ChatMessage<"base" | ModuleSubType>>

  • Created message

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>

getCarriedWeight

• getCarriedWeight(): number

  Determines carried weight.

  Returns number

  • kg or lbs of all carried things, including currency

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.

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.

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.

AbstractgetLevelExp

• getLevelExp(level: number): number

  Return the amount of experience required to gain a certain character level.

  Parameters

  • level: number

    The desired level

  Returns number

  • The XP required

getRollData

• getRollData(options?: { cache?: boolean; refresh?: boolean }): object

  Retrieve data used to fill in roll variables.

  Parameters

  • Optionaloptions: { cache?: boolean; refresh?: boolean } = ...

    Additional options

    • Optionalcache?: boolean

      Use cache. If set to false, new fresh copy is returned without caching it.

    • Optionalrefresh?: boolean

      Refresh cache

  Returns object

  • Roll data object

  Example

  await new Roll("1d20 + @abilities.wis.mod[Wis]", actor.getRollData()).toMessage();
  Copy

getSkillInfo

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

  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 null | SkillInfo

  • 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

getTokenDocument

• getTokenDocument(data?: object, options?: object): Promise<TokenDocumentPF>

  Create a new Token document, not yet saved to the database, which represents the Actor, and apply actor size to it.

  Parameters

  • Optionaldata: object = {}

    Additional data, such as x, y, rotation, etc. for the created token data

  • Optionaloptions: object = {}

    The options passed to the TokenDocument constructor

  Returns Promise<TokenDocumentPF>

  The created TokenDocument instance

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.

hasArmorProficiency

• hasArmorProficiency(item: ItemEquipmentPF): boolean

  Checks if there's any matching proficiency

  Parameters

  • item: ItemEquipmentPF

    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, options?: { override?: boolean }): boolean

  Test if actor is proficient with specified weapon.

  Parameters

  • item: ItemPF

    Item to test

  • Optionaloptions: { override?: boolean }

    Additional options

    • Optionaloverride?: boolean

      Allow item's proficiency override to influence the result.

  Returns boolean

  • Proficiency state

  Remarks

  Natural attacks incorrectly do not count as proficient.

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.

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

prepareDerivedData

• prepareDerivedData(): void

  Augment the basic actor data with additional dynamic data.

  Returns void

prepareItemLinks

• prepareItemLinks(): void
  Internal

  Returns void

rechargeItems

• rechargeItems(
      options?: RechargeActorItemsOptions,
  ): Promise<object[] | Item<"base" | ModuleSubType>[]>

  Recharge all owned items.

  Parameters

  • Optionaloptions: RechargeActorItemsOptions = {}

    Additional options

  Returns Promise<object[] | Item<"base" | ModuleSubType>[]>

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

  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>

  Result of update or the update data.

  Deprecated

rollAbilityTest

• rollAbilityTest(
      abilityId: "str" | "dex" | "con" | "int" | "wis" | "cha",
      options?: ActorRollOptions,
  ): Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  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<void | object | ChatMessage<"base" | ModuleSubType>>

  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<void | object | ChatMessage<"base" | ModuleSubType>>

  Roll a generic attack

  Parameters

  • Optionaloptions: ActorRollOptions = {}

    Roll options

    • Optionalaction?: string

      The selected sub-action depending on the context.

    • Optionalactions?: SubAction[]

      The sub-actions to show in the dialog (dependant 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"

    • Optionalitem?: Item<"base" | ModuleSubType>

      Associated item

    • Optionalmaneuver?: null | string | boolean

      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?: TokenDocument

      Associated token if any.

  Returns Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  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<void | object | ChatMessage<"base" | ModuleSubType>>

  Roll basic BAB check

  Parameters

  • Optionaloptions: ActorRollOptions = {}

    Additional options

  Returns Promise<void | object | ChatMessage<"base" | ModuleSubType>>

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

rollCL

• rollCL(
      bookId: string,
      options?: ActorRollOptions,
  ): Promise<void | object | ChatMessage<"base" | ModuleSubType>>

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

  Parameters

  • bookId: string

    Spellbook identifier

  • Optionaloptions: ActorRollOptions = {}

    Roll options

  Returns Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  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

rollConcentration

• rollConcentration(
      bookId: string,
      options?: ActorRollOptions,
  ): Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  Roll a concentration check using a particular spellbook of this actor

  Parameters

  • bookId: string

    Spellbook identifier

  • Optionaloptions: ActorRollOptions = {}

    Roll options

  Returns Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  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

rollInitiative

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

  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?: null | string;
        createCombatants?: boolean;
        dice?: null | string;
        initiativeOptions?: object;
        rerollInitiative?: boolean;
        rollMode?: string;
        skipDialog?: boolean;
        token?: TokenDocumentPF;
    } = {}

    Options which configure how initiative is rolled

    • Optionalbonus?: null | string

      Formula for bonus to initiative

    • OptionalcreateCombatants?: boolean

      Create new Combatant entries for tokens associated with this actor.

    • Optionaldice?: null | string

      Formula override for dice to roll

    • OptionalinitiativeOptions?: object

      Options to pass to ()

    • 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<null | CombatPF>

  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

rollSavingThrow

• rollSavingThrow(
      savingThrowId: "fort" | "ref" | "will",
      options?: ActorRollOptions,
  ): Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  Roll a specific saving throw

  Parameters

  • savingThrowId: "fort" | "ref" | "will"

    Identifier for saving throw type.

  • Optionaloptions: ActorRollOptions = {}

    Roll options.

  Returns Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  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

rollSkill

• rollSkill(
      skillId: string,
      options?: ActorRollOptions,
  ): Promise<void | object | ChatMessage<"base" | ModuleSubType>>

  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<void | object | ChatMessage<"base" | ModuleSubType>>

  • 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

updateItemResources

• updateItemResources(
      item: ItemPF,
      options?: { warnOnDuplicate?: boolean },
  ): boolean
  Internal

  Parameters

  • item: ItemPF

    the item to add to the actor's resources

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

    extra options

    • OptionalwarnOnDuplicate?: boolean

      Skips warning if item tag already exists in dictionary flags

  Returns boolean

  True if resources were set

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

Static_getSourceLabel

• _getSourceLabel(src: SourceInfo): string
  Internal

  Parameters

  • src: SourceInfo

    Source info

  Returns string

  • Label for source

StaticapplyDamage

• applyDamage(
      value?: number,
      options?: TargetedApplyDamageOptions,
  ): Promise<false | Actor<"base" | ModuleSubType>[]>

  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 | Actor<"base" | ModuleSubType>[]>

  • False if cancelled or array of updated actors.

  Throws

  • If no valid targets are provided.

StaticgetReach

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

  Get melee and reach maximum ranges.

  Parameters

  • size: number | "dim" | "med" | "fine" | "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

StaticgetReducedMovementSpeed

• getReducedMovementSpeed(value: number): number

  Return 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

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