Skip to content
JonataOliveiraa edited this page Nov 14, 2026 · 1 revision
Basics

Tiles are everything placed in the world's grid: blocks like dirt and stone, and objects like work benches, chairs, chests and torches. A mod adds a tile with a ModTile, usually together with the item that places it, and changes the game's tiles with a GlobalTile. Both are written as in tModLoader. This page starts with a block and an object, then goes through what tiles can do, one kind of furniture at a time.

Register a block

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Terraria;
using Terraria.ID;
using Terraria.ModLoader;

namespace MyMod.Content.Tiles;

public sealed class ExampleBlock : ModTile
{
    public override void SetStaticDefaults()
    {
        Main.tileSolid[Type] = true;
        Main.tileMergeDirt[Type] = true;
        Main.tileBlockLight[Type] = true;
        DustType = DustID.Stone;
        MinPick = 50;
        MineResist = 2f;
        AddMapEntry(new Color(200, 200, 200));
    }
}

The item that places it has the same name in the items' namespace:

namespace MyMod.Content.Items;

public sealed class ExampleBlock : ModItem
{
    public override void SetDefaults() => Item.DefaultToPlaceableTile(ModContent.TileType<Tiles.ExampleBlock>());
}

The texture uses Texture, following the same namespace and file rules as ModItem. Put the block sheet beside the tile source and the inventory texture beside the item source. Type is a ushort allocated after the game's tile types. Always resolve it through ModContent.TileType<T>(); numeric IDs can change with the enabled mods.

SetStaticDefaults describes the tile through the game's tables, indexed by Type. Main.tileSolid makes it a block that players and enemies stand on, Main.tileMergeDirt blends its edges with dirt and Main.tileBlockLight stops light; there are many more, such as tileFrameImportant, tileNoAttach, tileLavaDeath, tileLighted and the TileID.Sets. Two of them bring a partner along, as in the game: a solid tile also gets tileNoSunLight, and tileLavaDeath also sets tileObsidianKill.

MinPick is the pickaxe power needed to mine the tile, and MineResist makes each hit count for less (2 takes twice as many hits). DustType is the dust each hit throws and HitSound its sound, a SoundStyle such as the game's SoundID values; null silences it.

AddMapEntry(color, name) gives the tile its color on the map and the name shown when a finger is over it; without a name, it uses the tile's translatable MapEntry text (CreateMapEntryName()). Two things are not on the phone yet: GetMapOption, which picks between several map entries, is not called, so the first entry is used, and the overload with a function that changes the name by position throws NotSupportedException, because the phone's map legend only takes fixed names.

Objects and crafting stations

using Terraria.DataStructures;
using Terraria.Enums;
using Terraria.ObjectData;

public override void SetStaticDefaults()
{
    Main.tileFrameImportant[Type] = true;
    Main.tileNoAttach[Type] = true;
    TileObjectData.newTile.CopyFrom(TileObjectData.Style2x2);
    TileObjectData.newTile.Origin = new Point16(0, 1);
    TileObjectData.newTile.CoordinateHeights = new[] { 16, 18 };
    TileObjectData.newTile.AnchorBottom = new AnchorData(AnchorType.SolidTile, 2, 0);
    TileObjectData.newTile.StyleHorizontal = true;
    TileObjectData.addTile(Type);
    AdjTiles = new[] { (int)TileID.WorkBenches };
}

An object is a tile that takes several cells and has a fixed shape. TileObjectData.newTile describes that shape: copy one of the game's templates (Style2x2 is two cells by two), adjust it, and register it with TileObjectData.addTile(Type), all inside SetStaticDefaults. Here Origin is the cell the player places it by (the bottom left), CoordinateHeights is the height in pixels of each row of the sheet (the bottom row is 18, so it reaches into the floor), AnchorBottom asks for solid tiles under both its cells, and StyleHorizontal puts its styles side by side in the sheet.

Breaking any cell of the object breaks all of it, drops its item once and calls KillMultiTile(i, j, frameX, frameY) with the object's top left cell and its frame: the place to clean up whatever belongs to the object.

AdjTiles makes the tile count as other crafting stations: this work bench also counts as the game's work benches, so it crafts their recipes. A recipe that needs the mod's own station uses AddTile<T>(), and the phone shows the item that places it as the station's icon. A GlobalTile can give stations to the game's tiles with AdjTiles(type), read once when the mods load. The sets in TileID.Sets.RoomNeeds (CountsAsChair, CountsAsTable, CountsAsTorch, CountsAsDoor) make the tile count as furniture for housing.

