Options
All
  • Public
  • Public/Protected
  • All
Menu

Class World

Worlds contains various definitions (Enum, Tileset) and are made up of one or more Levels, which utilise these definitions.

Worlds can have different layouts: Linear, Free, or GridVania.

Linear worlds are organized as a linear sequence of levels, either horizontal or vertical.

Free worlds are not organized, all levels appear freely in 2D space.

GridVania worlds are organized into a uniform 2D grid, where each level can take up one or more grid cells.

Visit https://ldtk.io/docs/general/world/ for more information.

Hierarchy

  • World

Index

Constructors

Private constructor

Properties

Readonly enumIds

enumIds: string[]

Array Enum names defined for this World.

Readonly enumMap

enumMap: Readonly<Record<string, Enum>>

A map of Enum ids to Enums.

Readonly enums

enums: Enum[]

Array Enums defined for this World.

Readonly levelIds

levelIds: string[]

Array Levels Ids defined for this World.

Readonly levelMap

levelMap: Readonly<Record<string, Level>>

A map of Level ids to Levels.

Readonly levels

levels: Level[]

Array Levels defined for this World.

Readonly tilesetIds

tilesetIds: string[]

Array Tilesets Ids defined for this World.

Readonly tilesetMap

tilesetMap: Readonly<Record<string, Tileset>>

A map of Tileset ids to Tilesets.

Readonly tilesets

tilesets: Tileset[]

Array Tilesets defined for this World.

Accessors

bgColor

  • get bgColor(): string
  • Background color (RGB hex string)

    Returns string

externalLevels

  • get externalLevels(): boolean
  • True if this world was saved with separate level files option.

    Returns boolean

layout

  • The world layout

    Possible values: "Free", "GridVania", "LinearHorizontal", "LinearVertical"

    Returns WorldLayout

Methods

Private fetchLevel

  • fetchLevel(path: string): Promise<Level>
  • Used for fetching external levels

    Parameters

    • path: string

    Returns Promise<Level>

findEnum

  • findEnum(predicate: (e: Enum) => boolean): undefined | Enum
  • Find an enum for which a given predicate is true.

    Parameters

    • predicate: (e: Enum) => boolean
        • (e: Enum): boolean
        • Parameters

          Returns boolean

    Returns undefined | Enum

findEnumByUid

  • findEnumByUid(uid: number): undefined | Enum
  • Find an enum by its uid.

    Parameters

    • uid: number

    Returns undefined | Enum

findLevel

  • findLevel(predicate: (l: Level) => boolean): undefined | Level
  • Find a level for which a given predicate is true.

    Parameters

    • predicate: (l: Level) => boolean
        • Parameters

          Returns boolean

    Returns undefined | Level

findLevelByUid

  • findLevelByUid(uid: number): undefined | Level
  • Find a level by its uid.

    Parameters

    • uid: number

    Returns undefined | Level

findTileset

  • findTileset(predicate: (t: Tileset) => boolean): undefined | Tileset
  • Find a tileset for which a given predicate is true.

    Parameters

    Returns undefined | Tileset

findTilesetByPath

  • findTilesetByPath(path: string): undefined | Tileset
  • Find a tileset by its path.

    Parameters

    • path: string

    Returns undefined | Tileset

findTilesetByUid

  • findTilesetByUid(uid: number): undefined | Tileset
  • Find a tileset by its uid.

    Parameters

    • uid: number

    Returns undefined | Tileset

loadLevel

  • loadLevel(identifier: string): Promise<void>
  • Load and parse external level identifier.

    This allows for dynamically loading individual levels.

    If a level is already loaded, it won't be loaded again.

    Parameters

    • identifier: string

    Returns Promise<void>

loadLevels

  • loadLevels(): Promise<void>
  • Load and parse all external levels and enums.

    If a level is already loaded, it won't be loaded again.

    Returns Promise<void>

Static fromJSON

  • Parse an existing JSON object as an LDtk project file

    Parameters

    Returns World

Static fromURL

  • fromURL(path: string): Promise<World>
  • Asynchronously load and parse an LDtk project file

    Parameters

    • path: string

    Returns Promise<World>

Static loadRaw

  • loadRaw(path: string): Promise<World>
  • Load the raw JSON without any utilities.

    This does the following in Node:

    const path = ... ;
    import * as fs from "fs";
    const world = await new Promise((resolve, reject) => {
        fs.readFile(path, { encoding: "utf-8" }, (err, data) => {
             if (err) reject(err);
             else resolve(JSON.parse(data) as LDtk.World);
        });
    })
    

    And in the browser:

    const path = ... ;
    const world = await (await fetch(path)).json() as LDtk.World;
    

    Parameters

    • path: string

    Returns Promise<World>

Generated using TypeDoc