iOS
GameplayKit

Zufallszahlen generieren

Obwohl es sich bei GameplayKit (das mit iOS 9 SDK eingeführt wird) um die Implementierung von Spiellogik handelt, kann es auch zur Erzeugung von Zufallszahlen verwendet werden, was in Apps und Spielen sehr nützlich ist.

Neben GKRandomSource.sharedRandom das in den folgenden Kapiteln verwendet wird, gibt es drei zusätzliche Typen von GKRandomSource 's out-of-the-box.

• GKARC4RandomSource Verwendet den ARC4-Algorithmus
• GKLinearCongruentialRandomSource Dies ist eine schnelle, aber nicht zufällige GKRandomSource
• GKMersenneTwisterRandomSource Die Implementierung eines MersenneTwister-Algorithmus. Es ist langsamer aber zufällig.

Im folgenden Kapitel verwenden wir nur die nextInt() Methode einer GKRandomSource . Dazu kommen nextBool() -> Bool und nextUniform() -> Float

Generation

Importiere zuerst GameplayKit :

Schnell

import GameplayKit

Ziel c

#import <GameplayKit/GameplayKit.h>

Verwenden Sie dann diesen Code, um eine Zufallszahl zu generieren:

Schnell

let randomNumber = GKRandomSource.sharedRandom().nextInt()

Ziel c

int randomNumber = [[GKRandomSource sharedRandom] nextInt];

Hinweis

Wenn die nextInt () - Funktion ohne Parameter verwendet wird, wird eine Zufallszahl zwischen -2.147.483.648 und 2.147.483.647 einschließlich ihrer zurückgegeben. Daher sind wir nicht sicher, dass es sich immer um eine positive oder eine ungleich Null handelt.

Eine Zahl von 0 bis n erzeugen

Um dies zu erreichen, sollten Sie der nextIntWithUpperBound() Methode n geben:

Schnell

let randomNumber = GKRandomSource.sharedRandom().nextInt(upperBound: 10)

Ziel c

int randomNumber = [[GKRandomSource sharedRandom] nextIntWithUpperBound: 10];

Dieser Code gibt uns eine Zahl zwischen 0 und 10, einschließlich sich selbst.

Eine Zahl von m bis n generieren

Dazu erstellen Sie ein GKRandomDistribution Objekt mit einer GKRandomSource und übergeben die Grenzen. Eine GKRandomDistribution kann verwendet werden, um das Verteilungsverhalten wie GKGaussianDistribution oder GKShuffledDistribution zu ändern.

Danach kann das Objekt wie jede reguläre GKRandomSource da es auch das GKRandom Protokoll implementiert.

Schnell

let randomizer = GKRandomDistribution(randomSource: GKRandomSource(), lowestValue: 0, highestValue: 6)
let randomNumberInBounds = randomizer.nextInt()

Objective-C veraltet

int randomNumber = [[GKRandomSource sharedRandom] nextIntWithUpperBound: n - m] + m;

Um beispielsweise eine Zufallszahl zwischen 3 und 10 zu generieren, verwenden Sie diesen Code:

Schnell

let randomNumber = GKRandomSource.sharedRandom().nextInt(upperBound: 7) + 3

Objective-C veraltet

int randomNumber = [[GKRandomSource sharedRandom] nextIntWithUpperBound: 7] + 3;

GKEntity und GKComponent

Eine Entität repräsentiert ein Objekt eines Spiels wie eine Spielerfigur oder eine gegnerische Figur. Da dieses Objekt ohne Arme und Beine nicht viel ausmacht, können wir die Komponenten dazu hinzufügen. Um dieses System zu erstellen, verfügt Apple über die Klassen GKEntity und GKComponent .

Nehmen wir an, wir haben die folgende Klasse für die folgenden Kapitel:

class Player: GKEntity{}
class PlayerSpriteComponent: GKComponent {}

GKEntity

Eine Entität ist eine Sammlung von Komponenten und bietet verschiedene Funktionen zum Hinzufügen, Entfernen und Interagieren mit Komponenten davon.

Während wir die GKEntity einfach verwenden könnten, ist es üblich, sie für einen bestimmten Typ von Spieleinheiten zu subclassieren.

Es ist wichtig, dass eine Komponente nur einmal hinzugefügt werden kann. Wenn Sie eine zweite Komponente derselben Klasse hinzufügen, überschreibt sie die erste vorhandene Komponente in GKEntity

let otherComponent = PlayerSpriteComponent()
var player = Player()
player.addComponent(PlayerSpriteComponent())
player.addComponent(otherComponent)
print(player.components.count) //will print 1
print(player.components[0] === otherComponent) // will print true

Sie fragen vielleicht warum. Der Grund dafür sind die als component(for: T.Type) Methoden, die die Komponente eines bestimmten Entitätstyps zurückgeben.

let component = player.component(ofType: PlayerSpriteComponent.self) 

Neben den Komponenten-Methoden gibt es eine update , mit der die Deltazeit oder die aktuelle Zeit der Spiellogik an ihre Komponenten delegiert wird.

var player = Player()
player.addComponent(PlayerSpriteComponent())
player.update(deltaTime: 1.0) // will call the update method of the PlayerSpriteComponent added to it

GKComponent

Eine Komponente stellt etwas von einer Entität dar, beispielsweise die visuelle Komponente oder die Logikkomponente.

Wenn eine Aktualisierungsmethode einer Entität aufgerufen wird, wird sie an alle ihre Komponenten delegiert. Das Überschreiben dieser Methode wird zum Manipulieren einer Entität verwendet.

class PlayerSpriteComponent: GKComponent {
    override func update(deltaTime seconds: TimeInterval) {
        //move the sprite depending on the update time
    }
}

Darüber hinaus ist es möglich, die Methode didAddToEntity und willRemoveFromEntity zu willRemoveFromEntity , um andere Komponenten über das Entfernen oder Hinzufügen zu informieren.

Um eine andere Komponente innerhalb einer Komponente zu bearbeiten, ist es möglich, die GKEntity abzurufen, zu der die Komponente hinzugefügt wird.

override func update(deltaTime seconds: TimeInterval) {
    let controller = self.entity?.component(ofType: PlayerControlComponent.self)
    //call methods on the controller
}

Während dies möglich ist, ist es kein allgemeines Muster, da es die beiden Komponenten miteinander verbindet.

GKComponentSystem

Während wir gerade über die Verwendung des Aktualisierungsdelegationsmechanismus von GKEntity zum Aktualisieren der GKComponents gibt es eine andere Möglichkeit, GKComponents zu aktualisieren, die als GKComponentSystem .

Es wird verwendet, wenn alle Komponenten eines bestimmten Typs auf einmal aktualisiert werden müssen.

Ein GKComponentSystem wird für einen bestimmten Komponententyp erstellt.

let system = GKComponentSystem(componentClass: PlayerSpriteComponent.self)

Um eine Komponente hinzuzufügen, können Sie die add-Methode verwenden:

system.addComponent(PlayerSpriteComponent())

Eine üblichere Methode besteht jedoch darin, die erstellte Entität mit ihren Komponenten an das GKComponentSystem und es wird eine passende Komponente innerhalb der Entität gefunden.

system.addComponent(foundIn: player)

Um alle Komponenten eines bestimmten Typs zu aktualisieren, rufen Sie das Update auf:

system.update(deltaTime: delta)

GKComponentSystem Sie das GKComponentSystem anstelle eines GKComponentSystem Aktualisierungsmechanismus verwenden GKComponentSystem , müssen GKComponentSystem für jede Komponente ein GKComponentSystem und das Update auf allen Systemen aufrufen.