Technical Documentation: mapeditor/tiled

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (`README.md`)

Tiled Map Editor - https://www.mapeditor.org/

About Tiled

Tiled is a general purpose tile map editor for all tile-based games, such as
RPGs, platformers or Breakout clones.

Tiled is highly flexible. It can be used to create maps of any size, with no
restrictions on tile size, or the number of layers or tiles that can be used.
Maps, layers, tiles, and objects can all be assigned arbitrary properties.
Tiled's map format (TMX) is easy to understand and allows multiple tilesets to
be used in any map. Tilesets can be modified at any time.

Installing Tiled

Tiled is available for all major operating systems and can be downloaded either
from GitHub Releases or from
itch.io. Most Linux distributions also
package Tiled, but these packages are usually out of date so you might prefer
to use the AppImage or install Tiled through
Flatpak or
snap, both of which are official releases.

Signed Releases for macOS and Windows

macOS builds are signed by the maintainer, Thorbjørn Lindeijer, who registered
as Apple Developer.

Windows installers are using free code signing provided by
SignPath.io,
and a free code signing certificate by the
SignPath Foundation.

Compiling Tiled

Before you can compile Tiled, you must ensure the Qt (>= 6.2) development
libraries have been installed as well as the Qbs build tool:

On Ubuntu/Debian: sudo apt install qt6-base-dev libqt6svg6 libqt6test6 qt6-l10n-tools qt6-declarative-dev zlib1g-dev qbs
On Fedora: sudo dnf builddep tiled
On Arch Linux: sudo pacman -S qt6-declarative qt6-svg qt6-tools qbs
On macOS with Homebrew:
- brew install qbs qttools (which automatically pulls in qt)

If you want to build the Python plugin, you additionally need to install the
Python 3 development libraries:

On Ubuntu/Debian: sudo apt install python3-dev
On Windows: https://www.python.org/downloads/windows/

Alternatively, you can download Qt here.
You will still need to install a development environment alongside and some
libraries depending on your system, for example:

On Ubuntu/Debian: sudo apt install build-essential zlib1g-dev libgl1-mesa-dev
On Windows: Choose "MinGW" Qt version, or install Visual Studio
On macOS: Install Xcode

The easiest way to compile and run Tiled is to open tiled.qbs in Qt Creator
and run the project from there.

From the command-line, you may need to set up Qbs before you can build Tiled
(you will also need to make sure the version of Qt you want to use is in your
path):

text

qbs setup-toolchains --detect     # setup toolchains
qbs                               # build Tiled

You can now run Tiled as follows:

text

qbs run -p tiled

Qt 6

For compiling libtiledquick (not built by default) you'll need to install the
Vulkan headers:

On Ubuntu/Debian: sudo apt install libvulkan-dev

Working with Visual Studio 2017

Once Qbs is set up (see previous instructions), it is possible to generate a
Visual Studio 2017 project with it that allows you to code, compile and run
using that IDE. This can be done with the following command:

text

qbs generate -g visualstudio2017

Installing Self-Compiled Tiled

To install Tiled, run qbs install from the terminal. By default, Tiled will
be installed to /install-root.

The installation prefix can be changed when building Tiled. For example, to use
an installation prefix of /usr:

text

qbs qbs.installPrefix:"/usr"

To install Tiled to a packaging directory:

text

qbs install --install-root /tmp/tiled-pkg

By default, Tiled and its plugins are compiled with an Rpath that allows them
to find the shared libtiled library immediately after being compiled. When
packaging Tiled for distribution, the Rpath should be disabled by appending
projects.Tiled.useRPaths:false to the qbs command.

Overview (`docs/README.md`)

Generating the Tiled Documentation

This guide covers how to generate the Tiled documentation on various platforms using a virtual environment. You'll need Python 3 installed.

Prerequisites

Python 3
pip (Python package installer)

Setting Up a Virtual Environment

It's recommended to use a virtual environment to isolate the project dependencies. Here's how to set it up:

Linux (Ubuntu, Fedora, RHEL, CentOS) and macOS

bash

python3 -m venv .venv
source .venv/bin/activate

Windows

cmd

python -m venv .venv
.venv\Scripts\activate

Installing Dependencies

After activating the virtual environment, install the required packages using the requirements.txt file:

bash

pip install -r requirements.txt

Generating the Documentation

With the virtual environment activated and dependencies installed, you can generate the documentation by running:

bash

make html

On Windows, use:

cmd

make.bat html

Using a Different Language

Add O=-Dlanguage=<language> to the above command, where <language> should be replaced by a language code like fr, de, etc.

Updating Translation Files

To update the translation files before tagging a new release:

Ensure your virtual environment is activated.
Generate the .pot files:
bash
```
make gettext
```
Update the .po files for German and French:
bash
```
sphinx-intl update -p _build/gettext -l de -l fr
```

Note: Currently, only German and French translations are hosted. Additional languages can be added if there's sufficient interest in maintaining those translations.

Deactivating the Virtual Environment

When you're done working on the documentation, you can deactivate the virtual environment:

bash

deactivate

Requirements

The requirements.txt file in the documentation directory specifies the required packages and their versions. If you need to view or update these requirements, you can find them in this file.

Remember to activate the virtual environment each time you work on the documentation, and to update your virtual environment if requirements.txt changes:

bash

pip install -r requirements.txt

This ensures you're always using the correct versions of the dependencies for building the documentation.

Overview (`docs/scripting-doc/README.md`)

tiled-api

This package includes TypeScript definitions for the Tiled scripting API which
(depending on your editor support) also allow you to write simple JavaScript
scripts with automatic code completion.

Online documentation

See: https://www.mapeditor.org/docs/scripting

Writing a Tiled plugin with code completion in VS Code

Create a new project:

bash

mkdir example-tiled-ts-plugin
cd example-tiled-ts-plugin
npm init

Install the Tiled definitions:

bash

npm install @mapeditor/tiled-api --save-dev

Write your plugin and enjoy code-completion:

/// <reference types="@mapeditor/tiled-api" />

const action = tiled.registerAction("CustomAction", function(action) {
    tiled.log(action.text + " was " + (action.checked ? "checked" : "unchecked"))
})

action.text = "My Custom Action"
action.checkable = true
action.shortcut = "Ctrl+K"

tiled.extendMenu("Edit", [
    { action: "CustomAction", before: "SelectAll" },
    { separator: true }
]);

Of course, when writing TypeScript code instead of JavaScript you also get
compilation errors instead of only syntax highlighting.

Overview (`examples/sticker-knight/README.md`)

Sticker Knight platformer example

This example is by @ponywolf and released to the public domain. You can
find it at http://opengameart.org/content/sticker-knight-platformer.

It's a great example of using the flexible image collection tilesets with
tiles on object layers, for both the map and the UI.

Overview (`src/karchive/README.md`)

KArchive

Reading, creating, and manipulating file archives

Introduction

KArchive provides classes for easy reading, creation and manipulation of
"archive" formats like ZIP and TAR.

It also provides transparent compression and decompression of data, like the
GZip format, via a subclass of QIODevice.

Usage

If you want to read and write compressed data, just create an instance of
KCompressionDevice and write to or read from that.

If you want to read and write archive formats, create an instance of the
appropriate subclass of KArchive (eg: K7Zip for 7-Zip files). You may need to
combine this with usage of KCompressionDevice (see the API documentation for the
relevant KArchive subclass for details).

Overview (`util/java/README.md`)

Java library and sample project to view Tiled files

Folders description

libtiled-java - contains source code for a library that adds support of Tiled maps to your java project.
tmx-viewer-java - sample project, that uses libtiled-java to view Tiled map files.

Every folder contains a README.md related to its contents.

Packaging the project

Make sure you have properly installed Apache Maven on your computer.

Open current folder in terminal (cmd, power shell, etc) and run the command:

text

mvn package

As the command run has completed, check the following folders:

/libtiled-java/target and tmxviewer-java/target for generated jar files.

Overview (`util/java/libtiled-java/README.md`)

libtiled - Java library to work with Tiled maps

This is a small library meant to make it easy to use Tiled maps in your Java
project. It is based on the Java version of Tiled.

This small library is BSD licensed. See the LICENSE.BSD file for details.

Authors

Adam Turk [email protected]
Thorbjørn Lindeijer
Mike Thomas [email protected]

https://www.mapeditor.org/

Maven

Add into <dependencies> of your pom.xml:

xml

<dependency>
      <groupId>org.mapeditor</groupId>
      <artifactId>libtiled</artifactId>
      <version>x.y.z</version>
    </dependency>

Consult the Maven repository for the latest org.mapeditor/libtiled version.

sbt

Add the following to your build.sbt:

text

libraryDependencies += "org.mapeditor" % "libtiled" % "x.y.z"

Excluding unused dependencies

libtiled depends on zstd-jni to read and
write zstd-compressed layer data and on
jsvg to render SVG tilesets. If your project
uses neither, you can exclude them to reduce its size:

xml

<dependency>
      <groupId>org.mapeditor</groupId>
      <artifactId>libtiled</artifactId>
      <version>x.y.z</version>
      <exclusions>
        <exclusion>
          <groupId>com.github.luben</groupId>
          <artifactId>zstd-jni</artifactId>
        </exclusion>
        <exclusion>
          <groupId>com.github.weisj</groupId>
          <artifactId>jsvg</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

Loading a zstd-compressed map or an SVG tileset without the respective
dependency fails with an error naming the missing dependency.

Building

To make libtiled.jar, install Apache Maven and run the following command:

text

mvn clean install

To run all unit-tests, run the following command:

text

mvn test -P release-profile

To generate reports and documentation, run:

