Foundry VTT Development

https://foundryvtt.wiki/en/development
Admin
This documentation provides guides and best practices for developing packages, modules, and...
Tokens:229,802
Snippets:1,696
Trust Score:8.2
Update:1 week ago
Show doc for...
Tokens:
Raw
### Create foundry-config.yaml with install path

Source: https://foundryvtt.wiki/en/development/guides/improving-intellisense

Create a foundry-config.yaml file containing the full path to your Foundry install. This example is from a Windows device and is gitignored because the path differs per device.

```yaml
installPath: "C:\\Program Files\\Foundry Virtual Tabletop\\Version 13"
```

--------------------------------

### Example FormApplication

Source: https://foundryvtt.wiki/en/development/guides/converting-to-appv2

This is the example FormApplication used throughout the guide. It demonstrates a typical FormApplication with default options, getData, activateListeners, and _updateObject methods.

```javascript
class TemplateApplication extends FormApplication {
    static get defaultOptions() {
        return foundry.utils.mergeObject(super.defaultOptions, {
            id: "foo-form",
            title: `My Module: ${game.i18n.localize("FOO.form.title")}`,
            template: "./modules/foo/templates/form.hbs",
            classes: ["form"],
            width: 640,
            height: "auto",
            closeOnSubmit: true,
        });
    }

    getData() {
        const setting = game.settings.get("foo", "config");
        return {
          setting
        }
    }

    async activateListeners(html) {
        super.activateListeners(html);
        html.find("input[name=something]").on("click", /* ... */);
        html.find("button[name=reset]").on("click", async (event) => {
          await game.settings.set("foo", "config", {});
        });
    }

  async _updateObject(event, formData) {
    await Promise.all(
      Object.entries(formData)
        .map(([key, value]) => game.settings.set("foo", key, value));
    );
  }
}
```

--------------------------------

### Start Tour with Timeout

Source: https://foundryvtt.wiki/en/development/guides/tours

Suggests using a timeout when opening a window like client-settings before starting the tour. The tour start is delayed by 1000 milliseconds.

```javascript
setTimeout(function(){
  game.tours.get("myModuleName.tourName").start();
}, 1000);
```

--------------------------------

### template.json example with Actor types and templates

Source: https://foundryvtt.wiki/en/development/api/DataModel

Shows the classic template.json structure with Actor types (hero, pawn, villain) and shared templates (background, resources). This is the starting point for migration.

```json
{
  "Actor": {
    "types": ["hero", "pawn", "villain"],
    "templates": {
      "background": {
        "biography": "",
        "hairColor": "blue"
      },
      "resources": {
        "health": {
          "min": 0,
          "value": 10,
          "max": 10
        },
        "power": {
          "min": 0,
          "value": 1,
          "max": 3
        }
      }
    },
    "hero": {
      "templates": ["background", "resources"],
      "goodness": {
        "value": 5,
        "max": 10
      }
    },
    "pawn": {
      "templates": ["resources"]
    },
    "villain": {
      "templates": ["background", "resources"],
      "wickedness": {
        "value": 5,
        "max": 100
      }
    }
  }
}
```

--------------------------------

### Example 1: Grouping related keys in a system (dnd5e skills)

Source: https://foundryvtt.wiki/en/development/guides/localization/localization-best-practices

Shows how to group related localization keys together in a system's localization file, using the dnd5e skill lineup as an example.

```json
"DND5E.SkillAcr": "...",
"DND5E.SkillAni": "...",
"DND5E.SkillArc": "...",
"DND5E.SkillAth": "...",
"DND5E.SkillDec": "...",
"DND5E.SkillHis": "...",
```

--------------------------------

### Start Tour on First Login

Source: https://foundryvtt.wiki/en/development/guides/tours

Starts a tour once the module is activated and players log in, if the tour status is 'unstarted'. The status can be checked and the tour started. The comment lists possible statuses: unstarted, in-progress, completed.

```javascript
Hooks.once("ready", async function () {
    if(game.tours.get("myModuleName.tourName").status == "unstarted") // {"unstarted", "in-progress", "completed"}
  {
    game.tours.get("myModuleName.tourName").start();
  }
});
```