World and interaction hooks

KillTile(i, j, ref fail, ref effectOnly, ref noItem) runs when the tile is hit or broken and can change what happens: keep it standing, make the hit only visual, or drop nothing. CanKillTile can refuse the mining altogether. NumDust decides how much dust a hit throws and CreateDust its type, or none, and KillSound can silence it. CanPlace, PlaceInWorld, CanExplode, CanReplace, Slope, TileFrame, HitWire, RandomUpdate and NearbyEffects are available on both tile classes where tModLoader defines them. GlobalTile.PreHitWire can veto wiring before the game's handler.

A tile drops the mod item whose createTile and placeStyle match it, found by itself. RegisterItemDrop(itemType, styles) names another, GetItemDrops can return several items, and CanDrop returning false drops nothing. An object drops once for the whole object, not once per cell. GlobalTile.Drop runs after the drop.

On the phone, a tap on a tile only reaches RightClick when the tile shows an item icon under the finger, so Bunny Loader shows the item that places the tile for every tile that overrides RightClick. The game asks three times per frame, and again while the finger stays down; Bunny Loader turns that into one call per tap. MouseOver and MouseOverFar work as in tModLoader.

ModifyLight(i, j, ref r, ref g, ref b) makes the tile give light (set Main.tileLighted[Type] too). On the phone that light is added on top of what the game computes, during the world update; a GlobalTile can add light to the game's tiles the same way, but not replace the light they already give.

IsTileDangerous and IsTileSpelunkable decide whether the Dangersense and Spelunker potions outline the tile. In a GlobalTile, as in tModLoader, false removes the outline, true adds it and null keeps the game's choice.

Drawing

AnimateTile(ref frame, ref frameCounter) animates every tile of the type together, and AnimationFrameHeight is the distance in pixels between the frames of the sheet. AnimateIndividualTile, SetDrawPositions and SetSpriteEffects change how one cell is drawn.

PreDraw, DrawEffects and PostDraw work as in tModLoader. On the phone they run on the thread that draws the tiles, so keep them to drawing. A tile that uses PreDraw or DrawEffects is drawn by Bunny Loader instead of the game (when PreDraw returns true), from a TileDrawInfo with the cell's frame, size, offsets, texture, color and effects; such a tile does not get the game's special drawing of slopes, paint, glow and liquids. Main.instance.TilesRenderer.AddSpecialLegacyPoint(i, j) asks for a SpecialDraw in the same pass. The global versions of these hooks also apply to the game's tiles.

Bunny Loader only calls these hooks for the tile types that override them, so the game's tiles do not pay for them.

EmitParticles(i, j, tile, tileFrameX, tileFrameY, tileLight, visible) is where a tile spawns its dust or gore. The game asks about one tile in four, per frame, and only while it is active and not paused; GlobalTile has it too. GetTileFlameData fills a TileDrawing.TileFlameData with the flame the game draws over the tile. TileLoader.SetDrawPositions and SetAnimationFrame give a PostDraw the same frame the tile is drawn with, and Animation.RegisterTemporaryAnimation(frameRate, frames) makes an animation type for Animation.NewTemporaryAnimation.

A tile that sways sets TileID.Sets.MultiTileSway, and from PreDraw its top left calls Main.instance.TilesRenderer.AddSpecialPoint(i, j, TileDrawing.TileCounterType.MultiTileVine). AdjustMultiTileVineParameters changes the wind, the push and the glow. With this hook the tile is drawn by Bunny Loader, so paint shaders and the Spelunker or Dangersense outline do not apply to it.

Main.tile[x, y].TileFrameX += 18 works as in tModLoader. The indexer returns a reference to one of a few reused slots, so keep the tile in a local (Tile tile = Main.tile[x, y]), never a ref Tile.

Doors, torches, clocks and sinks

Set Effect
TileID.Sets.OpenDoorID[closed], CloseDoorID[open] The two tiles of a door. WorldGen.OpenDoor, CloseDoor, a touch and the automatic door option work with them, and ModTile.IsDoor says it is one
TileID.Sets.Torches with GetTorchLuck(Player) Luck counted when the torch is near or held. Mod torches are weighed apart from the game's: both add to torchLuck, which stays between 0 and 1
TileID.Sets.Clock Counts as a clock for the player's info display (SceneMetrics.HasClock)
CountsAsHoneyForCrafting, CountsAsLavaForCrafting Next to CountsAsWaterForCrafting, the tile also works as those liquids in recipes