text

mvn site

Overview (`util/java/tmxviewer-java/README.md`)

Java TMX Viewer example

This is a simple example application showing how to use libtiled-java to load
and view a Tiled map file.

Opening the project in a modern IDE

Just import this project as a Maven project, specifying the project pom.xml
file location.

Trying it out from the command line

The tmxviewer-java needs libtiled-java to be compiled first to add libtiled
dependency to your local Maven repository.

The Apache Maven build tool is used to build from the command line.

Run mvn clean install in the libtiled-java directory to build libtiled.jar
Go to the tmxviewer-java directory and run mvn clean install there to compile it
Launch the TMX Viewer using java -jar tmxviewer-<Version>.jar [file]

Index (`docs/index.rst`)

Tiled Documentation

.. note::

If you're not finding what you're looking for on these pages, please don't
hesitate to ask questions on the Tiled Forum <https://discourse.mapeditor.org>_
or the Tiled Discord <https://discord.gg/39wbTv7>_.

.. toctree::
:maxdepth: 2
:caption: User Manual

manual/introduction
manual/projects
manual/maps
manual/layers
manual/editing-tile-layers
manual/objects
manual/editing-tilesets
manual/custom-properties
manual/using-templates
manual/terrain
manual/using-infinite-maps
manual/worlds
manual/using-commands
manual/automapping
manual/export
manual/keyboard-shortcuts
manual/preferences
manual/scripting

.. toctree::
:maxdepth: 2
:caption: Reference

reference/support-for-tmx-maps
reference/tmx-map-format
reference/tmx-changelog
reference/json-map-format
reference/global-tile-ids

Requirements (`docs/requirements.txt`)

Sphinx >= 8, < 9
docutils >= 0.20, < 0.22
myst-parser >= 4.0
sphinx-docsearch >= 0.1
sphinx-reredirects >= 0.1
sphinx-rtd-theme >= 3
sphinx_design >= 0.6.1

Manual Automapping (`docs/manual/automapping.md`)

Automapping

What is Automapping?

Automapping can automatically place or replace tiles based on rules you define. It looks for tiles in your working map that match each rule's input, and if it finds any, it'll place the corresponding output. This enables complex or repetitive tile placement to be entirely automated, which can make decorating your levels much faster, and can help you automatically correct mistakes.

If your tiles are set up to work as corners and edges of shapes, you may want to look into using Terrains instead. Terrains provide a more convenient way to automate placement of such tiles.

Automapping can be applied manually via Map > AutoMap, or dynamically as you draw on the map if you enable Map > AutoMap While Drawing.

:::{note}
Automapping changed significantly in Tiled 1.9. It's 10-30x faster and setting up rules is more intuitive, but it behaves differently from the old system in some ways. Old rules should still behave the same, but you may want to take a look at the section on updating your rules. If you need help understanding your old rules, the old documentation is available on GitHub.

If you are making new rules, make sure you do not have any regions layers. These will enable the old Automapping system, and the rules will likely not behave as you intend.
:::

Setting Up the Rules File

Automapping rules are defined in regular map files, which we’ll call rule maps. These files are then referenced by a text file, usually called rules.txt. The rules.txt can list any number of rule maps, in the order in which their rules should be applied.

There are two ways to make the rule maps defined in the rules.txt apply to a map:

{bdg-secondary-line}Since Tiled 1.4 Open Project > Project Properties and set the "Automapping rules" property to the rules.txt file that you created in your project. If you have only a single rule map, you can also refer to that map file directly.
Alternatively, you can save your rules.txt in the same directory as the map files to which you want the rules to apply. This can also be used to override the project-wide rules for a certain set of maps.

Each line in the rules.txt file is either:

A path to a rule map.
A path to another .txt file which has the same syntax (e.g. in another directory).
{bdg-secondary-line}Since Tiled 1.9 A map filename filter, enclosed in [] and using * as a wildcard.
A comment, when the line starts with # or //.

By default, all Automapping rules will run on any map you Automap. The map filename filters let you restrict which maps rules apply to. For example, any rule maps listed after [town*] will only apply to maps whose filenames start with “town”. To start applying rules to all maps again, you can use [*], which will match any map name.

Setting Up a Rule Map

A rule map is a standard map file, which can be read and written by Tiled (usually in TMX or TMJ format). A rule map can define any number of rules. At a minimum, a rule map contains:

One or more input layers, describing which kind of pattern(s) the working map will be searched for.
One or more output layers, describing how the working map is changed when an input pattern is found.

In addition, custom properties on the rule map, its layers and on objects can be used to fine-tune the overall behavior or the behavior of specific rules.

Every contiguous region of tiles on the input and output layers is a rule. Tiles are considered contiguous if they're next to each other vertically, horizontally, or diagonally (8-way connectivity). You can include many rules in one map, as long as you leave space between them. By default all the rules will match simultaneously, and apply their outputs in order from top to bottom, left to right - rules with smaller Y value come first, and if there are rules at the same Y value, then the rules with smaller X come first. If you want the rules to match in order and take previous rules' output into account, you can use the MatchInOrder map property.

Defining Inputs

The input layers define the pattern(s) of tiles that a rule will look for. These are Tile Layers, and their names must follow this scheme:

text

input[not][index]_name

After the first underscore there will be the name of the target input layer. For example, input_Ground will look for tiles on a layer called Ground. The input layer name can include more underscores, so input_test_case will look for tiles on a layer called test_case. If the working map includes multiple layers by this name, the bottom-most one will be used. If the working map does not contain the named target layer, the rule checks against a dummy empty layer.

The not is optional. If present, it inverts the layer's meaning, so instead of matching the tiles on the layer, Tiled will match anything but those tiles.

The index is optional. Indices on input layers allow you to create rules that match any of several completely separate inputs. Any inputs with the same index are treated as part of the same condition, and each different index is its own independent set of conditions. Any of these conditions being matched will count as a match for the rule. An index can be empty, or it can be any string that doesn't start with not and doesn't contain any underscores.

Multiple input layers having the same name and index is explicitly allowed and is intended. Having multiple input layers of the same name and index allows you to define different possible tiles per coordinate as input, and any combination of those tiles will count as a match.

Input Example

Let's say you want to match two-tile areas of the ground, perhaps to randomise them. You might want to match any combination of grass and flower tiles, but only whole two-tile rocks. You can achieve this like so:

Tile Layer	Name
	input1_Ground
	input1_Ground
	input2_Ground

The first two layers both have the index 1, so Automapping will match any combination of those grass and flower tiles. The last layer has the index 2, so its tiles are checked separately. This means these inputs will match any part of the Ground layer that looks like any of these:

{bdg-secondary-line}Since Tiled 1.9

(specialtiles)=

Matching Special Cases

In some cases, your tiles alone aren't enough to define the scenario you want to match. Tiled provides a built-in “Automapping Rules Tileset” to handle certain special cases, which can be added to your rule map through Map > Add Automapping Rules Tileset.

[Empty]{.tile .empty}
: This tile matches any empty cell. If used on an output layer, this tile will output an empty tile, allowing you to erase tiles with Automapping.

[Ignore]{.tile .ignore}
: This tile does not affect the rule in any way. Its only function is to allow connecting otherwise disconnected parts into a single rule, but it can also be used for clarity.

[NonEmpty]{.tile .nonempty}
: This tile matches any non-empty cell.

[Other]{.tile .other}
: This tile matches any cell, which contains a tile that is different from all the tiles used by the current rule targeting the same input layer. This includes empty cells, unless the Empty tile is explicitly used elsewhere by the rule (since Tiled 1.10).

[Negate]{.tile .negate}
: This tile negates the condition at a specific location, making other input layers with the same target layer name act like inputnot and vice versa, but only in that location, which can simplify your rules in some cases.

The meaning of these tiles is derived from their custom MatchType property. This means that you can set up your own tiles for matching these special cases as well!

Defining Outputs

The output layers define what will be output when the input of the rule matches something in the working map. These can be Tile or Object Layers, and their names must follow this scheme, which is similar to that of input layer names:

text

output[index]_name

Everything after the first underscore is the name, which determines which layer in the working map the tiles or objects will be placed on. If the working map includes multiple layers by this name, the bottom-most one will be used. If the rule matches and the working map does not already contain the named output layer, Automapping will create the layer.

The index is optional, and is not related to the input indices. Instead, output indices are used to randomize the output: every time the rule finds a match, a random output index is chosen and only the output layers with that index will have their contents placed into the working map.

{bdg-primary}New in Tiled 1.11
For convenience, Tiled 1.11 introduced two changes to the behavior related to indexes. If an output index is completely empty for a given rule, it will never be chosen for that rule. This is useful when some rules have more random options than others. Also, when no index is specified, that part of the rule's output will always apply when the rule matches. This can be used to combine an unconditional part of a rule's output with a random part.

Random Output Example

Continuing with the example from before, you can use output layers like these to randomise the Ground layer:

Tile Layer	Name
	output1_Ground
	output2_Ground
	output3_Ground
	output4_Ground

By default, the output of a rule is allowed to overlap previous output from the same rule, which isn't always what you want. In the example above, the output rocks can be partially overwritten by subsequent outputs from that rule. You can set the NoOverlappingOutput map property to true to avoid this. This will only apply to rules overlapping their own output, however - outputs from different rules will still be allowed to overlap. If you want to avoid any kind of overlap, you will need to design your inputs such that your inputs are specific enough for different rules to not overlap.

{figure} images/automapping/automap_output_overlap2.png

:alt: Automap output with numerous half-rocks where different outputs overlapped each other.

