CODEWITHSUNDEEP
iosswiftclassoverridingoption-type
MysteryPancake
MysteryPancake

Reputation: 1505

Optional functions for override in Swift classes?

I'm trying to make a simple game using Swift. The game has different levels, and each level requires the game to behave in slightly different ways. I decided to use a different class for each level, all inherited from a base level class.

This is the base:

import SpriteKit

class LevelBase {

  var scene: GameScene! // Seems very dodgy
  var blocks = [SKSpriteNode]()

  init(scene: GameScene) { // Should this be required init?
    self.scene = scene
  }

  func filterBlock(_ block: SKSpriteNode) {
    blocks = blocks.filter() { $0 !== block } // Looks really dodgy to me
  }

  func update(time: TimeInterval) {
    // For override
  }

  func levelUp() {
    // For override
  }

  func postGenerate() {
    // For override
  }
}

However, to me, this class seems to be very badly written. I can't find any examples anywhere of functions created in a class just to be overwritten, which makes me think I'm doing something wrong. Should I be using extensions or protocols for optional functions like that? I don't quite understand how they work, so I haven't used any so far.

The second issue is that this class needs to be initialized with the game scene variable, since some levels need it to add or remove sprites. This seems especially dodgy, considering the class is created in the game scene's file.

Surely there's a better way?

Upvotes: 1

Views: 1109

Answers (1)

vikingosegundo
vikingosegundo

Reputation: 52227

I have no experience with SpriteKit, but from a general perspective you should consider to "Favour composition over Inheritance".

You would have one Level class that is not intended for subclassing but can be instantiated with objects or values that have different implementation.

Additionally you should use protocols to define those and you can add default implementation as protocol extensions. 

final class Level {
    init(levelImplementation: LevelImplementationType) {
        self.levelImplementation = levelImplementation
    }

    let levelImplementation: LevelImplementationType

    func navigate()  {
        levelImplementation.navigate()
    }

    func update(timeInterval: TimeInterval) {
        levelImplementation.update(timeInterval: timeInterval)
    }

}

The Level would be instantiated with an object or struct conforming to LevelImplementationType

protocol LevelImplementationType {
    func navigate()
    func update(timeInterval: TimeInterval)
}

Default implementations can be done via an extension.

extension LevelImplementationType {
    func navigate() {

    }
    func update(timeInterval: TimeInterval) {

    }
}

The LevelImpelmenation needs to conform to LevelImplementationType, but don't have any further constraints. i.e. they can have very different initialisers.

struct LevelImplementation1: LevelImplementationType {
    // useses default implementation of `navigate` and `update` from extension
}

struct LevelImplementation2: LevelImplementationType {
    // useses default implementation of `update` from extension

    func navigate() {
    }
}

struct LevelFileImplementation: LevelImplementationType {
    init(with path: String) {
        // read variables from file at path
    }

    func navigate() {
        // navigate as given in file
    }

}

Level instances cane be created like

let level1 = Level(levelImplementation: LevelImplementation1())
let level2 = Level(levelImplementation: LevelImplementation2())
let level3 = Level(levelImplementation: LevelFileImplementation(with: "path/to/file"))

Upvotes: 3

Related Questions