--------------------------------

### V2 ApplicationV2 Pattern (Manual Setup Required)

Source: https://foundryvtt.wiki/en/development/guides/applicationV2-conversion-guide

Complete manual drag/drop setup for ApplicationV2, including creating DragDrop instances, binding them in _onRender, and defining permission and callback handlers.

```javascript
const { DragDrop } = foundry.applications.ux

class MyAppV2 extends HandlebarsApplicationMixin(ApplicationV2) {
  #dragDrop

  static DEFAULT_OPTIONS = {
    dragDrop: [{
      dragSelector: '[data-drag="true"]',
      dropSelector: '.drop-zone'
    }]
  }

  constructor(options = {}) {
    super(options)
    this.#dragDrop = this.#createDragDropHandlers()
  }

  #createDragDropHandlers() {
    return this.options.dragDrop.map((d) => {
      d.permissions = {
        dragstart: this._canDragStart.bind(this),
        drop: this._canDragDrop.bind(this)
      }
      d.callbacks = {
        dragstart: this._onDragStart.bind(this),
        dragover: this._onDragOver.bind(this),
        drop: this._onDrop.bind(this)
      }
      return new DragDrop(d)
    })
  }

  _onRender(context, options) {
    this.#dragDrop.forEach((d) => d.bind(this.element))
  }

  _canDragStart(selector) {
    return this.document.isOwner && this.isEditable
  }

  _canDragDrop(selector) {
    return this.document.isOwner && this.isEditable
  }

  _onDragOver(event) {
    // Optional: handle dragover events if needed
  }
}
```

--------------------------------

### Instantiate helper class and emit event

Source: https://foundryvtt.wiki/en/development/api/sockets

Instantiates the helper class during the 'init' hook and shows how to emit events. The example uses 'game.modules.get("my-module")' to get the module, but the emit call uses 'game.modules.get("myPackage")' which may be a typo.

```javascript
Hooks.once("init", () => {
  const myPackage = game.modules.get("my-module") // or just game.system if you're a system
  myPackage.socketHandler = new MyPackageSocketHandler()
});

// Emitting events works like this
game.modules.get("myPackage").socketHandler.emit("ACTION", "foo")
```

--------------------------------

### Start Vite dev server

Source: https://foundryvtt.wiki/en/development/guides/vite

Start the Vite development server after starting Foundry. The output shows the server running at `http://localhost:30001/systems/lancer/` and notes that `--host` can be used to expose it on the network.

```bash
$ npx vite serve

  vite v2.5.0 dev server running at:

  > Local: http://localhost:30001/systems/lancer/
  > Network: use `--host` to expose

  ready in 205ms.
```

--------------------------------

### Get a setting value with game.settings.get

Source: https://foundryvtt.wiki/en/development/guides/handling-data

Reads a setting value. The example logs the value, expected to be 'foo'.

```javascript
const someVariable = game.settings.get('myModuleId','myModuleSetting');
console.log(someVariable); // expected to be 'foo'
```

--------------------------------

### Hooks.on('renderCompendium', callback) - Placeholder example

Source: https://foundryvtt.wiki/en/development/guides/Hooks_Listening_Calling

Example of registering a hook callback for the 'renderCompendium' event. The comment indicates a TODO to add a real world, working example.

```javascript
Hooks.on("renderCompendium", (compendiumApp, html, appData) => {
//TODO: add real world, working example
});
```

--------------------------------

### Hooks.callAll() examples

Source: https://foundryvtt.wiki/en/development/guides/Hooks_Listening_Calling

Examples of Hooks.callAll() calls for various hook events, including initialization, document creation/update/delete, and UI interactions.