PostSetDefaults runs right after the loader's own defaults, for what they would otherwise override (Main.tileNoSunLight on a solid tile). Town NPCs do not open or close mod doors yet: the game checks the door's number inside the NPC's AI.

Floors, switches, critters and tree shakes

Hook When
FloorVisuals(Player) Every frame a player stands on the tile
HasWalkDust(), WalkDust(ref dustType, ref makeDust, ref color) The dust a player kicks up walking on the tile
DropCritterChance(i, j, ref worm, ref grasshopper, ref grub) When the tile breaks; a chance of n is one in n
HitSwitch(i, j) A player or a mechanism uses the tile as a switch; Wiring.HitSwitchAndSync also tells the others
SwitchTiles(i, j, entity, position, width, height, oldPosition, objType) An entity moves through the tile; true stops the search
GlobalTile.PreShakeTree(x, y, treeType), ShakeTree(x, y, treeType) A tree is shaken. ShakeTree returning true replaces the game's drop. NPCLoader.blockLoot blocks item types until the shake ends

FlexibleTileWand.RubblePlacementSmall, Medium and Large take a mod's fake rubble with AddVariations. ItemID.Sets.DisableAutomaticPlaceableDrop keeps an item from becoming the drop of the tile it places.

Not on the phone: ModifyFrameMerge, PostTileFrame, ChangeWaterfallStyle, TileID.Sets.CanBeSloped, CanPlaceNextToNonSolidTile and IgnoredByGrowingSaplings, because they run in the middle of the game's framing, waterfall or placement code, which C# can only enter at the start and at the end.

Chairs and beds

Set TileID.Sets.CanBeSatOnForPlayers/CanBeSatOnForNPCs or CanBeSleptIn, then adjust where the entity rests with ModifySittingTargetInfo and ModifySleepingTargetInfo, as in tModLoader:

public override void ModifySittingTargetInfo(int i, int j, ref TileRestingInfo info)
{
    Tile tile = Framing.GetTileSafely(i, j);
    info.TargetDirection = tile.TileFrameX != 0 ? 1 : -1;
    info.AnchorTilePosition.X = i;
    info.AnchorTilePosition.Y = j;
    if (tile.TileFrameY % 40 == 0)
        info.AnchorTilePosition.Y++;
}

public override bool RightClick(int i, int j)
{
    Player player = Main.LocalPlayer;
    if (player.IsWithinSnappngRangeToTile(i, j, PlayerSittingHelper.ChairSittingMaxDistance))
    {
        player.GamepadEnableGrappleCooldown();
        player.sitting.SitDown(player, i, j);
    }
    return true;
}

The anchor is the bottom tile the entity rests on, and TargetDirection, DirectionOffset, VisualOffset, FinalOffset and ExtraInfo work as in tModLoader; the hooks run when sitting or sleeping starts and on every update while it lasts. For a bed, TileID.Sets.IsValidSpawnPoint makes it a spawn point, as long as it stands in a valid room, as the game requires; the phone's game has no such set, so Bunny Loader keeps it.

Smart interact

On mobile, touching furniture goes through the game's smart interact, which only knows its own tile types. HasSmartInteract(i, j, settings) adds a mod tile to the targets, as in tModLoader:

public override bool HasSmartInteract(int i, int j, SmartInteractScanSettings settings)
{
    return settings.player.IsWithinSnappngRangeToTile(i, j, PlayerSittingHelper.ChairSittingMaxDistance);
}

Unlike tModLoader, the default is true for tiles that override RightClick (false otherwise), so a ported tile stays usable by touch; return false to opt out. ModPylon returns true. The tile that smart interact picks gets the game's highlight outline: its size comes from the tile's TileObjectData, and ModifySmartInteractCoords adjusts it, as in tModLoader.

Chests and dressers

A chest is a 2x2 ModTile with TileID.Sets.BasicChest (a dresser: 3x2 with TileID.Sets.BasicDresser) and the game's own chest placement hooks, as in tModLoader:

