Class Tilemap

constructor

• new Tilemap(scene: Scene, mapData: MapData): Tilemaps.Tilemap

  Parameters

  • scene: Scene

    The Scene to which this Tilemap belongs.
  • mapData: MapData

    A MapData instance containing Tilemap data.

  Returns Tilemaps.Tilemap

currentLayerIndex

format

height

heightInPixels

hexSideLength

imageCollections

images

layer

layers

objects

orientation

properties

renderOrder

scene

tileHeight

tiles

tilesets

tileWidth

version

width

widthInPixels

addTilesetImage

• addTilesetImage(
      tilesetName: string,
      key?: string,
      tileWidth?: number,
      tileHeight?: number,
      tileMargin?: number,
      tileSpacing?: number,
      gid?: number,
      tileOffset?: object,
  ): Tileset

  Adds an image to the map to be used as a tileset. A single map may use multiple tilesets. Note that the tileset name can be found in the JSON file exported from Tiled, or in the Tiled editor.

  Parameters

  • tilesetName: string

    The name of the tileset as specified in the map data.
  • Optionalkey: string

    The key of the Phaser.Cache image used for this tileset. If undefined or null it will look for an image with a key matching the tilesetName parameter.
  • OptionaltileWidth: number

    The width of the tile (in pixels) in the Tileset Image. If not given it will default to the map's tileWidth value, or the tileWidth specified in the Tiled JSON file.
  • OptionaltileHeight: number

    The height of the tiles (in pixels) in the Tileset Image. If not given it will default to the map's tileHeight value, or the tileHeight specified in the Tiled JSON file.
  • OptionaltileMargin: number

    The margin around the tiles in the sheet (in pixels). If not specified, it will default to 0 or the value specified in the Tiled JSON file.
  • OptionaltileSpacing: number

    The spacing between each the tile in the sheet (in pixels). If not specified, it will default to 0 or the value specified in the Tiled JSON file.
  • Optionalgid: number

    If adding multiple tilesets to a blank map, specify the starting GID this set will use here. Default 0.
  • OptionaltileOffset: object

    Tile texture drawing offset. If not specified, it will default to {0, 0} Default {x: 0, y: 0}.

  Returns Tileset

calculateFacesAt