Because outputs are allowed to overlap each other and the inputs aren't very specific, the two-tile rock outputs are overlapped by subsequent outputs.

{figure} images/automapping/automap_output_overlap3.png

:alt: Automap output where each rock is whole.

With **NoOverlappingOutput** set to `true`, outputs don't overlap and all the rocks are whole.

Sometimes, you may want certain outputs to appear more or less frequently than others. The above example would look much nicer if the flowers and rocks didn't appear quite so often. You can control the probability of an output index by setting the Probability layer property on one of the layers for that index.

{figure} images/automapping/automap_output_overlap1.png

:alt: Automap output where most of the ground is grass, with a few flowers and just one rock.

Setting the **Probability** of the grass output to 20 and the **Probability** of the rock output to 0.5 produces much nicer-looking results.

(objectRegion)=
:::{warning}
While Automapping can output Objects, there are some caveats when it comes to detecting whether they're part of a given rule's output:

Object rotation is not taken into account.
Tile Objects' Object Alignment is not taken into account.
Ellipse and Text Objects use their bounding rectangles.
Point positions are checked exclusively, a Point must be within a given cell to count as part of it, merely touching the cell is not enough.
Polygons and Polylines are checked as if they were Points at their position, the rest of the shape is not taken into account.

You can ensure these Objects are output by putting [Ignore]{.tile .ignore} special tiles in a tile output layer at their position. You may also need to connect this tile to the rest of the rule with more Ignore tiles to make sure it isn't treated as a separate rule.
:::

Any custom properties set on an output layer (other than Probability) will be copied to the target layer when the output is applied. You should normally not need to add any such properties to output layers, but this can be a way to automate setting properties on your layers based on their contents.

Automapping Properties

The behavior of your rules can be modified by properties on the rules map, input and output layers, and on a per-rule basis using objects.

Map Properties

(DeleteTiles)=
DeleteTiles
: This is a boolean map property. When this property is true, the area covered by tiles in input layers is erased from the output layers before applying the rules. This property is mostly provided for backwards compatibility, because since Tiled 1.9 tiles can be erased by outputting the [Empty]{.tile .empty} special tile, which is more explicit and more flexible.

Despite the name, this property affects output Object Layers too, deleting any Objects that fully or partially overlap the erased region. This is currently the only way to delete Objects via Automapping.

:::{warning}
All the caveats of outputting objects also apply when deleting them, see the warning in the Defining Outputs section.
:::

(AutomappingRadius)=
AutomappingRadius
: This map property is a number: 1, 2, 3 … When using Automap While Drawing, this property determines how far beyond the tiles affected by your changes Automapping will look for matches.

MatchOutsideMap {bdg-secondary-line}Since Tiled 1.2
: This boolean map property determines whether rules can match even when their input region falls partially outside of a map. By default it is false for bounded maps and true for infinite maps. In some cases it can be useful to enable this for bounded maps. Tiles outside of the map boundaries are simply considered empty, unless one of either OverflowBorder or WrapBorder are also true.

Tiled 1.0 and 1.1 behaved as if this property was true, whereas older versions of Tiled behaved as if this property was false.

OverflowBorder {bdg-secondary-line}Since Tiled 1.3
: This boolean map property customizes the behavior of the MatchOutsideMap property. When this property is true, tiles outside of the map boundaries are considered as if they were copies of the nearest inbound tiles, effectively “overflowing” the map’s borders to the outside region.

When this property is true, it implies MatchOutsideMap. Note that this property has no effect on infinite maps (since there is no notion of border).

WrapBorder {bdg-secondary-line}Since Tiled 1.3
: This boolean map property customizes the behavior of the MatchOutsideMap property. When this property is true, the map effectively “wraps” around itself, making tiles on one border of the map influence the regions on the other border and vice versa.

When this property is true, it implies MatchOutsideMap. Note that this property has no effect on infinite maps (since there is no notion of border).

If both WrapBorder and OverflowBorder are true, WrapBorder takes precedence over OverflowBorder.

(MatchInOrder)=
MatchInOrder {bdg-secondary-line}Since Tiled 1.9
: When this boolean map property is set to true, each rule is applied immediately after a match is found. This disables concurrent matching of rules, but allows each rule to take into account the output of the previously applied rules (as used to be the case before Tiled 1.9).

Alternatively, you can split up your rules over multiple rule maps. Rule maps are always applied in order, so each rule map can rely on any modifications applied by previous rule maps.

Layer Properties

The following properties are supported on a per-layer basis:

(AutoEmpty)=
AutoEmpty (alias: StrictEmpty)
: This boolean layer property can be added to input and inputnot layers to customize the behavior for empty tiles within a rule.

Normally, empty tiles are simply ignored. When AutoEmpty is true, empty tiles within the input region match empty tiles in the target layer. This can only happen when you have multiple input/inputnot layers and some of the tiles that are part of the same rule are empty while others are not. Usually, using the [Empty]{.tile .empty} special tile is the best way to specify an empty tile, but this property is useful when you have multiple input layers, some of which need to match many empty tiles. Note that the input region is defined by all input layers, regardless of index.

IgnoreHorizontalFlip {bdg-primary}New in Tiled 1.11
: This boolean layer property can be added to input and inputnot layers to also match horizontally flipped versions of the input tile.

IgnoreVerticalFlip
: This boolean layer property can be added to input and inputnot layers to also match vertically flipped versions of the input tile.

IgnoreDiagonalFlip
: This boolean layer property can be added to input and inputnot layers to also match anti-diagonally flipped versions of the input tile. This kind of flip is used for 90-degree rotation of tiles.

IgnoreHexRotate120
: This boolean layer property can be added to input and inputnot layers to also match 120-degree rotated tiles on hexagonal maps. However, note that Automapping currently does not really work for hexagonal maps since it does not take into account the staggered axis.

(outputProbability)=
Probability {bdg-secondary-line}Since Tiled 1.10
: This float layer property can be added to output layers to control the probability that a given output index will be chosen. The probabilities for each output index are relative to one another, and default to 1.0. For example, if you have outputA with probability 2 and outputB with probability 0.5, A will be chosen four times as often as B. If multiple output layers with the same index have their Probability set, the last (top-most) layer's probability will be used.

{bdg-secondary-line}Since Tiled 1.9

(object-properties)=

Object Properties

A number of options can be set on individual rules, even within the same rule map. To do this, add an Object Layer to your rule map called rule_options. On this layer, you can create plain rectangle objects and any options you set on these objects will apply to all rules they contain.

The following options are supported per-rule:

ModX
: Only apply a rule every N tiles on the X axis (defaults to 1).

ModY
: Only apply a rule every N tiles on the Y axis (defaults to 1).

OffsetX
: An offset applied in combination with ModX (defaults to 0).

OffsetY
: An offset applied in combination with ModY (defaults to 0).

Probability
: The chance that a rule applies at all, even if its input layers would have matched, from 0 to 1. A value of 0 effectively disables the rule, whereas a value of 1 (the default) means it is never skipped.

Disabled
: A convenient way to (temporarily) disable some rules (defaults to false).

(NoOverlappingOutput)=
NoOverlappingOutput
: When set to true, the output of a rule is not allowed to overlap other outputs of the same rule (defaults to false).

(IgnoreLock)=
IgnoreLock {bdg-secondary-line}Since Tiled 1.10
: Since Tiled 1.10, Automapping rules no longer modify locked layers. Set this property to true to ignore the lock. This can be useful when you have layers that are only changed by rules and want to keep them locked.

All these options can also be set on the rule map itself, in which case they apply as defaults for all rules, which can then be overridden for specific rules by placing rectangle objects.

Examples

RPG Cliffs

A common Automapping scenario is to automate the placement of cliff sides. Tilesets will often include cliff tiles like this:

Terrains can be used to place the top of the cliff, but they cannot reliably add the vertical cliffs themselves. Fortunately, they are no problem for Automapping.

{figure} images/automapping/automap_example1.png

:alt: Cliff top tiles with no sides.

The starting map: the flat top of a cliff painted using Terrains.

{figure} images/automapping/automap_example2.png

:alt: The same cliff, with sides added.

Automapping can add the appropriate cliff tiles.

The bottom side and bottom corners of the cliff are the only ones that need cliff tiles in this tileset, so only three rules are needed to add those. The rules are shown below, layer by layer.

Tile Layer	Name
	input_Cliff
	output1_Cliff
	output2_Cliff

The two output layers differ only in which tile is output by the middle rule, the two corner output tiles are the same in both cases. These three rules get us most of the way there, but there are still some small issues:

{figure} images/automapping/automap_example7.png

:alt: The same cliff example as before, with cliffs added, but with some tiles not quite connecting correctly.

The result of the rules above.

{figure} images/automapping/automap_example8.png

:alt: The same example, with the problem tiles circled in yellow.

The bottom corners and sides of the cliff are circled here because they should use different tiles when they're next to a cliff tile.

This tileset includes tiles for the sides and bottom corners of the cliff top when they're next to a cliff, so you can make another rule map to place those. Since there are left and right side tiles and left and right corner tiles, you will need four rules.

You could create rules that check for a literal cliff tiles next to these tiles, but that would require enumerating every tile that counts as a cliff - all the cosmetic variants of straight cliff section, the cliff corners, and if you're not careful, you might still miss some edge cases like two cliff sides facing each other. A simpler approach would be check whether the tile above this side or corner is a concave corner tile: if it is, then you know that the tile next to it will be something with a cliff.

Tile Layer	Name
	input_Cliff
	input_Cliff
	output_Cliff

There is no need to repeat the side and corner tiles on the second "input_Cliff" layer, you can leave those cells empty and only include the extra input tiles that you need.