```javascript
Hooks.callAll("updateWorldTime", worldTime, dt)
Hooks.callAll("init")
Hooks.callAll('setup')
Hooks.callAll("ready")
Hooks.callAll("pauseGame", this.data.paused)
Hooks.callAll(`create${type}`, doc, options, userId)
Hooks.callAll(`update${doc.documentName}`, doc, change, options, userId)
Hooks.callAll(`delete${doc.documentName}`, doc, options, userId)
Hooks.callAll("updateCompendium", this, documents, options, userId)
Hooks.callAll(`preCreate${embeddedName}`, doc, d, options, user.id)
Hooks.callAll(`preUpdate${embeddedName}`, doc, d, options, user.id)
Hooks.callAll(`preDelete${embeddedName}`, doc, options, user.id)
Hooks.callAll("preUpdateActor", this.actor, data, options, user.id)
Hooks.callAll(`create${embeddedName}`, doc, options, userId)
Hooks.callAll(`update${embeddedName}`, doc, d, options, userId)
Hooks.callAll(`delete${embeddedName}`, doc, options, userId)
Hooks.callAll("updateActor", this.actor, data, options, userId)
Hooks.callAll('canvasInit', this)
Hooks.callAll("canvasPan", this, constrained)
Hooks.callAll("canvasPan", this, {x: stage.pivot.x, y: stage.pivot.y, scale: stage.scale.x})
Hooks.callAll("control"+this.constructor.embeddedName, this, this._controlled)
Hooks.callAll("control"+this.constructor.embeddedName, this, this._controlled)
Hooks.callAll("hover"+this.constructor.embeddedName, this, this._hover)
Hooks.callAll("hover"+this.constructor.embeddedName, this, this._hover)
Hooks.callAll("collapseSidebar", this, this._collapsed)
Hooks.callAll("collapseSidebar", this, this._collapsed)
Hooks.callAll("changeSidebarTab", app)
Hooks.callAll(`getSceneControlButtons`, controls)
Hooks.callAll("collapseSceneNavigation", this, this._collapsed)
Hooks.callAll("collapseSceneNavigation", this, this._collapsed)
Hooks.callAll("initializePointSourceShaders", this, this.animation.type)
Hooks.callAll("targetToken", this.user, token, targeted)
Hooks.callAll("lightingRefresh", this)
Hooks.callAll("sightRefresh", this)
Hooks.callAll("rtcSettingsChanged", this, changed)
Hooks.callAll(`${key}Changed`, volume)
```

--------------------------------

### module.json example with version, manifest, and download

Source: https://foundryvtt.wiki/en/development/guides/gitlab-pipeline

Example module.json showing the version, manifest, and download fields. The version is used for the zip URL, release name, and tag. The manifest points to the module.json in the repo root, and the download points to the release asset.

```json
{
  "version": "1.0.0",
  "manifest": "https://Gitlab.com/my_account/my-module/-/raw/main/module.json",
  "download": "https://Gitlab.com/my_account/my-module/-/releases/v1.0.0/downloads/my-module-v1.0.0.zip",
}
```

--------------------------------

### Open the FormApplication

Source: https://foundryvtt.wiki/en/development/guides/understanding-form-applications

Creates an instance of MyFormApplication with an example option and renders it. This is the typical way to open the form.

```javascript
/**
 * To open your application
 */

new MyFormApplication('example').render(true);
```

--------------------------------

### GitLab Pipeline before_script to Install Dependencies

Source: https://foundryvtt.wiki/en/development/guides/gitlab-pipeline

Installs zip and git using apk in the before_script. This prepares the environment for packaging and release.

```yaml
before_script: |
    apk add --no-cache zip git
```

--------------------------------

### Tour Configuration with Selector Example

Source: https://foundryvtt.wiki/en/development/guides/tours

Example of a tour configuration object with a step using a button selector with data-action attribute. The selector targets an HTML button element with the parameter data-action="configure". The sidebarTab property is commented with allowed values.

```json
{
    "title": "Configuration Settings",
    "description": "Howto mark the Button Configuration Settings for Tours",
    "canBeResumed": false,
    "display": true,
    "steps": [
        {
            "id": "configSettings",
            "selector": "button[data-action=\"configure\"]", // html element "button" with [parameter] data-action="configure"
            "title": "Config Tour",
            "content": "MYTRANSLATION.tours.configSettings",
            "sidebarTab" "settings" // {"chat", "combat", "scenes", "actors", "items", "journal", "tables", "cards", "playlists", "compedium", "settings"}

        },
        {
            "id": "stepTwo",
          // ...
        }
    ]
}
```

--------------------------------

### Handlebars Partial Example