TileObjectData.newTile.HookCheckIfCanPlace = new PlacementHook(Chest.FindEmptyChest, -1, 0, true);
TileObjectData.newTile.HookPostPlaceMyPlayer = new PlacementHook(Chest.AfterPlacement_Hook, -1, 0, false);

On the phone PlacementHook takes these two game methods (other methods are refused). The items live in the game's Main.chest, saved with the world as the game's chests. RightClick opens it (player.OpenChest) and KillMultiTile calls Chest.DestroyChest; see ExampleChest and ExampleDresser in the ExampleMod.

  • IsLockedChest(i, j), UnlockChest(i, j, ref frameXAdjustment, ref dustType, ref manual) and LockChest(i, j, ref frameXAdjustment, ref manual) answer Chest.IsLocked, Chest.Unlock and Chest.Lock; without manual, the 2x2 frame moves by frameXAdjustment (36 to lock, -36 to unlock) with the unlock sound and dust.
  • DefaultContainerName(frameX, frameY) is the name TileLoader.DefaultContainerName gives (for the cursor text, as the ExampleMod does).
  • The chest and dresser pages of the inventory show the item the tile drops.
  • A mod dresser stays open while the player is next to it and opens the clothes window, which the phone otherwise keeps for the game's dresser only.
  • In multiplayer, placing and breaking a mod chest or dresser goes to the server through the loader's own packet (the game's message only knows its three container tiles), as tModLoader's extra actions of that message do.

AddMapEntry with a name callback (MapChestName in tModLoader) is not available: the phone's map legend only takes fixed names.

Signs and page icons

A mod sign is a ModTile with Main.tileSign[Type] = true (and usually TileID.Sets.TileInteractRead), using Sign.ReadSign, Sign.TextSign and Sign.KillSign as in tModLoader. The mobile game draws a fixed item in the sign dialogue (sign, tombstone...); for a mod sign the loader draws the item that places it, with its name.

The mobile page icons also come from fixed tables: a mod chest or dresser shows the item that places it, and the shop page of a mod town NPC shows its head (the shimmered head when it is shimmered).

Tile entities

A ModTileEntity keeps data and code on one placed object, as in tModLoader:

public class BasicTileEntity : ModTileEntity
{
    public override bool IsTileValidForEntity(int x, int y)
    {
        Tile tile = Main.tile[x, y];
        return tile.HasTile && tile.TileType == ModContent.TileType<BasicTileEntityTile>();
    }
}

The tile places it and removes it:

TileObjectData.newTile.HookPostPlaceMyPlayer = ModContent.GetInstance<BasicTileEntity>().Generic_HookPostPlaceMyPlayer;

public override void KillMultiTile(int i, int j, int frameX, int frameY) => ModContent.GetInstance<BasicTileEntity>().Kill(i, j);

TileEntity.TryGet(i, j, out BasicTileEntity entity) finds the entity of the object that has the cell (i, j). Each entity has ID, Position (the top left cell, a Point16) and Type; the template (ModContent.GetInstance) has Place, Kill, Find and ModTileEntity.CountInWorld().

  • Update (only when overridden, RequiresUpdates), PreGlobalUpdate and PostGlobalUpdate run on the server (or alone) once per world update, around the game's own tile entities.
  • SaveData/LoadData keep the data in <world>.wld.bl.json; when the world loads, an entity whose tile is no longer valid (IsTileValidForEntity) is dropped, and entities of mods that are not loaded are kept as they were.
  • NetSend/NetReceive carry it to clients: when it is placed, when a player gets that part of the world, and on NetMessage.SendData(MessageID.TileEntitySharing, number: ID). A client's placement asks the server, which checks the tile, places it, calls OnNetPlace and sends it to everyone. OnKill runs on Kill.
  • Hook_AfterPlacement and other C# methods also work in a PlacementHook for HookPostPlaceMyPlayer.

The game itself cannot hold new tile entity classes, so mod entities live in the loader and are not in the game's TileEntity.ByID; use TileEntity.TryGet.

Trees

A ModTree is written as in tModLoader and is loaded on its own (it is not a ModType). The tree grows from the vanilla tree tile (5) on the ground tiles in GrowsOnTileId:

public class ExampleTree : ModTree
{
    private Asset<Texture2D> texture, branchesTexture, topsTexture;

    public override TreePaintingSettings TreeShaderSettings => new TreePaintingSettings { UseSpecialGroups = true };