With these additional rules in place, you should get the result shown at the top of this section: all the cliffs in place, with no transparent holes where sides and corners meet the cliffs.

Since these rules work with a layer called "Cliff", they will not affect cliffs drawn on any other layers. If you want to automap cliffs on several different layers, which may be necessary if you want stacks of cliffs, you'll need to duplicate the rule map and adjust the input and output layer names.

Automap While Drawing

The rules above work well if you draw your cliff tops with Terrains and then manually trigger Automapping, but what if you want to see the cliffs appear as you draw with Terrains, or want to keep drawing with Terrains after automapping manually?

{figure} images/automapping/automap_example14.gif

:alt: Animation showing erasing the cliff top Terrain. The cliff top is updated correctly, but the cliff tiles are not.

Without some extra rules, Automap While Drawing can produce messy results.

For this, your rules will need to take into account tiles that may have previously been placed by Automapping.

:::{hint}
If you're using Automapping While Drawing with Terrains, it also helps for your Terrains to be aware of the tiles that may be output to that same layer by Automapping. In this example, this would mean labeling the side and corner tiles meant to be next to cliffs with the same Terrain labels as their base versions.

This will have the side effect of making Terrains randomly output those tiles where they're not needed, but this can be remedied by setting the tile probability of those tiles to 0 in the Tileset Editor. If you always use those Terrains with Automapping, you can also just let Automapping fix the tiles.
:::

There are two approaches you can take to make your Automapping rules take its own output into account:

Include those tiles as alternate inputs in all the rules, or
Make another set of rules to reset all the alternate tiles to a uniform condition.

The appropriate option will depend on your specific rules. In this case, the latter is simpler: all you have to do is erase any cliff tiles, and replace the variants meant to be placed next to cliffs with their basic versions. For this purpose, you should create another rule map, and place it before the other rules in your rules.txt, so that it can prepare the map for those other rules. The actual rules are just simple substitutions:

Tile Layer	Name
	input_Cliff
	output_Cliff

The output tiles in the top row are the [Empty]{.tile .empty} special tile, which means the output will erase those tiles.

For Automap While Drawing to work correctly, you may also need to increase the AutomappingRadius property of your rules maps. This is because some of the rules may look only at tiles near the ones you change by drawing, such as the rules that erase cliff tiles. In this example, you will probably need to set the AutomappingRadius to 1 on the reset rules and on the rules that add cliffs.

{figure} images/automapping/automap_example15.gif

:alt: Animation showing erasing the cliff top Terrain. This time, everything is updated correctly.

Now, Automap While Drawing produces correct results.

(sidescroller-details)=

Sidescroller Details

You can use Automapping to add various details to your maps. This small example shows adding foreground details to a sidescroller platforms. This tileset features a number of platform tiles, some of which have rocky tops, and some of which have grassy tops. These two rules will add random grass and flower decorations to a different layer corresponding to the grassy-topped tiles, and delete any decorations that end up on top of non-grassy tiles. There are many input layers, because there are many grassy-topped tiles to check.

Tile Layer	Name
	input_Platform
	input_Platform
	input_Platform
	input_Platform
	input_Platform
	input_Platform
	outputA_Foreground
	outputB_Foreground
	outputC_Foreground

The inputs for these rules are identical except for the last input layer, in which the second rule, which deletes the foreground detail tiles, has the [Negate]{.tile .negate} special tile. This makes all those input layers act like inputnot layers, but only in that specific location. This means the first rule matches whenever it encounters any of those grassy-topped tiles, while the second rule matches whenever it encounters anything other than those grassy-topped tiles. The second rule could've also been made with a bunch of inputnot layers instead, but using the Negate tile reduces how many layers this rule map needs, and it's easier to see that the input tiles are negated when the layers are all viewed together:

The three outputs select a random foreground detail for the first rule, and are all Empty for the second rule. One of the outputs for the first rule is also Empty, just for extra variety.

{figure} images/automapping/automap_example26.png

:alt: Platforms with grass and flowers over some of the grassy tiles.

A result from the two rules above.

(updating-rules)=

Updating Legacy Rules

If you have some Automapping rules from before Tiled 1.9, they should still work much as they always did in most cases. When Tiled sees that a rule map contains regions layers, it will automatically bring back the old behavior - rules will be matched in order by default, cells within input regions that are empty in all the input layers for a given layer and index will be treated as "Other", and completely empty output indices will still be selected as valid outputs.

:::{warning}
In Tiled 1.9.x, the presence of regions layers did not imply MatchInOrder. If you're using 1.9.x rather than 1.10+ and want to use legacy rules, you'll need to set the MatchInOrder map property to true.
:::

If you'd like to instead update your rules to not rely on any legacy behavior, that can be as simple as deleting your regions layer(s), or it might take some extra work, depending on how exactly your rules are set up:

If your rules need to take the output of other rules in the same rules map into account, set the MatchInOrder map property to true.
When deleting your regions layers, make sure you weren't relying on them to connect otherwise disconnected areas of tiles. If you were, use the [Ignore]{.tile .ignore} special tile to connect them on one of the input layers, so that Tiled knows they're part of the same rule. To make sure the rules behave exactly the same, fill in any part that was previously part of the input region.
If were using the StrictEmpty map property to look for empty input tiles, you should now use the Empty special tile instead in the cells you want to check for being empty. You can also continue use the StrictEmpty property (or its newer alias, AutoEmpty), as long as at least one other input layer is not empty at those locations.
If were relying on the behavior that any tile which is left empty on all of the input layers for a given index is treated as “any tile not in this rule”, you should instead use the [Other]{.tile .other} special tile at those locations, and also the [Empty]{.tile .empty} special tile on an inputnot layer at those same locations. The Empty tile is needed because old-style Other never matched Empty, but the MatchType Other tile does match Empty.
If you have rules that rely on some output indices being empty to randomly not make any changes, you will need to place Ignore special tiles in at least one layer of each empty output index so that those indices aren't ignored. Alternatively, you can use rule_options to give those rules a chance to not run at all.
If you had rules with random output, but did not specify an index for one of the outputs, this part of the rule's output is now excluded from the options and applied unconditionally instead. If all outputs should be random options, make sure they all have an index. You can automate updating your existing rule maps with the "Add Output Index" script.

Credits

The Sidescroller Details example uses art from A platformer in the forest by Buch.

Manual Custom Properties (`docs/manual/custom-properties.rst`)

Custom Properties

One of the major strengths of Tiled is that it allows setting custom
properties on all of its basic data structures. This way it is possible
to include many forms of custom information, which can later be used by
your game or by the framework you're using to integrate Tiled maps.

Custom properties are displayed in the Properties view. This view is
context-sensitive, usually displaying the properties of the last
selected object. It also supports multi-selection, for changing the
properties of many objects at once.

.. figure:: images/properties/properties-dock.png
:alt: Properties View

Properties View

Adding Properties

When you add a property (using the '+' button at the bottom of the
Properties view), you are prompted for its name and its type.
Tiled supports the following basic property types:

bool (true or false)
color (a 32-bit color value)
file (a file reference, which is saved as a relative path)
float (a floating point number)
int (a whole number)
object (a reference to an object) - Since Tiled 1.4
string (any text, including multi-line text)

.. figure:: images/properties/add-property.png
:alt: Add Property Dialog
:scale: 66

Add Property Dialog

The property type is used to choose a custom editor in the Properties
view. Choosing a number or boolean type also avoids that the value will
get quoted in JSON and Lua exports.

.. raw:: html

Since Tiled 1.4

The context menu for custom file properties provides a quick way to open the
file in its preferred editor. For object references, there is an action to
quickly jump to the referenced object.

.. raw:: html

Since Tiled 1.8

.. _custom-property-types:

Custom Types

In addition to the basic property types listed above, you can define custom
types in your project. Tiled supports :ref:custom enums <custom-enums> and
:ref:custom classes <custom-classes>.

.. figure:: images/properties/property-types-editor.png
:alt: Custom Types Editor

Custom Types Editor

.. note::

These types are automatically saved in the :doc:project file .
Hence you need to create a project, before you can set up your custom
types.

.. _custom-enums:

Custom Enums

text

An enum is useful if you want to limit the options for a certain property to a
fixed set of values.

An enum also defines how its value is saved. It can be saved as a string,
saving one of its values directly. Alternatively it can be saved as a number,
the index of the current value in the list of values. The former is more
readable whereas the latter could easier and more efficient to load.

Finally, an enum can also allow multiple values to be chosen. In this case
each option is displayed with a checkbox. When saving as string, a
comma-separated list is used and when saving as number the selected indexes are
encoded as bitflags. In both cases, the maximum number of flags supported is 31,
since internally a 32-bit signed integer is used to store the value.

.. _custom-classes:

Custom Classes

A class is useful if you want to be able to add a set of properties at once,
with predefined defaults. It can also prevent excessive prefixing of property
names. Classes can have members referring to other classes.

.. _predefining-properties:

.. raw:: html

Since Tiled 1.9

Each data type has a "Class" property, which can be used to refer to a custom
class. The members of this class will then be directly available as custom
properties of that instance (before Tiled 1.9, this feature was only available
for objects and tiles as the "Type" property).

Each class can also have a custom color, which is used to make objects more
recognizable. The class color is used when rendering shape objects, object name
labels and connections between objects.

In the :doc:JSON </reference/json-map-format> and :ref:Lua <lua-export>
file formats, custom class properties used as property values are saved using
the native object and table constructs.

.. raw:: html

Since Tiled 1.0

.. _tile-property-inheritance:

Tile Property Inheritance

