Options
All
  • Public
  • Public/Protected
  • All
Menu

Definition of the export format.

Hierarchy

  • ExportFormat

Index

Properties

actors

actors: {}

The actors section is the meat of the export format, as it contains all of the actual character information. The "actors" object is always present and holds one or more properties that identify the various individual actors that comprise the overall character. If a character is a simple Fighter, then there will be a single actor, but more complex characters may have minions that are also included as separate actors (e.g. animal companions, drones, etc.).

Each actor is identified by a unique value that never changes. The primary character is always assigned a value of one (and sometimes referred to as the lead actor). The list of properties within the actors section is simply a list of the actors by their id, with the lead actor always appearing first. Within each of these properties, the full details of that actor will be found as an object, making each a self-contained unit.

Type declaration

  • [actorName: string]: { gameValues: GameValues; items: {}; name: string; player: string }

    The structure of an actorobjectbreaks down the actor into a small number of standard aspects and the game-specific details.

    • gameValues: GameValues

      Object containing all of the game-specific properties for the actor. These are all simple properties, so please refer to the specific game system section for details.

    • items: {}

      Object containing the collection of game-specific elements that comprise the character, encompassing all ability scores, skills, equipment, spells, etc.

      Within the "items" object, the structure is similar to the "actors" object. Each item is a uniquely named property within the object. It is possible that two items on a character represent the same general entity (e.g. two separate daggers), so each incorporates a unique value that guarantees distinction.

    • name: string

      Name given to the actor by the user.

    • player: string

      Name of the player controlling the character (as entered by the user).

Optional deletedActors

deletedActors: string[]

Deleting an actor from a character causes two different behaviors. First, a new "deletedActors" property appears at the topmost levelthat contains an array of the actors that have been deleted. Secondly, all of the items belonging to the actor that were deleted are included within the "deletedItems" object.

The primary character can never be deleted, so the actor with id 1 will always be present. All other actors can come and go, but "actor.1" will always remain.

Optional deletedItems

deletedItems: {}

Items will occasionally be deleted from a character. When this occurs, the differential export will include a new property named "deletedItems". This property will appear at the topmost level and is an object that lists every item deleted from any actors across the entire portfolio. Each deleted item is an object whose name is the deleted item and whose lone property identifies the containing item from which it was deleted.

Type declaration

  • [itemId: string]: { fromActor: string; fromItem: string | null }
    • fromActor: string

      Actor that previously possessed the deleted item.

    • fromItem: string | null

      Item that previously contained the deleted item(null when deleted directly from the actor and not a containingitem)

Optional metadata

metadata: { exportVersion: number; gameCode: string; gameMajor: number; gameMinor: number; gameName: string; hloVersion: number; legal?: string }

The metadata section outlines an assortment of important internal details about HLO that can impact the export contents. The "metadata" object is only included when a full export occurs.

Type declaration

  • exportVersion: number

    Version of the export format itself. When this changes, there could be implications across the export format.

  • gameCode: string

    Unique identifier for the game system within HLO

  • gameMajor: number

    Major version number of the game system data files. Each game system has distinct data files with its own version. When the major version changes, the contents of an export are likely to change in some manner, so differential exports acrossmajor version changes should not be used.

  • gameMinor: number

    Minor version number of the game system data files. When the minor version changes, differential exports should be safe, as this typically indicates smaller changes and bug fixes.

  • gameName: string

    Friendly name of the game system to which the character applies

  • hloVersion: number

    Version of the HLO engine. Changes to the engine should not typically impact the export data, but this value could be helpful in isolating bugs.

  • Optional legal?: string

    Copyright statement.

Optional movedItems

movedItems: {}

Items can also be moved from one location within the character to another.When this occurs, the moved item will disappear from beneath its old container and appear beneath its new container. In addition, the differential export will include a new object named "movedItems" at the topmost level. This object contains entries for each item that has been moved anywhere within the portfolio, where each identifies both the containing items from which it was moved and the new item that it now appears beneath.

Type declaration

  • [itemId: string]: { fromActor: string; fromItem: string | null; toActor: string; toItem: string | null }
    • fromActor: string

      Actor that previously possessed the moved item.

    • fromItem: string | null

      Item that previously contained the moved item (nullwhen moved directly from the actor and not a containing item).

    • toActor: string

      Actor that now possesses the moved item.

    • toItem: string | null

      Item beneath which the moved item now resides(null when moved directly to an actor and not into a containing item).

portfolio

portfolio: { baseline: number; charId: string; version: number }

The portfolio section provides basic details about the character and the export data returned.

Type declaration

  • baseline: number

    Baseline version of the character against which a differential export was generated. Character data can become large and only small portions may change. The export mechanism can optionally report only the differences between an older version and the current version. The baseline indicates the older version that the export contains the differences from. A baseline of zero indicates the full character is reported.

  • charId: string

    Unique identifier for the character within HLO

  • version: number

    Current version of the character within HLO. Whenever a character is modified in some way, its version is increased, and this value reflects the version at the time it was exported.

Generated using TypeDoc