    public override void SetStaticDefaults()
    {
        GrowsOnTileId = [ModContent.TileType<ExampleBlock>()];
        texture = ModContent.Request<Texture2D>("ExampleMod/Content/Tiles/Plants/ExampleTree");
        branchesTexture = ModContent.Request<Texture2D>("ExampleMod/Content/Tiles/Plants/ExampleTree_Branches");
        topsTexture = ModContent.Request<Texture2D>("ExampleMod/Content/Tiles/Plants/ExampleTree_Tops");
    }

    public override Asset<Texture2D> GetTexture() => texture;
    public override Asset<Texture2D> GetTopTextures() => topsTexture;
    public override Asset<Texture2D> GetBranchTextures() => branchesTexture;

    public override int SaplingGrowthType(ref int style)
    {
        style = 0;
        return ModContent.TileType<Plants.ExampleSapling>();
    }

    public override int DropWood() => ModContent.ItemType<ExampleItem>();
}
  • The trunk, branch and top textures use the vanilla tree sheet layouts (the trunk is a 176-pixel-wide strip, the tops are three 80x80 frames).
  • An acorn planted on the ground becomes the sapling returned by SaplingGrowthType. The sapling is a ModTile with TileID.Sets.TreeSapling[Type] = true; its GrowSapling is called by WorldGen.AttemptToGrowTreeFromSapling, and WorldGen.GrowTree accepts it.
  • CountsAsTreeType (TreeTypes.Custom by default), TreeLeaf, Shake, CreateDust, CanDropAcorn and DropWood work as in tModLoader; PlantLoader.Get<ModTree>(TileID.Trees, groundType) finds the tree.
  • Not available yet: ModPalmTree, SetTreeFoliageSettings (it is not called) and tree painting (TreeShaderSettings is not used). TileID.Sets.TreeSapling is kept by the loader, since the mobile game has no such set.

Cacti

A ModCactus is the same idea for cacti: it shares the game's cactus tile, grows on the tiles in GrowsOnTileId and gives the textures of the cactus and of its fruit. The Example Mod's grows on its own sand:

public class ExampleCactus : ModCactus
{
    private Asset<Texture2D> texture;
    private Asset<Texture2D> fruitTexture;

    public override void SetStaticDefaults()
    {
        GrowsOnTileId = [ModContent.TileType<ExampleSand>()];
        texture = ModContent.Request<Texture2D>("ExampleMod/Content/Tiles/Plants/ExampleCactus");
        fruitTexture = ModContent.Request<Texture2D>("ExampleMod/Content/Tiles/Plants/ExampleCactus_Fruit");
    }

    public override Asset<Texture2D> GetTexture() => texture;

    public override Asset<Texture2D> GetFruitTexture() => fruitTexture;
}

The fruit sheet has a layout of its own: start from the Example Mod's ExampleCactus_Fruit.png.

Pylons

A ModPylon is a ModTile with a TEModdedPylon entity, written as in tModLoader:

public sealed class SimplePylonTileEntity : TEModdedPylon { }

public class ExamplePylonTile : ModPylon
{
    public override void SetStaticDefaults()
    {
        Main.tileFrameImportant[Type] = true;
        TileObjectData.newTile.CopyFrom(TileObjectData.Style3x4);
        TEModdedPylon moddedPylon = ModContent.GetInstance<SimplePylonTileEntity>();
        TileObjectData.newTile.HookCheckIfCanPlace = new PlacementHook(moddedPylon.PlacementPreviewHook_CheckIfCanPlace, 1, 0, true);
        TileObjectData.newTile.HookPostPlaceMyPlayer = new PlacementHook(moddedPylon.Hook_AfterPlacement, -1, 0, false);
        TileObjectData.addTile(Type);
        AddToArray(ref TileID.Sets.CountsAsPylon);
        AddMapEntry(Color.White, CreateMapEntryName());
    }