When custom properties are added to a tile, these properties will also
be visible when an object instance of that tile is selected. This
enables easy per-object overriding of certain default properties
associated with a tile. This becomes especially useful when combined
with :ref:typed-tiles.

Inherited properties will be displayed in gray (disabled text color),
whereas overridden properties will be displayed in black (usual text
color).

.. raw:: html

Since Tiled 1.0

.. _typed-tiles:

Typed Tiles

text

If you're using :ref:`tile objects <insert-tile-tool>`, you can set the
class on the tile to avoid having to set it on each object instance.
Setting the class on the tile makes the predefined properties visible
when having the tile selected, allowing to override the values. It also
makes those possibly overridden values visible when having a tile object
instance selected, again allowing you to override them.

An example use-case for this would be to define custom classes like "NPC",
"Enemy" or "Item" with properties like "name", "health" or "weight". You
can then specify values for these on the tiles representing these
entities. And when placing those tiles as objects, you can override
those values if you need to.

.. topic:: Future Extensions
   :class: future

   There are several types of custom properties I'd like to add:

   -  **Customized basic properties**, where you can set properties like the
      minimum or maximum value, the precision or a different default value.

   -  **Array properties**, which would be properties having a list of
      values (`#1493 <https://github.com/mapeditor/tiled/issues/1493>`__).

   Apart from predefining properties based on object type, I'd like to add
   support for **predefining the properties for each data type**. So
   defining which custom properties are valid for maps, tilesets, layers,
   etc. (`#1410 <https://github.com/mapeditor/tiled/issues/1410>`__)

   If you like any of these plans, please help me getting around to it
   faster by `sponsoring Tiled development <https://www.mapeditor.org/donate>`__. The
   more support I receive the more time I can afford to spend improving
   Tiled!

---

### Manual Editing Tile Layers (`docs/manual/editing-tile-layers.rst`)

Editing Tile Layers
===================

:ref:`tile-layer-introduction` are what makes Tiled a *tile map editor*.
Although not as flexible as :ref:`object-layer-introduction`, they provide
efficient data storage and good rendering performance as well as efficient
content creation. Every new map gets one by default, though feel free to delete
it when you're not going to use it.

.. _stamp-tool:

Stamp Brush
-----------

Shortcut: ``B`` |stock-tool-clone|

The primary tool for editing tile layers is the Stamp Brush. It can be
used to paint single tiles as well as larger "stamps", which is where it
gets its name from. Using the right mouse button, it can also quickly
capture tile stamps from the currently active layer. A tile stamp is
commonly created by selecting one or more tiles in the Tilesets view.

The Stamp Brush has some extra features:

-  While holding ``Shift``, click any two points to draw a line between
   them.

-  While holding ``Ctrl+Shift``, click any two points two draw a circle
   or ellipse centered on the first point.

-  Activate the *Random Mode* using the dice button on the Tool Options
   toolbar to have the Stamp Brush paint with random tiles from the tile
   stamp. The probability of each tile depends on how often it occurred
   on the tile stamp, as well as the probability set on each tile in the
   *Tileset Editor*.

-  Activate the *Terrain Fill Mode* using the Terrain tile |terrain| button on
   the tool bar to have the Stamp Brush paint using random terrain tiles. This makes
   adjacent tiles match edge and corner terrains to be placed. Terrain tiles are
   described in detail in :doc:`terrain`.

-  In combination with the *Tile Stamps* view, it can also place
   randomly from a set of predefined tile stamps. This can be more
   useful than the *Random Mode*, which randomly places individual
   tiles.

-  You can flip the current tile stamp horizontally/vertically by using
   ``X`` and ``Y`` respectively. You can also rotate left/right by
   using ``Z`` and ``Shift+Z`` respectively. These actions can also be
   triggered from the Tool Options tool bar.

.. _terrain-tool:

Terrain Brush
-------------

Shortcut: ``T`` |terrain-edit|

The Terrain Brush allows for efficient editing with certain types of terrain
transitions (corner-based, edge-based or a combination). Setting it up
requires associating terrain information with your tiles, which is described
in detail in :doc:`terrain`.

Similarly to the :ref:`stamp-tool`, you can draw lines by holding ``Shift``.
When holding ``Ctrl``, the size of the edited area is increased to cover an
entire tile rather than just one corner or edge.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.0</div>

When holding ``Alt``, the editing operations are also applied at a 180
degree rotation. This is especially useful when editing strategic maps
where two sides need to have equal opportunities. The modifier works
well in combination with either ``Shift`` for drawing lines or ``Ctrl``
for increasing the edited area.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.1</div>

.. _bucket-fill-tool:

Bucket Fill Tool
----------------

Shortcut: ``F`` |stock-tool-bucket-fill|

The Bucket Fill Tool provides a quick way of filling empty areas or
areas covered with the same tiles. The currently active tile stamp will
be repeated in the filled area. It can also be used in combination with
the *Random Mode*, or *Terrain Fill Mode*.

When holding ``Shift``, the tool fills the currently selected area
regardless of its contents. This is useful for filling custom areas that
have been selected previously using one or more :ref:`tile-selection-tools`.

You can also flip and rotate the current stamp as described for the
:ref:`stamp-tool`.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.1</div>

.. _shape-fill-tool:

Shape Fill Tool
---------------

Shortcut: ``P`` |rectangle-fill|

This tool provides a quick way to fill rectangles or ellipses with a certain
tile or pattern.

- Holding ``Shift`` fills an exact square or circle.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.10.2</div>

- Holding ``Alt`` draws the rectangle or ellipse centered around the starting
  location.

You can also flip and rotate the current stamp as described for the
:ref:`stamp-tool`.

.. _eraser-tool:

Eraser
------

Shortcut: ``E`` |stock-tool-eraser|

A simple eraser tool. Left click erases single tiles and right click can
be used to quickly erase rectangular areas.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.5</div>

-  Holding ``Shift`` erases on all layers.

.. _tile-selection-tools:

Selection Tools
---------------

There are various tile selection tools that all work in similar fashion:

-  |stock-tool-rect-select| **Rectangular Select** allows selection of
   rectangular areas (shortcut: ``R``)

-  |stock-tool-fuzzy-select-22| **Magic Wand** allows selection of connected
   areas filled with the same tile (shortcut: ``W``)

-  |stock-tool-by-color-select| **Select Same Tile** allows selection of
   same-tiles across the entire layer (shortcut: ``S``)

By default, each of these tools replaces the currently selected area. The
following modifiers can be used to change the selection mode before starting
the selection:

-  Hold ``Shift`` to expand the current selection with the new area
-  Hold ``Ctrl`` to subtract the new area from the current selection
-  Hold ``Ctrl`` and ``Shift`` to select the intersection of the new
   area with the current selection

You can also lock into one of these modes (Add, Subtract or Intersect)
by clicking on one of the tool buttons in the Tool Options toolbar.

.. raw:: html

   <div class="new">New in Tiled 1.12</div>

While selecting an area, the following modifiers can be used:

- Hold ``Shift`` to constrain the selection to a square.
- Hold ``Ctrl`` to expand the selection from the starting location.

Managing Tile Stamps
--------------------

It can often be useful to store the current tile stamp somewhere to use
it again later. The following shortcuts work for this purpose:

-  ``Ctrl + 1-9`` - Store current tile stamp. When no tile drawing tool is
   selected, tries to capture the current tile selection (similar to
   ``Ctrl + C``).
-  ``1-9`` - Recall the stamp stored at this location (similar to
   ``Ctrl + V``)

Tile stamps can also be stored by name and extended with variations
using the *Tile Stamps* view.

.. |rectangle-fill| image:: ../../src/tiled/resources/images/22/rectangle-fill.png
.. |stock-tool-bucket-fill| image:: ../../src/tiled/resources/images/22/stock-tool-bucket-fill.png
.. |stock-tool-clone| image:: ../../src/tiled/resources/images/22/stock-tool-clone.png
.. |stock-tool-eraser| image:: ../../src/tiled/resources/images/22/stock-tool-eraser.png
.. |stock-tool-rect-select| image:: ../../src/tiled/resources/images/22/stock-tool-rect-select.png
.. |stock-tool-by-color-select| image:: ../../src/tiled/resources/images/22/stock-tool-by-color-select.png
.. |stock-tool-fuzzy-select-22| image:: ../../src/tiled/resources/images/22/stock-tool-fuzzy-select-22.png
.. |terrain-edit| image:: ../../src/tiled/resources/images/24/terrain-edit.png
.. |terrain| image:: ../../src/tiled/resources/images/24/terrain.png

---

### Manual Editing Tilesets (`docs/manual/editing-tilesets.rst`)

Editing Tilesets
================

To edit a tileset it needs to be opened explicitly for editing. External
tilesets can be opened via the *File* menu, but in general the quickest
way to edit the tileset when it is already open in the *Tilesets* view
is to click the small *Edit Tileset* button in the tool bar below the
tileset.

Two Types of Tileset
--------------------

A tileset is a collection of tiles. Tiled currently supports two types
of tilesets, which are chosen when creating a new tileset:

Based on Tileset Image
   This tileset defines a fixed size for all tiles and the image from
   which these tiles are supposed to be cut. In addition it supports a
   margin around the tiles and a spacing between the tiles, which
   allows for using tileset images that either happen to have space
   between or around their tiles or those that have extruded the border
   pixels of each tile to avoid color bleeding.

Collection of Images
   In this type of tileset each tile refers to its own image file. It
   is useful when the tiles aren't the same size, or when the packing
   of tiles into a texture is done later on.