Source: https://foundryvtt.wiki/en/development/guides/SD-tutorial/SD08-Creating-HTML-templates-for-your-actor-sheets

Shows the syntax for including a Handlebars partial. The full path from the Foundry Data folder must be provided.

```handlebars
{{> "systems/boilerplate/templates/actor/parts/actor-features.hbs"}}
```

--------------------------------

### Hooks.callAll('ready') - Called when game is ready

Source: https://foundryvtt.wiki/en/development/guides/Hooks_Listening_Calling

Example of a Hooks.callAll() call with the 'ready' hook, triggered when the game is done initializing its data structure.

```javascript
Hooks.callAll("ready");
// called when the game is done initializing its data structure and is 'ready'
```

--------------------------------

### Example 2: Grouping setting names and hints in a module

Source: https://foundryvtt.wiki/en/development/guides/localization/localization-best-practices

Shows how to group setting names and hints together in a module's localization file so translators know what they are translating.

```json
"minor-qol.ItemDeleteCheck.Name": "...",
"minor-qol.ItemDeleteCheck.Hint": "...",
"minor-qol.DamageImmunities.Name": "...",
"minor-qol.DamageImmunities.Hint": "...",
"minor-qol.SpeedItemRolls.Name": "...",
"minor-qol.SpeedItemRolls.Hint": "...",
```

--------------------------------

### Playing a sound locally and for all clients

Source: https://foundryvtt.wiki/en/development/api/audio

Example showing how to play a sound for the current user using the instance method `game.audio.play`, and for all connected clients using the static method `game.audio.constructor.play`. The static method can also be called as `foundry.audio.AudioHelper.play`.

```javascript
const src = 'some/audio/path.wav'

// play locally
game.audio.play(src);

// play on all connected clients
game.audio.constructor.play({ src }, true);
```

--------------------------------

### Use a custom class as a setting type

Source: https://foundryvtt.wiki/en/development/api/settings

Uses a custom class as the setting type to perform advanced data manipulation during get. The constructor receives the parsed JSON value, and the example shows register, set, and get calls. Be aware of gotchas with the onChange callback when using complex types.

```javascript
class SomeClass {
  constructor(parsedJson) {
    this.merged = parsedJson?.foo + parsedJson?.bar;
    this.foo = parsedJson?.foo;
    this.bar = parsedJson?.bar;
  }
}

game.settings.register('myModuleName', 'customClassSetting', { type: SomeClass });

game.settings.set('myModuleName', 'customClassSetting', {foo: 'foosius', bar: 'whatever'});

game.settings.get('myModuleName', 'customClassSetting').merged; // 'foosiuswhatever'
```

--------------------------------

### Initialize world with setupWorld function using init and ready hooks

Source: https://foundryvtt.wiki/en/development/api/hooks

Registers a world-scoped setting 'setupWorld' during the init hook, then on ready checks if the world has been set up. If not and the active GM is self, calls setupWorld() which shows a warning notification, performs setup, sets the setting to true, and removes the notification.

```javascript
Hooks.once("init", () => {
  game.settings.register('mySystem', 'setupWorld', {
    name: 'Setup World',
    scope: 'world',
    config: false,
    type: Boolean,
    default: false
  })
});

Hooks.once("ready", () => {
  const isWorldSetup = game.settings.get("mySystem", "setupWorld");
  if (!isWorldSetup && game.users.activeGM?.isSelf) setupWorld()
})

async setupWorld() {
  const warning = ui.notifications.warn("Setting up world, please do not exit the program")
  // do stuff
  await game.settings.set("mySystem", "setupWorld", true)
  ui.notifications.remove(warning)
}
```

--------------------------------

### getDocuments query examples

Source: https://foundryvtt.wiki/en/development/api/CompendiumCollection

Examples of query parameters for CompendiumCollection#getDocuments. The query parameters are currently undocumented, but these client-side examples show filtering by type, IDs, and sub-types. If no query is passed, all documents are returned.

```javascript
// Get Documents that match the given value only.
await pack.getDocuments({ type: "weapon" });

// Get several Documents by their IDs.
await pack.getDocuments({ _id__in: arrayOfIds });

// Get Documents by their sub-types.
await pack.getDocuments({ type__in: ["weapon", "armor"] });
```