• calculateFacesAt(
      tileX: number,
      tileY: number,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Calculates interesting faces at the given tile coordinates of the specified layer. Interesting faces are used internally for optimizing collisions against tiles. This method is mostly used internally to optimize recalculating faces when only one tile has been changed.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

calculateFacesWithin

• calculateFacesWithin(
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Calculates interesting faces within the rectangular area specified (in tile coordinates) of the layer. Interesting faces are used internally for optimizing collisions against tiles. This method is mostly used internally.

  If no layer is specified, the maps current layer is used.

  Parameters

  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

copy

• copy(
      srcTileX: number,
      srcTileY: number,
      width: number,
      height: number,
      destTileX: number,
      destTileY: number,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Copies the tiles in the source rectangular area to a new destination (all specified in tile coordinates) within the layer. This copies all tile properties & recalculates collision information in the destination region.

  If no layer specified, the map's current layer is used. This cannot be applied to StaticTilemapLayers.

  Parameters

  • srcTileX: number

    The x coordinate of the area to copy from, in tiles, not pixels.
  • srcTileY: number

    The y coordinate of the area to copy from, in tiles, not pixels.
  • width: number

    The width of the area to copy, in tiles, not pixels.
  • height: number

    The height of the area to copy, in tiles, not pixels.
  • destTileX: number

    The x coordinate of the area to copy to, in tiles, not pixels.
  • destTileY: number

    The y coordinate of the area to copy to, in tiles, not pixels.
  • OptionalrecalculateFaces: boolean

    true if the faces data should be recalculated. Default true.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

createBlankLayer

• createBlankLayer(
      name: string,
      tileset: string | string[] | Tileset | Tileset[],
      x?: number,
      y?: number,
      width?: number,
      height?: number,
      tileWidth?: number,
      tileHeight?: number,
  ): TilemapLayer

  Creates a new and empty Tilemap Layer. The currently selected layer in the map is set to this new layer.

  Prior to v3.50.0 this method was called createBlankDynamicLayer.

  Parameters

  • name: string

    The name of this layer. Must be unique within the map.
  • tileset: string | string[] | Tileset | Tileset[]

    The tileset, or an array of tilesets, used to render this layer. Can be a string or a Tileset object.
  • Optionalx: number

    The world x position where the top left of this layer will be placed. Default 0.
  • Optionaly: number

    The world y position where the top left of this layer will be placed. Default 0.
  • Optionalwidth: number

    The width of the layer in tiles. If not specified, it will default to the map's width.
  • Optionalheight: number

    The height of the layer in tiles. If not specified, it will default to the map's height.
  • OptionaltileWidth: number

    The width of the tiles the layer uses for calculations. If not specified, it will default to the map's tileWidth.
  • OptionaltileHeight: number

    The height of the tiles the layer uses for calculations. If not specified, it will default to the map's tileHeight.

  Returns TilemapLayer

createFromObjects

• createFromObjects(
      objectLayerName: string,
      config: CreateFromObjectLayerConfig | CreateFromObjectLayerConfig[],
      useTileset?: boolean,
  ): GameObject[]

  This method will iterate through all of the objects defined in a Tiled Object Layer and then convert the matching results into Phaser Game Objects (by default, Sprites)

  Objects are matched on one of 4 criteria: The Object ID, the Object GID, the Object Name, or the Object Type.

  Within Tiled, Object IDs are unique per Object. Object GIDs, however, are shared by all objects using the same image. Finally, Object Names and Types are strings and the same name can be used on multiple Objects in Tiled, they do not have to be unique; Names are specific to Objects while Types can be inherited from Object GIDs using the same image.

  You set the configuration parameter accordingly, based on which type of criteria you wish to match against. For example, to convert all items on an Object Layer with a gid of 26:

  createFromObjects(layerName, {
    gid: 26
  });
  Copy

  Or, to convert objects with the name 'bonus':

  createFromObjects(layerName, {
    name: 'bonus'
  });
  Copy

  Or, to convert an object with a specific id:

  createFromObjects(layerName, {
    id: 9
  });
  Copy

  You should only specify either id, gid, name, type, or none of them. Do not add more than one criteria to your config. If you do not specify any criteria, then all objects in the Object Layer will be converted.

  By default this method will convert Objects into Phaser.GameObjects.Sprite instances, but you can override this by providing your own class type:

  createFromObjects(layerName, {
    gid: 26,
    classType: Coin
  });
  Copy

  This will convert all Objects with a gid of 26 into your custom Coin class. You can pass any class type here, but it must extend Phaser.GameObjects.GameObject as its base class. Your class will always be passed 1 parameter: scene, which is a reference to either the Scene specified in the config object or, if not given, the Scene to which this Tilemap belongs. The class must have setPosition and setTexture methods.

  This method will set the following Tiled Object properties on the new Game Object:

  • flippedHorizontal as flipX
  • flippedVertical as flipY
  • height as displayHeight
  • name
  • rotation
  • visible
  • width as displayWidth
  • x, adjusted for origin
  • y, adjusted for origin

  Additionally, this method will set Tiled Object custom properties

  • on the Game Object, if it has the same property name and a value that isn't undefined; or
  • on the Game Object's data store otherwise.

  For example, a Tiled Object with custom properties { alpha: 0.5, gold: 1 } will be created as a Game Object with an alpha value of 0.5 and a data.values.gold value of 1.

  When useTileset is true (the default), Tile Objects will inherit the texture and any tile properties from the tileset, and the local tile ID will be used as the texture frame. For the frame selection to work you need to load the tileset texture as a spritesheet so its frame names match the local tile IDs.

  For instance, a tileset tile

  { id: 3, type: 'treadmill', speed: 4 }
  Copy

  with gid 19 and an object

  { id: 7, gid: 19, speed: 5, rotation: 90 }
  Copy

  will be interpreted as

  { id: 7, gid: 19, speed: 5, rotation: 90, type: 'treadmill', texture: '[the tileset texture]', frame: 3 }
  Copy

  You can suppress this behavior by setting the boolean ignoreTileset for each config that should ignore object gid tilesets.

  You can set a container property in the config. If given, the new Game Object will be added to the Container or Layer instance instead of the Scene.

  You can set named texture-key and texture-frame properties, which will be set on the new Game Object.

  Finally, you can provide an array of config objects, to convert multiple types of object in a single call:

  createFromObjects(layerName, [
    {
      gid: 26,
      classType: Coin
    },
    {
      id: 9,
      classType: BossMonster
    },
    {
      name: 'lava',
      classType: LavaTile
    },
    {
      type: 'endzone',
      classType: Phaser.GameObjects.Zone
    }
  ]);
  Copy

  The signature of this method changed significantly in v3.60.0. Prior to this, it did not take config objects.

  Parameters

  • objectLayerName: string

    The name of the Tiled object layer to create the Game Objects from.
  • config: CreateFromObjectLayerConfig | CreateFromObjectLayerConfig[]

    A CreateFromObjects configuration object, or an array of them.
  • OptionaluseTileset: boolean

    True if objects that set gids should also search the underlying tile for properties and data. Default true.

  Returns GameObject[]

createFromTiles

• createFromTiles(
      indexes: number | any[],
      replacements: number | any[],
      spriteConfig?: SpriteConfig,
      scene?: Scene,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): GameObjects.Sprite[]

  Creates a Sprite for every tile matching the given tile indexes in the layer. You can optionally specify if each tile will be replaced with a new tile after the Sprite has been created. Set this value to -1 if you want to just remove the tile after conversion.

  This is useful if you want to lay down special tiles in a level that are converted to Sprites, but want to replace the tile itself with a floor tile or similar once converted.

  The following features were added in Phaser v3.80:

  By default, Phaser Sprites have their origin set to 0.5 x 0.5. If you don't specify a new origin in the spriteConfig, then it will adjust the sprite positions by half the tile size, to position them accurately on the map.

  When the Sprite is created it will copy the following properties from the tile:

  'rotation', 'flipX', 'flipY', 'alpha', 'visible' and 'tint'.

  The spriteConfig also has a special property called useSpriteSheet. If this is set to true and you have loaded the tileset as a sprite sheet (not an image), then it will set the Sprite key and frame to match the sprite texture and tile index.

  Parameters

  • indexes: number | any[]

    The tile index, or array of indexes, to create Sprites from.
  • replacements: number | any[]

    The tile index, or array of indexes, to change a converted tile to. Set to null to leave the tiles unchanged. If an array is given, it is assumed to be a one-to-one mapping with the indexes array.
  • OptionalspriteConfig: SpriteConfig

    The config object to pass into the Sprite creator (i.e. scene.make.sprite).
  • Optionalscene: Scene

    The Scene to create the Sprites within.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns GameObjects.Sprite[]

createLayer

• createLayer(
      layerID: string | number,
      tileset: string | string[] | Tileset | Tileset[],
      x?: number,
      y?: number,
      gpu?: boolean,
  ): TilemapLayer | TilemapGPULayer

  Creates a new Tilemap Layer that renders the LayerData associated with the given layerID. The currently selected layer in the map is set to this new layer.

  The layerID is important. If you've created your map in Tiled then you can get this by looking in Tiled and looking at the layer name. Or you can open the JSON file it exports and look at the layers[].name value. Either way it must match.

  Prior to v3.50.0 this method was called createDynamicLayer.

  Parameters

  • layerID: string | number

    The layer array index value, or if a string is given, the layer name from Tiled.
  • tileset: string | string[] | Tileset | Tileset[]

    The tileset, or an array of tilesets, used to render this layer. Can be a string or a Tileset object.
  • Optionalx: number

    The x position to place the layer in the world. If not specified, it will default to the layer offset from Tiled or 0. Default 0.
  • Optionaly: number

    The y position to place the layer in the world. If not specified, it will default to the layer offset from Tiled or 0. Default 0.
  • Optionalgpu: boolean

    Create a TilemapGPULayer instead of a TilemapLayer. This option is WebGL-only. A TilemapGPULayer is less flexible, but can be much faster. Default false.

  Returns TilemapLayer | TilemapGPULayer

destroy

• destroy(): void

  Removes all layer data from this Tilemap and nulls the scene reference. This will destroy any TilemapLayers that have been created.

  Returns void

destroyLayer

• destroyLayer(layer?: string | number | TilemapLayer): Tilemaps.Tilemap

  Destroys the given TilemapLayer and removes it from this Tilemap.

  If no layer is specified, the maps current layer is used.

  Parameters

  • Optionallayer: string | number | TilemapLayer

    The tile layer to be destroyed.

  Returns Tilemaps.Tilemap

fill

• fill(
      index: number,
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets the tiles in the given rectangular area (in tile coordinates) of the layer with the specified index. Tiles will be set to collide if the given index is a colliding index. Collision information in the region will be recalculated.

  If no layer specified, the map's current layer is used. This cannot be applied to StaticTilemapLayers.

  Parameters

  • index: number

    The tile index to fill the area with.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • OptionalrecalculateFaces: boolean

    true if the faces data should be recalculated. Default true.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

filterObjects

• filterObjects(
      objectLayer: string | ObjectLayer,
      callback: TilemapFilterCallback,
      context?: object,
  ): TiledObject[]

  For each object in the given object layer, run the given filter callback function. Any objects that pass the filter test (i.e. where the callback returns true) will be returned in a new array. Similar to Array.prototype.Filter in vanilla JS.

  Parameters

  • objectLayer: string | ObjectLayer

    The name of an object layer (from Tiled) or an ObjectLayer instance.
  • callback: TilemapFilterCallback

    The callback. Each object in the given area will be passed to this callback as the first and only parameter.
  • Optionalcontext: object

    The context under which the callback should be run.

  Returns TiledObject[]

filterTiles

• filterTiles(
      callback: Function,
      context?: object,
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      filteringOptions?: FilteringOptions,
      layer?: string | number | TilemapLayer,
  ): Tile[]

  For each tile in the given rectangular area (in tile coordinates) of the layer, run the given filter callback function. Any tiles that pass the filter test (i.e. where the callback returns true) will returned as a new array. Similar to Array.prototype.Filter in vanilla JS. If no layer specified, the map's current layer is used.

  Parameters

  • callback: Function

    The callback. Each tile in the given area will be passed to this callback as the first and only parameter. The callback should return true for tiles that pass the filter.
  • Optionalcontext: object

    The context under which the callback should be run.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area to filter.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area to filter.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • OptionalfilteringOptions: FilteringOptions

    Optional filters to apply when getting the tiles.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile[]

findByIndex

• findByIndex(
      index: number,
      skip?: number,
      reverse?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tile

  Searches the entire map layer for the first tile matching the given index, then returns that Tile object. If no match is found, it returns null. The search starts from the top-left tile and continues horizontally until it hits the end of the row, then it drops down to the next column. If the reverse boolean is true, it scans starting from the bottom-right corner traveling up to the top-left. If no layer specified, the map's current layer is used.

  Parameters

  • index: number

    The tile index value to search for.
  • Optionalskip: number

    The number of times to skip a matching tile before returning. Default 0.
  • Optionalreverse: boolean

    If true it will scan the layer in reverse, starting at the bottom-right. Otherwise it scans from the top-left. Default false.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

findObject

• findObject(
      objectLayer: string | ObjectLayer,
      callback: TilemapFindCallback,
      context?: object,
  ): TiledObject

  Find the first object in the given object layer that satisfies the provided testing function. I.e. finds the first object for which callback returns true. Similar to Array.prototype.find in vanilla JS.

  Parameters

  • objectLayer: string | ObjectLayer

    The name of an object layer (from Tiled) or an ObjectLayer instance.
  • callback: TilemapFindCallback

    The callback. Each object in the given area will be passed to this callback as the first and only parameter.
  • Optionalcontext: object

    The context under which the callback should be run.

  Returns TiledObject

findTile

• findTile(
      callback: FindTileCallback,
      context?: object,
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      filteringOptions?: FilteringOptions,
      layer?: string | number | TilemapLayer,
  ): Tile

  Find the first tile in the given rectangular area (in tile coordinates) of the layer that satisfies the provided testing function. I.e. finds the first tile for which callback returns true. Similar to Array.prototype.find in vanilla JS. If no layer specified, the maps current layer is used.

  Parameters

  • callback: FindTileCallback

    The callback. Each tile in the given area will be passed to this callback as the first and only parameter.
  • Optionalcontext: object

    The context under which the callback should be run.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area to search.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area to search.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • OptionalfilteringOptions: FilteringOptions

    Optional filters to apply when getting the tiles.
  • Optionallayer: string | number | TilemapLayer

    The Tile layer to run the search on. If not provided will use the current layer.

  Returns Tile

forEachTile

• forEachTile(
      callback: EachTileCallback,
      context?: object,
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      filteringOptions?: FilteringOptions,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  For each tile in the given rectangular area (in tile coordinates) of the layer, run the given callback. Similar to Array.prototype.forEach in vanilla JS.

  If no layer specified, the map's current layer is used.

  Parameters

  • callback: EachTileCallback

    The callback. Each tile in the given area will be passed to this callback as the first and only parameter.
  • Optionalcontext: object

    The context under which the callback should be run.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area to search.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area to search.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • OptionalfilteringOptions: FilteringOptions

    Optional filters to apply when getting the tiles.
  • Optionallayer: string | number | TilemapLayer

    The Tile layer to run the search on. If not provided will use the current layer.

  Returns Tilemaps.Tilemap

getImageIndex

• getImageIndex(name: string): number

  Gets the image layer index based on its name.

  Parameters

  • name: string

    The name of the image to get.

  Returns number

getImageLayerNames

• getImageLayerNames(): string[]

  Return a list of all valid imagelayer names loaded in this Tilemap.

  Returns string[]

getIndex

• getIndex(location: any[], name: string): number

  Internally used. Returns the index of the object in one of the Tilemaps arrays whose name property matches the given name.

  Parameters

  • location: any[]

    The Tilemap array to search.
  • name: string

    The name of the array element to get.

  Returns number

getLayer

• getLayer(layer?: string | number | TilemapLayer): LayerData

  Gets the LayerData from this.layers that is associated with the given layer, or null if the layer is invalid.

  Parameters

  • Optionallayer: string | number | TilemapLayer

    The name of the layer from Tiled, the index of the layer in the map or Tilemap Layer. If not given will default to the maps current layer index.

  Returns LayerData

getLayerIndex

• getLayerIndex(layer?: string | number | TilemapLayer): number

  Gets the LayerData index of the given layer within this.layers, or null if an invalid layer is given.

  Parameters

  • Optionallayer: string | number | TilemapLayer

    The name of the layer from Tiled, the index of the layer in the map or a Tilemap Layer. If not given will default to the map's current layer index.

  Returns number

getLayerIndexByName

• getLayerIndexByName(name: string): number

  Gets the index of the LayerData within this.layers that has the given name, or null if an invalid name is given.

  Parameters

  • name: string

    The name of the layer to get.

  Returns number

getObjectLayer

• getObjectLayer(name?: string): ObjectLayer

  Gets the ObjectLayer from this.objects that has the given name, or null if no ObjectLayer is found with that name.

  Parameters

  • Optionalname: string

    The name of the object layer from Tiled.

  Returns ObjectLayer

getObjectLayerNames

• getObjectLayerNames(): string[]

  Return a list of all valid objectgroup names loaded in this Tilemap.

  Returns string[]

getTileAt

• getTileAt(
      tileX: number,
      tileY: number,
      nonNull?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tile

  Gets a tile at the given tile coordinates from the given layer.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    X position to get the tile from (given in tile units, not pixels).
  • tileY: number

    Y position to get the tile from (given in tile units, not pixels).
  • OptionalnonNull: boolean

    For empty tiles, return a Tile object with an index of -1 instead of null. Default false.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

getTileAtWorldXY

• getTileAtWorldXY(
      worldX: number,
      worldY: number,
      nonNull?: boolean,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Tile

  Gets a tile at the given world coordinates from the given layer.

  If no layer is specified, the maps current layer is used.

  Parameters

  • worldX: number

    X position to get the tile from (given in pixels)
  • worldY: number

    Y position to get the tile from (given in pixels)
  • OptionalnonNull: boolean

    For empty tiles, return a Tile object with an index of -1 instead of null. Default false.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

getTileCorners

• getTileCorners(
      tileX: number,
      tileY: number,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Math.Vector2[]

  Returns an array of Vector2s where each entry corresponds to the corner of the requested tile.

  The tileX and tileY parameters are in tile coordinates, not world coordinates.

  The corner coordinates are in world space, having factored in TilemapLayer scale, position and the camera, if given.

  The size of the array will vary based on the orientation of the map. For example an orthographic map will return an array of 4 vectors, where-as a hexagonal map will, of course, return an array of 6 corner vectors.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Math.Vector2[]

getTileLayerNames

• getTileLayerNames(): string[]

  Return a list of all valid tilelayer names loaded in this Tilemap.

  Returns string[]

getTileset

• getTileset(name: string): Tileset

  Gets the Tileset that has the given name, or null if an invalid name is given.

  Parameters

  • name: string

    The name of the Tileset to get.

  Returns Tileset

getTilesetIndex

• getTilesetIndex(name: string): number

  Gets the index of the Tileset within this.tilesets that has the given name, or null if an invalid name is given.

  Parameters

  • name: string

    The name of the Tileset to get.

  Returns number

getTilesWithin

• getTilesWithin(
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      filteringOptions?: FilteringOptions,
      layer?: string | number | TilemapLayer,
  ): Tile[]

  Gets the tiles in the given rectangular area (in tile coordinates) of the layer.

  If no layer is specified, the maps current layer is used.

  Parameters

  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • OptionalfilteringOptions: FilteringOptions

    Optional filters to apply when getting the tiles.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile[]

getTilesWithinShape

• getTilesWithinShape(
      shape: Geom.Rectangle | Geom.Triangle | Circle | Geom.Line,
      filteringOptions?: FilteringOptions,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Tile[]

  Gets the tiles that overlap with the given shape in the given layer. The shape must be a Circle, Line, Rectangle or Triangle. The shape should be in world coordinates.

  If no layer is specified, the maps current layer is used.

  Parameters

  • shape: Geom.Rectangle | Geom.Triangle | Circle | Geom.Line

    A shape in world (pixel) coordinates
  • OptionalfilteringOptions: FilteringOptions

    Optional filters to apply when getting the tiles.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when factoring in which tiles to return.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile[]

getTilesWithinWorldXY

• getTilesWithinWorldXY(
      worldX: number,
      worldY: number,
      width: number,
      height: number,
      filteringOptions?: FilteringOptions,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Tile[]

  Gets the tiles in the given rectangular area (in world coordinates) of the layer.

  If no layer is specified, the maps current layer is used.

  Parameters

  • worldX: number

    The world x coordinate for the top-left of the area.
  • worldY: number

    The world y coordinate for the top-left of the area.
  • width: number

    The width of the area.
  • height: number

    The height of the area.
  • OptionalfilteringOptions: FilteringOptions

    Optional filters to apply when getting the tiles.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when factoring in which tiles to return.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile[]

hasTileAt

• hasTileAt(
      tileX: number,
      tileY: number,
      layer?: string | number | TilemapLayer,
  ): boolean

  Checks if there is a tile at the given location (in tile coordinates) in the given layer. Returns false if there is no tile or if the tile at that location has an index of -1.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns boolean

hasTileAtWorldXY

• hasTileAtWorldXY(
      worldX: number,
      worldY: number,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): boolean

  Checks if there is a tile at the given location (in world coordinates) in the given layer. Returns false if there is no tile or if the tile at that location has an index of -1.

  If no layer is specified, the maps current layer is used.

  Parameters

  • worldX: number

    The x coordinate, in pixels.
  • worldY: number

    The y coordinate, in pixels.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when factoring in which tiles to return.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns boolean

putTileAt

• putTileAt(
      tile: number | Tile,
      tileX: number,
      tileY: number,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tile

  Puts a tile at the given tile coordinates in the specified layer. You can pass in either an index or a Tile object. If you pass in a Tile, all attributes will be copied over to the specified location. If you pass in an index, only the index at the specified location will be changed. Collision information will be recalculated at the specified location.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tile: number | Tile

    The index of this tile to set or a Tile object.
  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • OptionalrecalculateFaces: boolean

    true if the faces data should be recalculated.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

putTileAtWorldXY

• putTileAtWorldXY(
      tile: number | Tile,
      worldX: number,
      worldY: number,
      recalculateFaces?: boolean,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Tile

  Puts a tile at the given world coordinates (pixels) in the specified layer. You can pass in either an index or a Tile object. If you pass in a Tile, all attributes will be copied over to the specified location. If you pass in an index, only the index at the specified location will be changed. Collision information will be recalculated at the specified location.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tile: number | Tile

    The index of this tile to set or a Tile object.
  • worldX: number

    The x coordinate, in pixels.
  • worldY: number

    The y coordinate, in pixels.
  • OptionalrecalculateFaces: boolean

    true if the faces data should be recalculated.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

putTilesAt

• putTilesAt(
      tile: number[] | number[][] | Tile[] | Tile[][],
      tileX: number,
      tileY: number,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Puts an array of tiles or a 2D array of tiles at the given tile coordinates in the specified layer. The array can be composed of either tile indexes or Tile objects. If you pass in a Tile, all attributes will be copied over to the specified location. If you pass in an index, only the index at the specified location will be changed. Collision information will be recalculated within the region tiles were changed.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tile: number[] | number[][] | Tile[] | Tile[][]

    A row (array) or grid (2D array) of Tiles or tile indexes to place.
  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • OptionalrecalculateFaces: boolean

    true if the faces data should be recalculated.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

randomize

• randomize(
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      indexes?: number[],
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Randomizes the indexes of a rectangular region of tiles (in tile coordinates) within the specified layer. Each tile will receive a new index. If an array of indexes is passed in, then those will be used for randomly assigning new tile indexes. If an array is not provided, the indexes found within the region (excluding -1) will be used for randomly assigning new tile indexes. This method only modifies tile indexes and does not change collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • Optionalindexes: number[]

    An array of indexes to randomly draw from during randomization.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

removeAllLayers

• removeAllLayers(): this

  Removes all Tilemap Layers from this Tilemap and calls destroy on each of them.

  Returns this

removeLayer

• removeLayer(layer?: string | number | TilemapLayer): Tilemaps.Tilemap

  Removes the given TilemapLayer from this Tilemap without destroying it.

  If no layer is specified, the maps current layer is used.

  Parameters

  • Optionallayer: string | number | TilemapLayer

    The tile layer to be removed.

  Returns Tilemaps.Tilemap

removeTile

• removeTile(
      tiles: Tile | Tile[],
      replaceIndex?: number,
      recalculateFaces?: boolean,
  ): Tile[]

  Removes the given Tile, or an array of Tiles, from the layer to which they belong, and optionally recalculates the collision information.

  Parameters

  • tiles: Tile | Tile[]

    The Tile to remove, or an array of Tiles.
  • OptionalreplaceIndex: number

    After removing the Tile, insert a brand new Tile into its location with the given index. Leave as -1 to just remove the tile. Default -1.
  • OptionalrecalculateFaces: boolean

    true if the faces data should be recalculated. Default true.

  Returns Tile[]

removeTileAt

• removeTileAt(
      tileX: number,
      tileY: number,
      replaceWithNull?: boolean,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tile

  Removes the tile at the given tile coordinates in the specified layer and updates the layers collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • OptionalreplaceWithNull: boolean

    If true (the default), this will replace the tile at the specified location with null instead of a Tile with an index of -1.
  • OptionalrecalculateFaces: boolean

    If true (the default), the faces data will be recalculated.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

removeTileAtWorldXY

• removeTileAtWorldXY(
      worldX: number,
      worldY: number,
      replaceWithNull?: boolean,
      recalculateFaces?: boolean,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Tile

  Removes the tile at the given world coordinates in the specified layer and updates the layers collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • worldX: number

    The x coordinate, in pixels.
  • worldY: number

    The y coordinate, in pixels.
  • OptionalreplaceWithNull: boolean

    If true (the default), this will replace the tile at the specified location with null instead of a Tile with an index of -1.
  • OptionalrecalculateFaces: boolean

    If true (the default), the faces data will be recalculated.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tile

renderDebug

• renderDebug(
      graphics: GameObjects.Graphics,
      styleConfig?: StyleConfig,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Draws a debug representation of the layer to the given Graphics object. This is helpful when you want to get a quick idea of which of your tiles are colliding and which have interesting faces. The tiles are drawn starting at (0, 0) in the Graphics, allowing you to place the debug representation wherever you want on the screen.

  If no layer is specified, the maps current layer is used.

  Note: This method currently only works with orthogonal tilemap layers.

  Parameters

  • graphics: GameObjects.Graphics

    The target Graphics object to draw upon.
  • OptionalstyleConfig: StyleConfig

    An object specifying the colors to use for the debug drawing.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

renderDebugFull

• renderDebugFull(graphics: GameObjects.Graphics, styleConfig?: StyleConfig): this

  Draws a debug representation of all layers within this Tilemap to the given Graphics object.

  This is helpful when you want to get a quick idea of which of your tiles are colliding and which have interesting faces. The tiles are drawn starting at (0, 0) in the Graphics, allowing you to place the debug representation wherever you want on the screen.

  Parameters

  • graphics: GameObjects.Graphics

    The target Graphics object to draw upon.
  • OptionalstyleConfig: StyleConfig

    An object specifying the colors to use for the debug drawing.

  Returns this

replaceByIndex

• replaceByIndex(
      findIndex: number,
      newIndex: number,
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Scans the given rectangular area (given in tile coordinates) for tiles with an index matching findIndex and updates their index to match newIndex. This only modifies the index and does not change collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • findIndex: number

    The index of the tile to search for.
  • newIndex: number

    The index of the tile to replace it with.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

setBaseTileSize

• setBaseTileSize(tileWidth: number, tileHeight: number): this

  Sets the base tile size for the map. Note: this does not necessarily match the tileWidth and tileHeight for all layers. This also updates the base size on all tiles across all layers.

  Parameters

  • tileWidth: number

    The width of the tiles the map uses for calculations.
  • tileHeight: number

    The height of the tiles the map uses for calculations.

  Returns this

setCollision

• setCollision(
      indexes: number | any[],
      collides?: boolean,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
      updateLayer?: boolean,
  ): Tilemaps.Tilemap

  Sets collision on the given tile or tiles within a layer by index. You can pass in either a single numeric index or an array of indexes: [2, 3, 15, 20]. The collides parameter controls if collision will be enabled (true) or disabled (false).

  If no layer is specified, the maps current layer is used.

  Parameters

  • indexes: number | any[]

    Either a single tile index, or an array of tile indexes.
  • Optionalcollides: boolean

    If true it will enable collision. If false it will clear collision.
  • OptionalrecalculateFaces: boolean

    Whether or not to recalculate the tile faces after the update.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.
  • OptionalupdateLayer: boolean

    If true, updates the current tiles on the layer. Set to false if no tiles have been placed for significant performance boost. Default true.

  Returns Tilemaps.Tilemap

setCollisionBetween

• setCollisionBetween(
      start: number,
      stop: number,
      collides?: boolean,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets collision on a range of tiles in a layer whose index is between the specified start and stop (inclusive). Calling this with a start value of 10 and a stop value of 14 would set collision for tiles 10, 11, 12, 13 and 14. The collides parameter controls if collision will be enabled (true) or disabled (false).

  If no layer is specified, the maps current layer is used.

  Parameters

  • start: number

    The first index of the tile to be set for collision.
  • stop: number

    The last index of the tile to be set for collision.
  • Optionalcollides: boolean

    If true it will enable collision. If false it will clear collision.
  • OptionalrecalculateFaces: boolean

    Whether or not to recalculate the tile faces after the update.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

setCollisionByExclusion

• setCollisionByExclusion(
      indexes: number[],
      collides?: boolean,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets collision on all tiles in the given layer, except for tiles that have an index specified in the given array. The collides parameter controls if collision will be enabled (true) or disabled (false). Tile indexes not currently in the layer are not affected.

  If no layer is specified, the maps current layer is used.

  Parameters

  • indexes: number[]

    An array of the tile indexes to not be counted for collision.
  • Optionalcollides: boolean

    If true it will enable collision. If false it will clear collision.
  • OptionalrecalculateFaces: boolean

    Whether or not to recalculate the tile faces after the update.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

setCollisionByProperty

• setCollisionByProperty(
      properties: object,
      collides?: boolean,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets collision on the tiles within a layer by checking tile properties. If a tile has a property that matches the given properties object, its collision flag will be set. The collides parameter controls if collision will be enabled (true) or disabled (false). Passing in { collides: true } would update the collision flag on any tiles with a "collides" property that has a value of true. Any tile that doesn't have "collides" set to true will be ignored. You can also use an array of values, e.g. { types: ["stone", "lava", "sand" ] }. If a tile has a "types" property that matches any of those values, its collision flag will be updated.

  If no layer is specified, the maps current layer is used.

  Parameters

  • properties: object

    An object with tile properties and corresponding values that should be checked.
  • Optionalcollides: boolean

    If true it will enable collision. If false it will clear collision.
  • OptionalrecalculateFaces: boolean

    Whether or not to recalculate the tile faces after the update.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

setCollisionFromCollisionGroup

• setCollisionFromCollisionGroup(
      collides?: boolean,
      recalculateFaces?: boolean,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets collision on the tiles within a layer by checking each tiles collision group data (typically defined in Tiled within the tileset collision editor). If any objects are found within a tiles collision group, the tiles colliding information will be set. The collides parameter controls if collision will be enabled (true) or disabled (false).

  If no layer is specified, the maps current layer is used.

  Parameters

  • Optionalcollides: boolean

    If true it will enable collision. If false it will clear collision.
  • OptionalrecalculateFaces: boolean

    Whether or not to recalculate the tile faces after the update.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

setLayer

• setLayer(layer?: string | number | TilemapLayer): this

  Sets the current layer to the LayerData associated with layer.

  Parameters

  • Optionallayer: string | number | TilemapLayer

    The name of the layer from Tiled, the index of the layer in the map or a TilemapLayer. If not given will default to the maps current layer index.

  Returns this

setLayerTileSize

• setLayerTileSize(
      tileWidth: number,
      tileHeight: number,
      layer?: string | number | TilemapLayer,
  ): this

  Sets the tile size for a specific layer. Note: this does not necessarily match the maps tileWidth and tileHeight for all layers. This will set the tile size for the layer and any tiles the layer has.

  Parameters

  • tileWidth: number

    The width of the tiles (in pixels) in the layer.
  • tileHeight: number

    The height of the tiles (in pixels) in the layer.
  • Optionallayer: string | number | TilemapLayer

    The name of the layer from Tiled, the index of the layer in the map or a TilemapLayer. If not given will default to the maps current layer index.

  Returns this

setRenderOrder

• setRenderOrder(renderOrder: string | number): this

  Sets the rendering (draw) order of the tiles in this map.

  The default is 'right-down', meaning it will order the tiles starting from the top-left, drawing to the right and then moving down to the next row.

  The draw orders are:

  0 = right-down 1 = left-down 2 = right-up 3 = left-up

  Setting the render order does not change the tiles or how they are stored in the layer, it purely impacts the order in which they are rendered.

  You can provide either an integer (0 to 3), or the string version of the order.

  Calling this method after creating Tilemap Layers will not automatically update them to use the new render order. If you call this method after creating layers, use their own setRenderOrder methods to change them as needed.

  Parameters

  • renderOrder: string | number

    The render (draw) order value. Either an integer between 0 and 3, or a string: 'right-down', 'left-down', 'right-up' or 'left-up'.

  Returns this

setTileIndexCallback

• setTileIndexCallback(
      indexes: number | number[],
      callback: Function,
      callbackContext: object,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets a global collision callback for the given tile index within the layer. This will affect all tiles on this layer that have the same index. If a callback is already set for the tile index it will be replaced. Set the callback to null to remove it. If you want to set a callback for a tile at a specific location on the map then see setTileLocationCallback.

  If no layer is specified, the maps current layer is used.

  Parameters

  • indexes: number | number[]

    Either a single tile index, or an array of tile indexes to have a collision callback set for. All values should be integers.
  • callback: Function

    The callback that will be invoked when the tile is collided with.
  • callbackContext: object

    The context under which the callback is called.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

setTileLocationCallback

• setTileLocationCallback(
      tileX: number,
      tileY: number,
      width: number,
      height: number,
      callback: Function,
      callbackContext?: object,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Sets a collision callback for the given rectangular area (in tile coordinates) within the layer. If a callback is already set for the tile index it will be replaced. Set the callback to null to remove it.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • tileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • width: number

    How many tiles wide from the tileX index the area will be.
  • height: number

    How many tiles tall from the tileY index the area will be.
  • callback: Function

    The callback that will be invoked when the tile is collided with.
  • OptionalcallbackContext: object

    The context under which the callback is called.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

shuffle

• shuffle(
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Shuffles the tiles in a rectangular region (specified in tile coordinates) within the given layer. It will only randomize the tiles in that area, so if they're all the same nothing will appear to have changed! This method only modifies tile indexes and does not change collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

swapByIndex

• swapByIndex(
      tileA: number,
      tileB: number,
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Scans the given rectangular area (given in tile coordinates) for tiles with an index matching indexA and swaps then with indexB. This only modifies the index and does not change collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileA: number

    First tile index.
  • tileB: number

    Second tile index.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

tileToWorldX

• tileToWorldX(
      tileX: number,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): number

  Converts from tile X coordinates (tile units) to world X coordinates (pixels), factoring in the layers position, scale and scroll.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The x coordinate, in tiles, not pixels.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns number

tileToWorldXY

• tileToWorldXY(
      tileX: number,
      tileY: number,
      vec2?: Math.Vector2,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Math.Vector2

  Converts from tile XY coordinates (tile units) to world XY coordinates (pixels), factoring in the layers position, scale and scroll. This will return a new Vector2 object or update the given point object.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileX: number

    The x coordinate, in tiles, not pixels.
  • tileY: number

    The y coordinate, in tiles, not pixels.
  • Optionalvec2: Math.Vector2

    A Vector2 to store the coordinates in. If not given a new Vector2 is created.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Math.Vector2

tileToWorldY

• tileToWorldY(
      tileY: number,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): number

  Converts from tile Y coordinates (tile units) to world Y coordinates (pixels), factoring in the layers position, scale and scroll.

  If no layer is specified, the maps current layer is used.

  Parameters

  • tileY: number

    The y coordinate, in tiles, not pixels.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns number

weightedRandomize

• weightedRandomize(
      weightedIndexes: object[],
      tileX?: number,
      tileY?: number,
      width?: number,
      height?: number,
      layer?: string | number | TilemapLayer,
  ): Tilemaps.Tilemap

  Randomizes the indexes of a rectangular region of tiles (in tile coordinates) within the specified layer. Each tile will receive a new index. New indexes are drawn from the given weightedIndexes array. An example weighted array:

  [ { index: 6, weight: 4 }, // Probability of index 6 is 4 / 8 { index: 7, weight: 2 }, // Probability of index 7 would be 2 / 8 { index: 8, weight: 1.5 }, // Probability of index 8 would be 1.5 / 8 { index: 26, weight: 0.5 } // Probability of index 27 would be 0.5 / 8 ]

  The probability of any index being picked is (the indexs weight) / (sum of all weights). This method only modifies tile indexes and does not change collision information.

  If no layer is specified, the maps current layer is used.

  Parameters

  • weightedIndexes: object[]

    An array of objects to randomly draw from during randomization. They should be in the form: { index: 0, weight: 4 } or { index: [0, 1], weight: 4 } if you wish to draw from multiple tile indexes.
  • OptionaltileX: number

    The left most tile index (in tile coordinates) to use as the origin of the area.
  • OptionaltileY: number

    The top most tile index (in tile coordinates) to use as the origin of the area.
  • Optionalwidth: number

    How many tiles wide from the tileX index the area will be.
  • Optionalheight: number

    How many tiles tall from the tileY index the area will be.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Tilemaps.Tilemap

worldToTileX

• worldToTileX(
      worldX: number,
      snapToFloor?: boolean,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): number

  Converts from world X coordinates (pixels) to tile X coordinates (tile units), factoring in the layers position, scale and scroll.

  If no layer is specified, the maps current layer is used.

  You cannot call this method for Isometric or Hexagonal tilemaps as they require both worldX and worldY values to determine the correct tile, instead you should use the worldToTileXY method.

  Parameters

  • worldX: number

    The x coordinate to be converted, in pixels, not tiles.
  • OptionalsnapToFloor: boolean

    Whether or not to round the tile coordinate down to the nearest integer.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns number

worldToTileXY

• worldToTileXY(
      worldX: number,
      worldY: number,
      snapToFloor?: boolean,
      vec2?: Math.Vector2,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): Math.Vector2

  Converts from world XY coordinates (pixels) to tile XY coordinates (tile units), factoring in the layers position, scale and scroll. This will return a new Vector2 object or update the given point object.

  If no layer is specified, the maps current layer is used.

  Parameters

  • worldX: number

    The x coordinate to be converted, in pixels, not tiles.
  • worldY: number

    The y coordinate to be converted, in pixels, not tiles.
  • OptionalsnapToFloor: boolean

    Whether or not to round the tile coordinate down to the nearest integer.
  • Optionalvec2: Math.Vector2

    A Vector2 to store the coordinates in. If not given a new Vector2 is created.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns Math.Vector2

worldToTileY

• worldToTileY(
      worldY: number,
      snapToFloor?: boolean,
      camera?: Cameras.Scene2D.Camera,
      layer?: string | number | TilemapLayer,
  ): number

  Converts from world Y coordinates (pixels) to tile Y coordinates (tile units), factoring in the layers position, scale and scroll.

  If no layer is specified, the maps current layer is used.

  You cannot call this method for Isometric or Hexagonal tilemaps as they require both worldX and worldY values to determine the correct tile, instead you should use the worldToTileXY method.

  Parameters

  • worldY: number

    The y coordinate to be converted, in pixels, not tiles.
  • OptionalsnapToFloor: boolean

    Whether or not to round the tile coordinate down to the nearest integer.
  • Optionalcamera: Cameras.Scene2D.Camera

    The Camera to use when calculating the tile index from the world values.
  • Optionallayer: string | number | TilemapLayer

    The tile layer to use. If not given the current layer is used.

  Returns number