Regardless of the type of tileset, you can associate a lot of meta-
information with it and its tiles. Some of this information can be for
use in your game, like :ref:`collision information <tile-collision-editor>`
and :ref:`animations <tile-animation-editor>`. Other information is
primarily meant for certain editing tools.

.. note::

   A tileset can be either embedded in a map file or saved externally.
   Since Tiled 1.0, the default and recommended approach is to save your
   tilesets to their own file. This simplifies your workflow since it
   makes sure any meta-information is shared between all maps using the
   same tileset.

Tileset Properties
------------------

You can access the tileset properties by using the menu action
*Tileset > Tileset Properties*.

Name
   The name of the tileset. Used to identify the tileset in the
   *Tilesets* view when editing a map.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.4</div>

Object Alignment
   The alignment to use for :ref:`tile objects <insert-tile-tool>` referring
   to tiles from this tileset. This affects the placement of the tile relative
   to the position of the object (the origin) and is also the location around
   which the rotation is applied.

   Possible values are: *Unspecified* (the default), *Top Left*, *Top*, *Top
   Right*, *Left*, *Center*, *Right*, *Bottom Left*, *Bottom* and *Bottom
   Right*. When unspecified, tile object alignment is generally *Bottom Left*,
   except for Isometric maps where it is *Bottom*.

Drawing Offset
   A drawing offset in pixels, applied when rendering any tile from
   the tileset (as part of tile layers or as tile objects). This is
   can be useful to make your tiles align to the grid.

Background Color
   A background color for the tileset, which can be set in case the
   default dark-gray background is not suitable for your tiles.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.0</div>

Orientation
   When the tileset contains isometric tiles, you can set this to
   *Isometric*. This value, along with the **Grid Width** and
   **Grid Height** properties, is taken into account by overlays
   rendered on top of the tiles. This helps for example when specifying
   :ref:`terrain-information`. It also affects the orientation used by
   the :ref:`tile-collision-editor`.

Columns
   This is a read-only property for tilesets based on a tileset image,
   but for image collection tilesets you can control the number of
   columns used when displaying the tileset here.

Image
   This property only exists for tilesets based on a tileset image.
   Selecting the value field will show an *Edit...* button, allowing
   you to change the parameters relevant to cutting the tiles from the
   image.

Of course, as with most data types in Tiled, you can also associate
:doc:`custom-properties` with the tileset.


Tile Properties
---------------

ID
   The ID of the tile in the tileset (read-only)

.. raw:: html

   <div class="new new-prev">Since Tiled 1.0</div>

Class
   This property refers to custom classes defined in the :ref:`Custom Types Editor <custom-property-types>`.
   See the section about :ref:`typed-tiles` for more information.

Width and Height
   The size of the tile (read-only)

Probability
   Represents a relative probability that this tile will get chosen out
   of multiple options. This value is used in *Random Mode* and by the
   :ref:`terrain-tool`.

Image
   Only relevant for tiles that are part of image collection tilesets,
   this shows the image file of the tile and allows you to change it.

.. _terrain-information:

Terrain Information
-------------------

Terrain information can be added to a tileset to enable the use of the
:ref:`terrain-tool`. See the section about
:ref:`defining terrain information <define-terrain-information>`.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.1</div>

.. _tile-collision-editor:

Tile Collision Editor
---------------------

The tile collision editor is available by clicking the *Tile Collision Editor*
|tile-collision-editor-icon| button on the tool bar. This will open a
view where you can create and edit shapes on the tile. You can also
associate custom properties with each shape.

Usually these shapes define collision information for a certain sprite
or for a tile representing level geometry, but of course you could also
use them to add certain hot-spots to your sprites like for particle
emitters or the source of gunshots.

.. figure:: images/tile-collision-editor.png
   :alt: Tile Collision Editor

   Tile Collision Editor

.. raw:: html

   <div class="new new-prev">Since Tiled 1.3</div>

To be able to easily check whether your tiles have the right collision shapes
set up, they can be rendered on the map. To enable this, check *Show Tile
Collision Shapes* in the *View* menu. The collision shapes are rendered for
both tile layers and tile objects.

.. figure:: images/view-tile-collisions.png
   :alt: Showing Tile Collision on the Map

   Collision shapes rendered on the map. This map is from `Owyn's Adventure
   <https://store.steampowered.com/app/1020940/Owyns_Adventure/>`__.

.. _tile-animation-editor:

Tile Animation Editor
---------------------

The tile animation editor allows defining a single linear looping
animation with each tile by referring to other tiles in the tileset as
its frames. Open it by clicking the *Tile Animation Editor* |tile-animation-editor-icon| button.

Tile animations can be live-previewed in Tiled, which is useful for
getting a feeling of what it would look like in-game. The preview can be
turned on or off via *View > Show Tile Animations*.

.. figure:: images/tile-animation-editor.png
   :alt: Tile Animation Editor

   Tile Animation Editor

The following steps allow to add or edit a tile animation:

* Select the tile in the main Tiled window. This will make the *Tile Animation Editor*
  window show the (initially empty) animation associated with that tile,
  along with all other tiles from the tileset.

* Drag tiles from the tileset view in the Tile Animation Editor into the list
  on the left to add animation frames. You can drag multiple tiles at the same
  time. Each new frame gets a default duration of 100 ms (or other value when
  set using the :guilabel:`Frame Duration` field at the top).

* Double-click on the duration of a frame to change it.

* Drag frames around in the list to reorder them.

A preview of the animation shows in the bottom left corner.

You can change the duration of multiple frames at once by selecting them,
changing the value in the :guilabel:`Frame Duration` field and then clicking
:guilabel:`Apply`.

.. |tile-collision-editor-icon|
   image:: ../../src/tiled/resources/images/48/tile-collision-editor.png
      :scale: 50

.. |tile-animation-editor-icon|
   image:: ../../src/tiled/resources/images/24/animation-edit.png

.. _Tiled2Unity: http://www.seanba.com/Tiled2Unity
.. _Mega Dad Adventures: http://www.seanba.com/megadadadventures.html

.. topic:: Future Extensions
   :class: future

   There are many ways in which the tileset editor can be made more
   efficient, for example:

   **Terrain Sets**

   - Make it easier to set up terrain (`#1729 <https://github.com/mapeditor/tiled/issues/1729>`__)

   **Tile Collision Editor**

   - Allow setting collisions for multiple tiles at once (`#1322 <https://github.com/mapeditor/tiled/issues/1322>`__)
   - Render tile collision shapes to the tileset view (`#1281 <https://github.com/mapeditor/tiled/issues/1281>`__)

   **Tile Animation Editor**

   - Support multiple named animations per tile (`#986 <https://github.com/mapeditor/tiled/issues/986>`__)
   - Make it easier to define animations spanning multiple tiles (`#811 <https://github.com/mapeditor/tiled/issues/811>`__)

   If you like any of these plans, please help me getting around to it
   faster by `sponsoring Tiled development <https://www.mapeditor.org/donate>`__. The
   more support I receive the more time I can afford to spend improving
   Tiled!

---

### Manual Export Custom (`docs/manual/export-custom.rst`)

Custom Export Formats
---------------------

Tiled provides several options for extending it with support for additional
file formats.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.3</div>

Using JavaScript

Tiled is :doc:extendable using JavaScript </manual/scripting> and it is
possible to add custom export formats using tiled.registerMapFormat <https://www.mapeditor.org/docs/scripting/modules/tiled.html#registerMapFormat>__ or tiled.registerTilesetFormat <https://www.mapeditor.org/docs/scripting/modules/tiled.html#registerTilesetFormat>__.

This is the recommended way to add support for custom map or tileset formats.

Using Python

text

On some platforms, it is also possible to write :doc:`Python scripts `
to add support for importing or exporting custom map and tileset formats.

.. warning::

    Python scripting is not supported by the macOS release nor the Tiled snap
    release for Ubuntu. The plugin is also very specific in the supported
    Python version. Hence, its use is not recommend.

Using C++
~~~~~~~~~

Currently all export options shipping with Tiled are written as C++ Tiled
plugins. The API for such plugins is not documented (apart from Doxygen-style
comments in the ``libtiled`` source code), but there are over a dozen examples
you can look at.

.. note::

    For binary compatibility reasons, a C++ plugin needs to be compiled for
    the same platform, by the same compiler and with the same versions of Qt
    and Tiled that the plugin is supposed to support. Generally, the easiest
    way to achieve this is by compiling the plugin along with Tiled, which is
    what all current plugins do. If you write a C++ plugin that could be
    useful for others, it is recommended you open a pull request to have it
    shipped with Tiled.

---

### Manual Export Defold (`docs/manual/export-defold.rst`)

Defold
------

Tiled can export to `Defold <https://defold.com/>`__ using one of the two
supplied plugins. Both are disabled by default.

defold
~~~~~~

This plugin exports a map to a `Defold Tile Map <https://www.defold.com/manuals/tilemap/>`__ (\*.tilemap).
It only supports tile layers and only a single tileset may be used.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.9.2</div>

Custom Properties
^^^^^^^^^^^^^^^^^

The ``tile_set`` property of the Tile Map can be set by adding a custom
string property to the map named "tile_set" (case sensitive). If left empty,
it will need to be set up in Defold after each export.

A custom float property named "z" can be added to set the ``z`` value for each
tile layer. By default, the layers will be exported with incrementing z values,
so you only need to set this property in case you need to customize the
rendering order.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.3</div>

defoldcollection

This plugin exports a map to a Defold Collection <https://www.defold.com/manuals/building-blocks/>__ (*.collection), while
also creating multiple .tilemap files.

It supports:

Group layers (only top-level group layers are supported, not nested ones!)
Multiple Tilesets per Tilemap

