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 #

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.

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.

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