SKTiled Framework

Layers in SKTiled are containers for different data types and are all subclasses of SKTiledLayerObject. This base class provides coordinate transformation and positioning information.

Supported layer types include:

• Tile layers: Hold an array of tile sprites and tileset data.
• Object groups: Contain vector shape objects.
• Image layers: Display a single image.
• Group layers: Encapsulate other layers.

You can query layers by their specific type, by their name, or by their index.

// query layers by type
let tileLayers = tilemap.tileLayers
let objectGroups = tilemap.objectGroups
let imageLayers = tilemap.imageLayers
let groupLayers = tilemap.groupLayers

// query named layers
let groundLayers = tilemap.getLayers(named: "Ground") as! [SKTileLayer]
let objectGroups = tilemap.getLayers(named: "Objects") as! [SKObjectGroup]
let hudLayers = tilemap.getLayers(named: "HUD") as! [SKImageLayer]

// query layer at a specific index
if let firstLayer = tilemap.getLayer(atIndex: 1) as! SKTileLayer {
    firstLayer.visible = true
}

In Swift, if a base class conforms to a protocol with default implementations (like SKTilemapDelegate), subclassing that base class to override protocol methods may fail because Swift may favor the default protocol implementation over your subclass's override.

To ensure your custom logic is called, you have two options:

1. Implement the protocol on the base class: Ensure the base class provides the necessary implementation so that overrides in the subclass are recognized.
2. Use a secondary method pattern: Implement the protocol method in the base class, which then calls a separate, non-protocol method. You can then override that secondary method in your subclass.

It is generally recommended to implement protocols directly on your objects rather than relying on subclassing classes that already conform to them.

// Recommended pattern: Use a secondary method to bypass protocol implementation issues
class BaseScene: SKScene, SKTilemapDelegate {
    func didRenderMap(_ tilemap: SKTilemap) {
        // call a secondary method that can be overridden
        setupTilemap(tilemap)
    }

    func setupTilemap(_ tilemap: SKTilemap) {
        print("BaseScene: setting up tilemap: \"\(tilemap.name!)\"")
    }
}

class LevelScene: BaseScene {
    override func setupTilemap(_ tilemap: SKTilemap) {
        print("LevelScene: setting up tilemap: \"\(tilemap.name!)\"")
    }
}

Since SKTilemap and SKTiledLayerObject are subclasses of SKEffectNode, you can apply Core Image effects, shaders, and distortions.

To use shaders, you must set shouldEnableEffects = true.

Warning: Enabling effects consumes more CPU/GPU. Additionally, SKEffectNode uses a buffer with a maximum texture size of 2048x2048. If your map exceeds these dimensions, it will appear cropped. Enabling effects also softens the edges of nearest-neighbor textures, which may affect the look of retro-style games.

// 1. Enable effects
tilemap.shouldEnableEffects = true

// 2. Load and configure shader
let shader = SKShader(fileNamed: "waves")
shader.attributes = [SKAttribute(name: "a_map_size", type: .vectorFloat2)]
tilemap.shader = shader

// 3. Pass data to shader
tilemap.setValue(SKAttributeValue(vectorFloat2: tilemap.sizeInPoints.toVec2), forAttribute: "a_map_size")