The plugin automatically assigns a Z-index to each layer ranging between 0 and
0.1. It supports the use of 9999 Group Layers and 9999 Tile Layers per Group
Layer.

When any additional information from the map is needed, the map can be
exported in :ref:Lua format <lua-export> and loaded as Defold script.

Custom Properties
^^^^^^^^^^^^^^^^^

The tile_set property of each tilemap may need to be set up manually in
Defold after each export. However, Tiled will attempt to find the
.tilesource file corresponding with the name your Tileset in Tiled in your
project's /tilesources/ directory. If one is found, manual adjustments
won't be necessary.

Alternatively, a custom string property called "tilesource" (case-sensitive)
can be added to the tileset, which will then be used instead (since Tiled
1.9.2).
If you create custom properties on your map called x-offset and
y-offset, these values will be used as coordinates for your top-level
GameObject in the Collection. This is useful when working with :doc:Worlds <worlds>.

.. raw:: html

Since Tiled 1.10

A custom float property named "z" can be added to tile layers to manually
specify their z value.

Manual Export Generic (`docs/manual/export-generic.rst`)

Generic File Formats

Tiled supports exporting to several generic file formats which are not
targeting any specific framework.

JSON

:doc:The JSON format </reference/json-map-format> is the most common
additional file format supported by Tiled. It can be used instead of TMX
since Tiled can also open JSON maps and tilesets and the format supports
all Tiled features. Especially in the browser and when using JavaScript
in general, the JSON format is easier to load.

.. _lua-export:

Lua

Maps and tilesets can be exported to Lua code. This export option supports
most of Tiled's features and is useful when using a Lua-based framework like
LÖVE_ (with Simple Tiled Implementation), Solar2D (with
ponytiled_ or Dusk Engine) or Defold.

Currently not included are the type of custom properties (though the
type does affect how a property value is exported) and information
related to :doc:object templates .

The tiles are referenced using :doc:/reference/global-tile-ids, as done in
the :doc:TMX </reference/tmx-map-format> and :doc:JSON </reference/json-map-format> formats.

CSV

The CSV export only supports :doc:tile layers <editing-tile-layers>.
Maps containing multiple tile layers will export as multiple files,
called base_<layer-name>.csv.

Each tile is written out by its ID, unless the tile has a custom
property called name, in which case its value is used to write out
the tile. Using multiple tilesets will lead to ambiguous IDs, unless the
custom name property is used. Empty cells get the value -1.

When tiles are flipped horizontally, vertically or diagonally, these states
are exported using bitflags in the ID, in the same way as done in the
:doc:/reference/tmx-map-format.

.. _LÖVE: https://love2d.org/
.. _Solar2D: https://solar2d.com/
.. _Defold: https://www.defold.com/
.. _Simple Tiled Implementation: https://github.com/karai17/Simple-Tiled-Implementation
.. _ponytiled: https://github.com/ponywolf/ponytiled
.. _Dusk Engine: https://github.com/GymbylCoding/Dusk-Engine

Manual Export Gmx (`docs/manual/export-gmx.rst`)

.. _gamemaker-export:

GameMaker: Studio 1.4

GameMaker: Studio 1.4 uses a custom XML-based format to store its rooms,
and Tiled ships with a plugin to export maps in this format. Currently
only orthogonal maps will export correctly.

Tile layers and tile objects (when no class is set) will export as "tile"
elements. These support horizontal and vertical flipping, but no
rotation. For tile objects, scaling is also supported.

.. warning::

The tilesets have to be named the same as the corresponding backgrounds
in the GameMaker project. Otherwise GameMaker will pop up an error for each
tile while loading the exported room.gmx file.

Object Instances

text

GameMaker object instances are created by putting the object name in the
"Class" field of the object in Tiled. Rotation is supported here, and for
tile objects also flipping and scaling is supported (though flipping in
combination with rotation doesn't appear to work in GameMaker).

.. raw:: html

   <div class="new new-prev">Since Tiled 1.1</div>

The following custom properties can be set on objects to affect the
exported instance:

* string ``code`` (instance creation code, default: "")
* float ``scaleX`` (default: derived from tile or 1.0)
* float ``scaleY`` (default: derived from tile or 1.0)
* int ``originX`` (default: 0)
* int ``originY`` (default: 0)

The ``scaleX`` and ``scaleY`` properties can be used to override the
scale of the instance. However, if the scale is relevant then it will
generally be easier to use a tile object, in which case it is
automatically derived from the tile size and the object size.

The ``originX`` and ``originY`` properties can be used to tell Tiled
about the origin of the object defined in GameMaker, as an offset from
the top-left. This origin is taken into account when determining the
position of the exported instance.

.. hint::

   Of course setting the class and/or the above properties manually for
   each instance will get old fast. Since Tiled 1.0.2, you can instead
   use tile objects with the class set on the tile, and in Tiled 1.1 you
   can also use :doc:`object templates <using-templates>`.

.. raw:: html

   <div class="new new-prev">Since Tiled 1.1</div>

Views
~~~~~

.. figure:: images/gamemaker-view-settings.png
   :alt: GameMaker View Settings
   :align: right

Views can be defined using :ref:`rectangle objects `
where the Class has been set to ``view``. The position and size will be
snapped to pixels. Whether the view is visible when the room starts
depends on whether the object is visible. The use of views is
automatically enabled when any views are defined.

The following custom properties can be used to define the various other
properties of the view:

**Port on screen**

* int ``xport`` (default: 0)
* int ``yport`` (default: 0)
* int ``wport`` (default: 1024)
* int ``hport`` (default: 768)

**Object following**

* string ``objName``
* int ``hborder`` (default: 32)
* int ``vborder`` (default: 32)
* int ``hspeed`` (default: -1)
* int ``vspeed`` (default: -1)

.. hint::

   When you're defining views in Tiled, it is useful to add ``view``
   as class in the :ref:`Custom Types Editor <custom-property-types>`,
   adding the above properties for ease of access. If you frequently use
   views with similar settings, you can set up
   :doc:`templates ` for them.

Map Properties
~~~~~~~~~~~~~~

General
^^^^^^^

* int ``speed`` (default: 30)
* bool ``persistent`` (default: false)
* bool ``clearDisplayBuffer`` (default: true)
* bool ``clearViewBackground`` (default: false)
* string ``code`` (map creation code, default: "")

Physics
^^^^^^^

* bool ``PhysicsWorld`` (default: false)
* int ``PhysicsWorldTop`` (default: 0)
* int ``PhysicsWorldLeft`` (default: 0)
* int ``PhysicsWorldRight`` (default: width of map in pixels)
* int ``PhysicsWorldBottom`` (default: height of map in pixels)
* float ``PhysicsWorldGravityX`` (default: 0.0)
* float ``PhysicsWorldGravityY`` (default: 10.0)
* float ``PhysicsWorldPixToMeters`` (default: 0.1)

Layer Properties

Both tile layers and object layers may produce "tile" elements in the exported
room file. Their depth is set automatically, with tiles from the bottom-most
layer getting a value of 10000000 (the GameMaker default) and counting up from
there. If you want to set a custom depth value you can set the following
property on the layer:

int depth (default: 10000000 + N)

Manual Export Image (`docs/manual/export-image.rst`)

.. _export-as-image:

Export as Image

Maps can be exported as image. Tiled supports most common image formats.
Choose File -> Export as Image... to open the relevant dialog.

Since exporting a map can in some cases result in a huge image, a Use current
zoom level option is provided to allow exporting the map at the size it's
currently displayed at.

For repeatedly converting a map to an image, manually triggering this export
isn't very convenient. For this purpose, a tool called tmxrasterizer ships
with Tiled, which contrary to its name is able to render any supported map
format to an image. It is also able to render :doc:entire worlds <worlds> to
an image. On Linux this tool can be set up for generating thumbnail previews
of maps in the file manager.

Manual Export Other (`docs/manual/export-other.rst`)

Other Formats

A few other plugins ship with Tiled to support various games or tools:

droidcraft
Adds support for editing DroidCraft_ maps (*.dat)

flare
Adds support for editing Flare Engine_ maps (*.txt)

replicaisland
Adds support for editing Replica Island_ maps (*.bin)

.. raw:: html

Since Tiled 1.5

rpmap
Adds support for exporting Tiled maps as RpMap (*.rpmap), the format used
by MapTool_.

text

Currently, support is limited to maps using "Image Collection" tilesets
since MapTool doesn't support tileset images.

tengine
Adds support for exporting to T-Engine4_ maps (*.lua)

These plugins are disabled by default. They can be enabled in Edit >
Preferences > Plugins.

.. _MapTool: https://www.rptools.net/toolbox/maptool/
.. _DroidCraft: https://play.google.com/store/apps/details?id=org.me.droidcraft
.. _Flare Engine: http://flarerpg.org/
.. _Replica Island: http://replicaisland.net/
.. _T-Engine4: https://te4.org/te4

Manual Export Tbin (`docs/manual/export-tbin.rst`)

.. raw:: html

tBIN since Tiled 1.1

tIDE new in Tiled 1.12

tBIN and tIDE

The tBIN map format is a binary format used by the tIDE Tile Map Editor,
while the tIDE map format is an XML-based format used by it as well.
tIDE was used by Stardew Valley, a successful game that spawned many
community mods <https://www.nexusmods.com/stardewvalley/?>__.

Tiled ships with a plugin that enables direct editing of Stardew Valley
maps (and any other maps using the tBIN or tIDE formats). This plugin needs to
be enabled in Edit > Preferences > Plugins. It is not enabled by default
because it won't store everything (most notably it doesn't support
object layers in general, nor external tilesets), so you need to know
what you are doing.