--------------------------------

### Use the 'ready' hook with Hooks.once

Source: https://foundryvtt.wiki/en/development/guides/SD-tutorial/SD05-Creating-your-main-JS-file

Use Hooks.once("ready", ...) to run code after Foundry has fully loaded and systems/modules have initialized. This is useful for steps that need to happen later in the process.

```javascript
/* -------------------------------------------- */
/*  Ready Hook                                  */
/* -------------------------------------------- */

Hooks.once("ready", function() {
  // Include steps that need to happen after Foundry has fully loaded here.
});
```

--------------------------------

### Choosing the right base class

Source: https://foundryvtt.wiki/en/development/guides/applicationV2-conversion-guide

Code examples showing how to extend each base class for different use cases: ActorSheetV2 for actor sheets, DocumentSheetV2 for item sheets, ApplicationV2 for configuration dialogs, and DialogV2 for user prompts.

```javascript
// For actor sheets - use ActorSheetV2
class MyActorSheet extends HandlebarsApplicationMixin(ActorSheetV2) {
  // Gets automatic drag/drop, actor-specific features
}

// For item sheets - use DocumentSheetV2
class MyItemSheet extends HandlebarsApplicationMixin(DocumentSheetV2) {
  // Gets document handling, no automatic drag/drop
}

// For configuration dialogs - use ApplicationV2
class MyConfigDialog extends HandlebarsApplicationMixin(ApplicationV2) {
  // Gets basic application features only
}

// For user prompts - use DialogV2
class MyPrompt extends DialogV2 {
  // Gets modal behavior, button handling
}
```

--------------------------------

### Example translation file with custom keys

Source: https://foundryvtt.wiki/en/development/guides/localization/localizing-tinymce

Example of adding custom keys 'Custom' and 'Secret' to the JSON array in the translation file. Note the comma after the last item in the JSON array (line 4 in the example).

```javascript
tinymce.addI18n('fi',{
...omitted data...
"Caption": "Seloste",
"Insert template": "Lis\u00e4\u00e4 pohja",
"Custom": "Mukautettu",
"Secret": "Salainen"
});
```

--------------------------------

### Hooks.call() with interruption examples

Source: https://foundryvtt.wiki/en/development/guides/Hooks_Listening_Calling

Examples of Hooks.call() calls that can be interrupted, including pre-create/update/delete hooks and various UI interactions.

```javascript
Hooks.call(`preCreate${type}`, doc, createData, options, user.id)
Hooks.call(`preUpdate${doc.documentName}`, doc, update, options, user.id)
Hooks.call(`preDelete${doc.documentName}`, doc, options, user.id)
Hooks.call("modifyTokenAttribute", {attribute, value, isDelta, isBar}, updates)
Hooks.call("dropCanvasData", this, data)
Hooks.call("dropActorSheetData", actor, this, data)
Hooks.call("dropRollTableSheetData", this.document, this, data)
Hooks.call("chatBubble", token, html, message, {emote})
Hooks.call("hotbarDrop", this, data, slot)
Hooks.call("chatMessage", this, message, chatData)
Hooks.call(`get${cls.name}EntryContext`, html, entryOptions)
Hooks.call(`get${cls.name}EntryContext`, html, entryOptions)
Hooks.call(`get${cls.name}SoundContext`, html, entryOptions)
```

--------------------------------

### Hooks.call() examples

Source: https://foundryvtt.wiki/en/development/guides/Hooks_Listening_Calling

Examples of Hooks.call() calls for various hook events, including rendering, context menus, and chat messages.

```javascript
Hooks.call(`render${cls.name}`, this, html, data)
Hooks.call(`get${cls.name}HeaderButtons`, this, buttons)
Hooks.call(`close${cls.name}`, this, el)
Hooks.call("applyActiveEffect", actor, change)
Hooks.call("renderChatMessage", this, html, messageData)
Hooks.call("canvasReady", this)
Hooks.call(`paste${cls.name}`, this._copy, toCreate)
Hooks.call(`get${cls.name}FolderContext`, html, folderOptions)
Hooks.call(`get${cls.name}EntryContext`, html, entryOptions)
Hooks.call("getSceneNavigationContext", html, contextOptions)
Hooks.call(`getUserContextOptions`, html, contextOptions)
Hooks.call(`get${cls.name}EntryContext`, html, entryOptions)
Hooks.call(`paste${cls.name}`, this._copy, toCreate)
```

