Class

TilingSprite

Extends AbstractTexturedGraphics<PixiTilingSprite>

Renders a Texture repeated across a rectangular region attached to a WorldObject — the building block for tiled floors, walls, and scrolling backgrounds.

Where a Sprite draws one copy of a texture, a TilingSprite fills a width x height region by repeating its texture as many times as needed. It builds on AbstractGraphics, so it inherits scene-parenting and the once-per-frame transform sync (position, rotation, and the host's scale).

Region size vs. tile size

Two independent levers, neither of which fights the inherited transform sync:

TilingSprite.width / TilingSprite.height — the size of the region to fill, in world units. Changing these adds or removes repeats.
TilingSprite.setTileScale — the on-screen size of each repeated tile. This is how you draw 16px pixel-art tiles at, say, 3x without changing the region. The host's WorldObject.scale still scales the whole thing on top, as with any graphics component.

Scrolling

TilingSprite.setTileOffset shifts the tiling pattern within the region; animate it each tick for a parallax/scrolling background.

Example

// A 2000x2000 floor of a 16px tile drawn at 3x, centred on the object.
const floor = world.createObject();
const tile = new Texture(tileset, { x: 16, y: 16, width: 16, height: 16 });
floor.addComponentFromFactory(
  'floor',
  (host) =>
    new TilingSprite(host, tile, {
      width: 2000,
      height: 2000,
      tileScale: 3,
    }),
);

Constructors

constructor(host: WorldObject, texture: Texture, options: TilingSpriteOptions): TilingSprite

Parameters

host WorldObject
texture Texture
options TilingSpriteOptions

Properties

enabled: boolean

Per-component gate on the three update hooks (onPreUpdate, onUpdate, onPostUpdate). When explicitly false, the engine skips all three for this component during the host's tick — useful for temporarily pausing behaviour (e.g. a freeze powerup) without removing the component and losing its internal state.

Does not gate onAdded or onDestroy; those always fire so a host can never end up with a half-attached component.

readonly #

host: WorldObject

The host this component is attached to. Stored read-only; subclasses access it as this.host directly, or through the tier-appropriate aliases (this.world, this.game) on the per-tier abstract bases.

Accessors

alpha: number

Opacity from 0 (fully transparent) to 1 (fully opaque). Applies to the whole graphic, including any children the display object holds.

readonly #

anchor: Point

The anchor point as a fresh Point of per-axis fractions (0–1). See TexturedGraphicsOptions.anchor for the meaning. Returned by value; mutating the result does not affect the graphic — use AbstractTexturedGraphics.setAnchor.

readonly #

game: Game

The Game the host's world belongs to. Always non-null — the world's game field is a mandatory construction argument, not an option.

height: number

The height of the tiled region in world units. See TilingSprite.width.

layer: undefined | Layer

The render layer this graphic is in, or undefined in a layer-less world.

Assigning a different Layer re-parents the display into that layer's container, moving the graphic between bands at runtime (e.g. dropping a dying enemy below the living). The same opt-in rules as GraphicsOptions.layer apply: a layered world rejects undefined (ErrorCode.LAYER_UNSPECIFIED), a layer-less world rejects a token (ErrorCode.LAYER_SET_ABSENT), and a foreign token is rejected by Scene.containerForLayer (ErrorCode.LAYER_NOT_IN_SET).

readonly #

raw: T

Direct access to the underlying Pixi display object.

Use with care. raw is an intentional escape hatch for cases the arcade2d API doesn't cover — custom shaders, filter chains, advanced blend modes, mask assignment, world-space bounds queries, anything we haven't decided how to model yet. Code that touches raw is coupled to Pixi's public API and may break when:

arcade2d upgrades Pixi (including minor versions).
Pixi itself ships a breaking change.
arcade2d swaps Pixi for a different renderer.

None of those will be treated as breaking changes to arcade2d's own surface. Prefer the typed methods on this component; reach for raw only when no equivalent exists, and isolate the access behind your own helper so the coupling is in one place.

readonly #

texture: Texture

The Texture this tiling sprite repeats.

readonly #

tileOffset: Readonly<Point>

The current tiling-pattern offset as a fresh Readonly Point. Returned by value so mutating it is inert (and now a compile error); use TilingSprite.setTileOffset to change it.

readonly #

tileScale: Readonly<Point>

The per-tile scale as a fresh Readonly Point. Returned by value so mutating it is inert (and now a compile error); use TilingSprite.setTileScale to change it.

tint: number

Multiplicative tint as a 24-bit RGB integer; 0xffffff is untinted. See TexturedGraphicsOptions.tint.

visible: boolean

Whether the graphic is drawn. A hidden graphic still ticks and stays transform-synced; it is simply skipped by the renderer.

width: number

The width of the tiled region in world units. Setting it changes how many times the texture repeats horizontally; it does not scale the tiles (use TilingSprite.setTileScale) or fight the host transform.

readonly #

world: World

The World the host WorldObject lives in. Shorthand for this.host.world.

Methods

protected #

_destroyOptions(): DestroyOptions

The options handed to the underlying Pixi display object's destroy during AbstractGraphics.onDestroy. The base returns {} — destroy the node itself but leave shared resources alone, since textures are owned by the asset layer and shared across instances. Subclasses that construct an owned, non-shared Pixi resource override this to release it (e.g. Text returns { style: true } to free the TextStyle Pixi created for it).

Returns

DestroyOptions

onAdded(): void

Lifecycle hook that is called when the component is added to the host object. Should not be called directly.

Returns

void

onDestroy(): void

Lifecycle hook that is called when the host object is destroyed. Should not be called directly.

Returns

void

x number
y number

Returns

void