ArcadeWorld

Extended physics world that integrates Arcade physics with Ceramic's visual system.

This class extends the base arcade.World to provide seamless collision detection between Ceramic visuals, groups, bodies, and tilemaps. It handles the complex type resolution needed to make different Ceramic object types work with the physics engine.

Key features:

• Automatic type detection for Visual, Group, Body, and Tilemap objects
• Optimized collision detection with quadtree spatial partitioning
• Support for both overlap (trigger) and collide (solid) interactions
• Integration with tilemap plugin for tile-based collisions
• Specialized sorting algorithms for broad-phase optimization

Usage example:

var world = arcade.world;
world.gravity.y = 800;

// Collide two visuals
world.collide(player, enemy, (body1, body2) -> {
    trace("Player hit enemy!");
});

// Check overlaps with a group
world.overlap(player, collectibles, (body1, body2) -> {
    // Collect the item
});

Instance Members #

Whether a body moving a lot in one frame is tested against tilemaps in several steps along its displacement, so that it can't go through a tile without ever overlapping it (see separateBodyVsTilemapLayersSwept()).

Whether a body still overlapping a full tile after the regular separation is pushed out through one of the tile's exposed faces (see escapeFromTile()).

Checks for overlaps between collidable elements without separating them.

Overlaps are useful for triggers, collectibles, and other non-solid interactions. The overlap callback is called for each pair of overlapping bodies.

Supports all combinations of:

• Visual vs Visual
• Visual/Body vs Group
• Group vs Group
• Any vs Tilemap/TilemapLayer (with tilemap plugin)

Checks for overlaps between all bodies in two arcade groups.

This optimized implementation uses temporary arrays to avoid modification during iteration and applies sorting for broad-phase optimization.

Checks for overlaps between a single body and all bodies in a group.

Uses quadtree spatial partitioning for large groups to improve performance. Only bodies near the target body are checked for overlap.

Checks for collisions between collidable elements and separates them.

Collisions prevent objects from overlapping by pushing them apart. The collide callback is called for each pair of colliding bodies after separation.

Supports all combinations of:

• Visual vs Visual
• Visual/Body vs Group
• Group vs Group
• Any vs Tilemap/TilemapLayer (with tilemap plugin)

Sorts a Ceramic visual group for optimized collision detection.

Sorting bodies by position allows the collision system to exit early when checking pairs, significantly improving performance for large groups.

Uses specialized merge sort implementations optimized for each direction.

Creates a new ArcadeWorld with the specified bounds.

The world bounds define the area where physics simulation occurs. Bodies outside these bounds may not collide properly.

Performs collision detection and separation between a body and a tilemap.

Only checks tiles that the body overlaps with for efficiency. Each colliding tile is treated as a solid immovable body.

Collides a body with the collidable layers of several tilemaps at once, in a single sweep (separateBodyVsTilemapLayersSwept): tilemaps placed next to each other then behave as one continuous solid. Colliding them one after the other would not: each sweep restarts from the body's previous position and would undo what the others did. With layerName, only the layer of that name in each tilemap is used.

Private Members #

Reusable body instance for tilemap collisions.

Instead of creating a new body for each tile collision, we reuse this single instance for performance. The body is configured as immovable and its position/size is updated for each tile.

Determines the actual type of a collidable element for proper collision routing.

This method resolves Ceramic's visual types to their base classes so the collision system can handle them appropriately. For example, all Visual subclasses (Quad, Mesh, etc.) are treated as Visual for collision purposes.

Checks for overlaps between all visuals in two Ceramic groups.

Extracts physics bodies from visuals and performs overlap checks. Handles null bodies gracefully.

Separates a body against tilemap layers (layers, or the single layer if given), moving the body along its displacement in several steps when it moved a lot this frame.

A body is only tested against the tiles it overlaps at its current position, so a body moving more than its own size in one frame could end up past a tile without ever overlapping it. Stepping by at most half the body size on each axis makes sure the first tile on the path is met. The steps only concern the collision test: velocity and gravity were integrated once, for the whole frame, before this is called.

Pushes body out of tile, a full tile it is still overlapping after the regular separation, through one of the tile's exposed faces. The face the body came through is preferred when the body moved on that axis this step and is not deeper through that face than its displacement, otherwise the nearest exposed face is used: a body resting a few pixels inside a wall is pushed sideways, never lifted onto the wall. Returns false when no face is exposed (the body is inside a thick wall).

Core tilemap collision implementation for a single layer.

This method:

1. Calculates which tiles the body overlaps
2. Creates a temporary immovable body for each solid tile
3. Performs collision/overlap detection
4. Handles special cases like connected tiles and slopes