    public override void KillMultiTile(int i, int j, int frameX, int frameY) => ModContent.GetInstance<SimplePylonTileEntity>().Kill(i, j);
}
  • Each ModPylon gets a PylonType after the game's (11, 12, ...). Its entities join the game's pylon list (Main.PylonSystem), so HasPylonOfType, teleporting, the "near a pylon" check and multiplayer sync work with the game's own code.
  • CanPlacePylon (one per type by default), ValidTeleportCheck_NPCCount and ValidTeleportCheck_BiomeRequirements (called with the SceneMetrics scanned around the destination) decide placement and teleporting.
  • DrawMapIcon draws the icon on the full map, usually with DefaultDrawMapIcon and DefaultMapClickHandle. SpecialDraw with DefaultDrawPylonCrystal draws the floating crystal (DrawEffects already asks for SpecialDraw once per pylon).
  • Touching the pylon opens the map in the mobile pylon mode, framing every revealed pylon, like a vanilla pylon.
  • GetNPCShopEntry adds the pylon item to town NPC shops, except those in NPCShopDatabase.NoPylons.
  • After those checks, ValidTeleportCheck_DestinationPostCheck and ValidTeleportCheck_NearbyPostCheck can still refuse the teleport with a message of their own, and ModifyTeleportationPosition changes where the player lands. A GlobalPylon steps into the placement, the teleport checks and the map icon of every pylon, the game's included.
  • Not available yet: the smart cursor highlight of the crystal and the TileFrame override tModLoader uses to break a pylon. TileID.Sets.CountsAsPylon is kept by the loader, since the mobile game has no such set.

Enemy banners

An enemy banner is a ModBannerTile. It sets up the 1x3 banner object (hanging from a block or a platform), the map entry, the sway in the wind and the bonus against the banner's enemies. Each placed style is one banner, and the item that places that style is the banner item:

public class EnemyBanner : ModBannerTile
{
    public enum StyleID
    {
        ExampleWormHead,
        ExampleCustomAISlimeNPC
    }
}

public class ExampleCustomAISlimeNPCBanner : ModItem
{
    public override void SetDefaults()
    {
        Item.DefaultToPlaceableTile(ModContent.TileType<EnemyBanner>(), (int)EnemyBanner.StyleID.ExampleCustomAISlimeNPC);
        Item.width = 10;
        Item.height = 24;
    }
}

The NPC links itself to the banner in ModNPC.SetDefaults, as in tModLoader:

Banner = Type;
BannerItem = ModContent.ItemType<ExampleCustomAISlimeNPCBanner>();
ItemID.Sets.KillsToBanner[BannerItem] = 25; // optional, 50 by default
  • A mod banner's ID is the type of its representative NPC, the one with Banner = Type and a BannerItem. Other NPCs of the same family set Banner to that type and count on the same banner. To share a vanilla banner, use Banner = BannerSystem.NPCtoBanner(NPCID.Zombie) and BannerItem = BannerSystem.BannerToItem(Banner).
  • BannerSystem.NPCtoBanner, BannerToItem and BannerToNPC know the mod banners, so the game's own code handles kills, the kill announcement, claiming at the banner screen and the bonus.
  • The bonus works when the banner is near the player, through ModBannerTile.NearbyEffects. The banner item needs ItemID.Sets.BannerStrength[item].Enabled, which is on by default.
  • The kill counts and the banners left to claim are saved in the world's .wld.bl.json under <mod UID>/<NPC name>, so they survive a different load order. The .wld file itself keeps only the vanilla banners. In multiplayer the game's own banner packet carries the mod banners too.
  • Not available yet: the banner bonus line in the buff tooltip (the game lists only vanilla banners). A tile that does not extend ModBannerTile cannot get the wind sway from TilesRenderer.AddSpecialPoint(i, j, TileCounterType.MultiTileVine).

World persistence

Mod tiles are saved by the native core in <world>.wld.tiles.bl. Their stable key is <mod UID>/<tile name>: keep both to reuse saved tiles across versions of your mod; the numeric type may change.

The .wld file keeps a world the plain game can open, and the mod tiles live only in .wld.tiles.bl, with their frames and shapes: keep the two files together when you copy a world. When a mod is missing, its tiles stay saved in that file and come back with the mod, as long as nothing was built where they were; meanwhile those cells are empty. VanillaFallbackOnModDeletion does not change this on the phone.

Examples

The Example Mod has a tile for almost everything on this page: ExampleBlock and ExampleSand, the ExampleWorkbench that some of its recipes need, an ExampleChest and an ExampleDresser, an ExampleChair and an ExampleBed, a door (ExampleDoorClosed and its open half), an ExampleTorch, the ExampleTree and the ExampleCactus, the ExamplePylonTile, the EnemyBanner and the BasicTileEntity.


← Players  ·  Walls →

Clone this wiki locally