.. note::

There is only one plugin, called tbin. Despite its name, it enables
support for both tBIN and tIDE maps.

.. note::

The tBIN and tIDE formats support setting custom properties on the tiles of
a tile layer. Since Tiled does not support this directly, "TileData"
objects are created that match the location of the tile, on which
such properties are then stored.

.. figure:: images/export/stardew-valley-map.png
:alt: One of the farm maps from Stardew Valley opened in Tiled

One of the farm maps from Stardew Valley opened in Tiled.

.. _tIDE Tile Map Editor: https://colinvella.github.io/tIDE/
.. _Stardew Valley: https://stardewvalley.net/

Manual Export Tscn (`docs/manual/export-tscn.rst`)

.. _godot4-export:

.. raw:: html

text

<div class="new new-prev">Since Tiled 1.10</div>

Godot 4

Godot 4 revamped its TileMap node, and Tiled ships with a plugin to export
maps in this format. For exporting to Godot 3, see the Tiled To Godot Export <https://github.com/mapeditor/tiled-to-godot-export>__ extension.

The Godot 4 exporter assumes that the generated .tscn files and the tileset
artwork all share the same file hierarchy. The exporter will search for a
common parent folder containing a .godot project file and use that folder
as the res:// root for the project. The exporter will search at least two
parent folders for a .godot file.

.. note::

text

If this exporter does not fit your needs, `YATI (Yet Another Tiled
Importer) <https://github.com/Kiamo2/YATI>`__ is a popular Godot 4 addon
that imports ``.tmx`` and ``.tmj`` files directly, with a very extensive
feature set.

Layer Properties

text

All layer types support the following custom properties:

* bool ``ySortEnabled`` (default: false)
* int ``zIndex`` (default: 0)
* bool ``noExport`` (default: false)
* bool ``tilesetOnly`` (default: blank)

The ``ySortEnabled`` property can be used to change the drawing order to allow
sprites to be drawn behind tiles based on their Y coordinate.

The ``zIndex`` property can be used to assign a specific depth value to a
layer.

The ``noExport`` property can be used to suppress exporting of an entire
layer, including any child layers. This is useful if you use a layer for
annotations (like adding background image or text objects) that you do not
want exported to Godot. Note that any views defined on this layer will
then also get ignored.

The ``tilesetOnly`` property can be used if you want to export all the tilesets
used in this layer, without actually exporting the layer itself. By default,
the exporter will only export tilesets which are actually used in the map, so
this property allows you to export tilesets that normally would otherwise get
skipped. This is most useful in combination with the :ref:`tilesetResPath
property <godot4-map-properties>`.

Tileset Properties

Tilesets support the following property:

bool exportAlternates (default: false)

Deprecated: The exportAlternates property is necessary when using
flipped or rotated tiles in Godot 4.0 and 4.1. This will create 7 alternate
tiles for each tile, allowing all flipped and rotation combinations. This
has been deprecated in Tiled 1.11 in favour of Godot 4.2's native rotation
and flipping support.

Tile Properties

text

.. raw:: html

    <div class="new new-prev">Since Tiled 1.10.2</div>

All custom properties set on tiles will get exported as `Custom Data Layers
<https://docs.godotengine.org/en/stable/tutorials/2d/using_tilesets.html#assigning-custom-metadata-to-the-tileset-s-tiles>`__
of the Godot TileSet resource.

.. _godot4-map-properties:

Map Properties
~~~~~~~~~~~~~~

Maps support the following custom property:

* string ``tilesetResPath`` (default: blank)

The ``tilesetResPath`` property saves the tileset to an external .tres file,
allowing it to be shared between multiple maps more efficiently. This path
must be in the form of 'res://<path>.tres'. The tileset file will be
overwritten every time the map is exported.

.. note::

    Only tilesets that are used in the current map will be exported. You
    must ensure that every map which uses the same ``.tres`` file also uses
    *all* of the same tilesets. You may wish to create a layer with the
    ``tilesetOnly`` property to ensure the correct tilesets are exported.

.. raw:: html

   <div class="new">New in Tiled 1.11</div>

Object Properties

Objects support the following property:

string resPath (required)

The resPath property takes the form of 'res://

Technical Documentation: mapeditor/tiled

Overview (`README.md`) Copy Section

About Tiled Copy Chapter

Installing Tiled Copy Chapter

Signed Releases for macOS and Windows Copy Section

Compiling Tiled Copy Chapter

Qt 6 Copy Section

Working with Visual Studio 2017 Copy Section

Installing Self-Compiled Tiled Copy Chapter

Overview (`docs/README.md`) Copy Section

Generating the Tiled Documentation

Prerequisites Copy Chapter

Setting Up a Virtual Environment Copy Chapter

Linux (Ubuntu, Fedora, RHEL, CentOS) and macOS Copy Section

Windows Copy Section

Installing Dependencies Copy Chapter

Generating the Documentation Copy Chapter

Using a Different Language Copy Section

Updating Translation Files Copy Chapter

Deactivating the Virtual Environment Copy Chapter

Requirements Copy Chapter

Overview (`docs/scripting-doc/README.md`) Copy Section

tiled-api

Online documentation Copy Chapter

Writing a Tiled plugin with code completion in VS Code Copy Chapter

Overview (`examples/sticker-knight/README.md`) Copy Section

Sticker Knight platformer example Copy Chapter

Overview (`src/karchive/README.md`) Copy Section

KArchive

Introduction Copy Chapter

Usage Copy Chapter

Overview (`util/java/README.md`) Copy Section

Java library and sample project to view Tiled files

Folders description Copy Chapter

Packaging the project Copy Chapter

Overview (`util/java/libtiled-java/README.md`) Copy Section

libtiled - Java library to work with Tiled maps

Authors Copy Chapter

Maven Copy Chapter

sbt Copy Chapter

Excluding unused dependencies Copy Chapter

Building Copy Chapter

Overview (`util/java/tmxviewer-java/README.md`) Copy Section

Java TMX Viewer example

Opening the project in a modern IDE Copy Chapter

Trying it out from the command line Copy Chapter

Index (`docs/index.rst`) Copy Section

Tiled Documentation

Requirements (`docs/requirements.txt`) Copy Section

Manual Automapping (`docs/manual/automapping.md`) Copy Section

Automapping

What is Automapping? Copy Chapter

Setting Up the Rules File Copy Chapter

Setting Up a Rule Map Copy Chapter

Defining Inputs Copy Section

Input Example

Matching Special Cases

Defining Outputs Copy Section

Random Output Example

Automapping Properties Copy Chapter

Map Properties Copy Section

Layer Properties Copy Section

Object Properties Copy Section

Examples Copy Chapter

RPG Cliffs Copy Section

Automap While Drawing

Sidescroller Details Copy Section

Updating Legacy Rules Copy Chapter

Credits Copy Chapter

Manual Custom Properties (`docs/manual/custom-properties.rst`) Copy Section

Custom Properties

Adding Properties Copy Chapter

Custom Types Copy Chapter

Tile Property Inheritance Copy Chapter

Manual Export Generic (`docs/manual/export-generic.rst`) Copy Section

Generic File Formats

JSON Copy Chapter

Lua Copy Chapter

CSV Copy Chapter

Manual Export Gmx (`docs/manual/export-gmx.rst`) Copy Section

Overview (`README.md`)

About Tiled

Installing Tiled

Signed Releases for macOS and Windows

Compiling Tiled

Qt 6

Working with Visual Studio 2017

Installing Self-Compiled Tiled

Overview (`docs/README.md`)

Prerequisites

Setting Up a Virtual Environment

Linux (Ubuntu, Fedora, RHEL, CentOS) and macOS

Windows

Installing Dependencies

Generating the Documentation

Using a Different Language

Updating Translation Files

Deactivating the Virtual Environment

Requirements

Overview (`docs/scripting-doc/README.md`)

Online documentation

Writing a Tiled plugin with code completion in VS Code

Overview (`examples/sticker-knight/README.md`)

Sticker Knight platformer example

Overview (`src/karchive/README.md`)

Introduction

Usage

Overview (`util/java/README.md`)

Folders description

Packaging the project

Overview (`util/java/libtiled-java/README.md`)

Authors

Maven

sbt

Excluding unused dependencies

Building

Overview (`util/java/tmxviewer-java/README.md`)

Opening the project in a modern IDE

Trying it out from the command line

Index (`docs/index.rst`)

Requirements (`docs/requirements.txt`)

Manual Automapping (`docs/manual/automapping.md`)

What is Automapping?

Setting Up the Rules File

Setting Up a Rule Map

Defining Inputs

Defining Outputs

Automapping Properties

Map Properties

Layer Properties

Object Properties

Examples

RPG Cliffs

Sidescroller Details

Updating Legacy Rules

Credits

Manual Custom Properties (`docs/manual/custom-properties.rst`)

Adding Properties

Custom Types

Tile Property Inheritance

Manual Export Generic (`docs/manual/export-generic.rst`)

JSON

Lua

CSV

Manual Export Gmx (`docs/manual/export-gmx.rst`)

GameMaker: Studio 1.4

Manual Export Image (`docs/manual/export-image.rst`)

Export as Image

Manual Export Other (`docs/manual/export-other.rst`)

Other Formats

Manual Export Tbin (`docs/manual/export-tbin.rst`)

tBIN and tIDE

Manual Export Tscn (`docs/manual/export-tscn.rst`)

Tinting Layers

Blend Modes

Manual Maps (`docs/manual/maps.rst`)

Creating a Map

Map Orientations

Plugins

Manual Projects (`docs/manual/projects.rst`)