--------------------------------

### Vite build output

Source: https://foundryvtt.wiki/en/development/guides/vite

Example output of running `npx vite build` for a Foundry VTT system. Shows the build process and the generated files in the dist folder.

```bash
$ npx vite build
vite v2.5.0 building for production...
✓ 963 modules transformed.
rendering chunks (9)...

dist/lancer.es.js     0.04 KiB / brotli: 0.05 KiB
dist/lancer.es.js.map 0.09 KiB
dist/aws-exports.js   0.92 KiB / brotli: 0.42 KiB
dist/aws-exports.js.map 2.32 KiB
dist/index.js         1.69 KiB / brotli: 0.70 KiB
dist/index.js.map     5.04 KiB
dist/marked.js        46.42 KiB / brotli: 12.97 KiB
dist/marked.js.map    137.94 KiB
dist/index4.js        52.08 KiB / brotli: 14.08 KiB
dist/index4.js.map    238.45 KiB
dist/Credentials.js   138.40 KiB / brotli: 29.90 KiB
dist/Credentials.js.map 968.75 KiB
dist/style.css        36.59 KiB / brotli: 7.38 KiB
dist/index2.js        144.89 KiB / brotli: 34.89 KiB
dist/index2.js.map    602.29 KiB
dist/index3.js        179.36 KiB / brotli: 33.85 KiB
dist/index3.js.map    1536.81 KiB
dist/lancer.js        1030.44 KiB / brotli: skipped (large chunk)
dist/lancer.js.map    1777.34 KiB
```

--------------------------------

### Register tours and handle pre-step (myTours.js)

Source: https://foundryvtt.wiki/en/development/guides/tours

Registers tours from JSON files, toggles the sidebar tab to 'chat' before targeting #chat, and runs code before entering a step. Only GMs get the 'settings' tour.

```javascript
Hooks.once("setup", async function () {
    registerMyTours();
}
// necessary to toggle tab from settings to chat before you are able to target #chat
Hooks.on("closeToursManagement", function (event) {
  ui.sidebar.activateTab("chat");
});
class MyTour extends Tour {
    async _preStep() {
      await super._preStep();
      const currentStep = this.currentStep;
      if(currentStep.id == "chat") {
        ChatMessage.create({
          content: "<h2>Demo MyTour</h2>",
          speaker: ChatMessage.getSpeaker({alias: "MyTour", color: "#ff0000"})
        });
      } else {
        console.log("MyTours | Tours _preStep: ",currentStep.id);
      }
    }
}
async function registerMyTours() {
  try {
    game.tours.register(moduleName, 'format', await MyTour.fromJSON('/modules/'+moduleName+'/tours/chat.json'));
    if(game.user.isGM) {
      game.tours.register(moduleName, 'settings', await MyTour.fromJSON('/modules/'+moduleName+'/tours/settings.json'));
    }
  } catch (error) {
    console.error("MyTour | Error registering tours: ",error);
  }
}
```

--------------------------------

### Install dependencies for the generator

Source: https://foundryvtt.wiki/en/development/guides/SD-tutorial/SD01-Getting-started

Installs the dependencies for the Boilerplate generator. Requires node.js version 20 or higher. Run from inside the boilerplate directory.

```bash
npm install
```

--------------------------------

### conflicts field example

Source: https://foundryvtt.wiki/en/development/manifest-plus

Example of the `conflicts` field in a Foundry VTT manifest. It is an array of objects with `name`, `type`, and optional `versionMin` and `versionMax` fields.

```json
"conflicts": [
  {
    "name": "module-name",
    "type": "module",
    "versionMin": "a.b.c",
    "versionMax": "a.c.d"
  }
]
```

--------------------------------

### deprecated field example

Source: https://foundryvtt.wiki/en/development/manifest-plus

Example of the `deprecated` field in a Foundry VTT manifest. It includes `coreVersion`, `reason`, and an array of `alternatives` objects with `name` and `manifest` URL.

```json
"deprecated": {
  "coreVersion": "0.7.0",
  "reason": "This was added to foundry core.",
  "alternatives": [
    {
      "name": "module-name",
      "manifest": "https://link.com/to/module.json"
    }
  ]
}
```

--------------------------------

### GitLab Pipeline Script Start - Set Release Variables

Source: https://foundryvtt.wiki/en/development/guides/gitlab-pipeline

Starts the main script section, generating the release file name and setting environment variables for the release.

```bash
script: |

  # Generate release file name.
  echo "[Info] Preparing Release ${CI_PROJECT_NAME} at ${CI_COMMIT_TAG}"
  export RELEASE_FILE="${CI_PROJECT_DIR}/${CI_PROJECT_NAME}-${CI_COMMIT_TAG}.zip"
  export RELEASE_NAME="v${CI_COMMIT_TAG}"
  export MODULE_DIRECTORY="${CI_PROJECT_DIR}/src"
```

--------------------------------

### includes field example

Source: https://foundryvtt.wiki/en/development/manifest-plus

Example of the includes field, an array of relative file paths to include in the package zip archive. Used by CI/CD tools to generate archives with only desired files.

```json
"includes": [
   "relative/path/to/files/script.js",
   "relative/path/to/templates/template.html",
   "path/to/image/assets/folder"
]
```

--------------------------------

### media field example

Source: https://foundryvtt.wiki/en/development/manifest-plus

Example of the media field, an array of objects with type, url, and optional caption. Includes screenshot, cover, and video types with optional loop and thumbnail for videos.

```json
"media": [
  {
    "type": "screenshot",
    "url": "link/to/media/file",
    "caption": "<Insert description of screenshot>"
  },
  {
    "type": "cover",
    "url": "https://somereposite.com/author/repo/raw/images/cover.png",
    "caption": "<Insert module / system name>"
  },
  {
    "type": "video",
    "url": "https://somereposite.com/author/repo/raw/videos/demo.webm",
    "loop": true,
    "thumbnail": "https://somereposite.com/author/repo/raw/images/thumb.png",
    "caption": "<Insert description of a cool feature from the video>"
  }
]
```

--------------------------------

### Hooks.on('init', async function) - Registering a hook callback

Source: https://foundryvtt.wiki/en/development/guides/Hooks_Listening_Calling

Example of registering a hook callback with Hooks.on() for the 'init' event, triggered by a Hooks.callAll() that calls every module/system that registered 'init'.

```javascript
Hooks.on("init", async function () {
//obviously triggered by a Hooks.callAll() that's gonna call every module/system that registered 'init', no matter what
});
```

--------------------------------

### Full template.json example with types and templates

Source: https://foundryvtt.wiki/en/development/guides/SD-tutorial/SD04-templatejson

Demonstrates the three supported properties: 'types' for sub-types, 'templates' for shared attributes, and sub-type-specific properties like 'character' and 'npc'. Changes only apply after reloading the world and if the system version is higher than the world's stored settings.

```json
{
  "Actor": {
    "types": ["character", "npc"],
    "templates": {
      "base": {
        "health": {
          "value": 10,
          "max": 10
        }
      }
    },
    "character": {
      "templates": ["base"],
      "foo": "",
      "bar": {
        "value": ""
      }
    },
    "npc": {
      "templates": ["base"]
    }
  }
}
```

--------------------------------

### Retrieve Grid Space on Hex Grid

Source: https://foundryvtt.wiki/en/development/api/canvas

Gets the top-left coordinates of the grid space under the mouse cursor on a hex grid. Converts mouse position to cube and offset coordinates before getting the top-left point.

```javascript
// Grabbing the hovered grid's space
const p = canvas.mousePosition; // { x, y }
const coords = canvas.grid.getCenterPoint({ x: p.x, y: p.y }); // { x, y }
const cube = canvas.grid.getCube(coords); // { q, r, s }
const offset = canvas.grid.getOffset(cube); // { q, r, s }
const { x, y } = canvas.grid.getTopLeftPoint(offset);
```

--------------------------------

### Example: Three tabs, varied options

Source: https://foundryvtt.wiki/en/development/guides/Tabs-and-Templates/Extending-Dialog-with-Tabs

Creates a TabbedDialog with three tabs having titles, icons, and HTML content. Sets initial_tab to "tab3" to open the third tab by default. Includes buttons, default button, and render/close handlers, and renders with resizable: true.

```javascript
let d = new TabbedDialog(
{
  title: "Test Tabbed Dialog",
  header: "Test <em>header</em>",
  footer: "Test <i>footer</i>",
  tabs: [ { title: "Tab 1",
            content: "Tab 1 content" },
          { title: "Tab 2",
            icon: "fas fa-cogs",
            content: "<b>Tab 2 content</b>" },
          { content: "<i>Tab 3 content</i>" }
        ],
  buttons: {
   one: {
    icon: '<i class="fas fa-check"></i>',
    label: "Option One",
    callback: () => console.log("Chose One")
   },
   two: {
    icon: '<i class="fas fa-times"></i>',
    label: "Option Two",
    callback: () => console.log("Chose Two")
   }
 },
 default: "two",
 render: html => console.log("Register interactivity in the rendered dialog"),
 close: html => console.log("This always is logged no matter which option is chosen")

},
{ resizable: true, initial_tab: "tab3" }

);

d.render(true);
```

--------------------------------

### game.settings.get

Source: https://foundryvtt.wiki/en/development/api/settings

Gets the value of a registered setting. The setting must be registered first.

```APIDOC
## game.settings.get

### Description
Gets the value of a registered setting. The setting must be registered first.

### Method
get

### Parameters
- **key** (string) - Required - The module name and setting name in the format 'moduleName.settingName'.

### Returns
- **value** (any) - The current value of the setting, cast to the registered type.

### Example
```javascript
game.settings.get('myModuleName', 'customClassSetting').merged; // 'foosiuswhatever'
```
```

--------------------------------

### Application and FormApplication options documentation (foundry.js)

Source: https://foundryvtt.wiki/en/development/guides/understanding-form-applications

Lists the default options for Application and FormApplication classes as documented in foundry.js. Includes defaults for closeOnSubmit, submitOnChange, submitOnClose, and editable.

```javascript
(From foundry.js)

Application:

 * @param {string} options.baseApplication      A named "base application" which generates an additional hook
 * @param {number} options.width                The default pixel width for the rendered HTML
 * @param {number} options.height               The default pixel height for the rendered HTML
 * @param {number} options.top                  The default offset-top position for the rendered HTML
 * @param {number} options.left                 The default offset-left position for the rendered HTML
 * @param {boolean} options.popOut              Whether to display the application as a pop-out container
 * @param {boolean} options.minimizable         Whether the rendered application can be minimized (popOut only)
 * @param {boolean} options.resizable           Whether the rendered application can be drag-resized (popOut only)
 * @param {string} options.id                   The default CSS id to assign to the rendered HTML
 * @param {Array.<string>} options.classes      An array of CSS string classes to apply to the rendered HTML
 * @param {string} options.title                A default window title string (popOut only)
 * @param {string} options.template             The default HTML template path to render for this Application
 * @param {Array.<string>} options.scrollY      A list of unique CSS selectors which target containers that should
 *                                              have their vertical scroll positions preserved during a re-render.|

FormApplication: (inherits all the above and adds)

* @returns {Object} options                    The default options for this FormApplication class, see Application
* @returns {boolean} options.closeOnSubmit     Whether to automatically close the application when it's contained
*                                              form is submitted. Default is true.
* @returns {boolean} options.submitOnChange    Whether to automatically submit the contained HTML form when an input
*                                              or select element is changed. Default is false.
* @returns {boolean} options.submitOnClose     Whether to automatically submit the contained HTML form when the
*                                              application window is manually closed. Default is false.
* @returns {boolean} options.editable          Whether the application form is editable - if true, it's fields will
*                                              be unlocked and the form can be submitted. If false, all form fields
*                                              will be disabled and the form cannot be submitted. Default is true.
```
Tokens:
Raw