iOS
GameplayKit

Willekeurige getallen genereren

Hoewel GameplayKit (die wordt geïntroduceerd met iOS 9 SDK) gaat over het implementeren van gamelogica, kan het ook worden gebruikt om willekeurige getallen te genereren, wat erg handig is in apps en games.

Naast de GKRandomSource.sharedRandom die in de volgende hoofdstukken wordt gebruikt, zijn er drie extra typen GKRandomSource 's uit de doos.

• GKARC4RandomSource Die het ARC4-algoritme gebruikt
• GKLinearCongruentialRandomSource Wat een snelle maar niet zo willekeurige GKRandomSource
• GKMersenneTwisterRandomSource Die een MersenneTwister-algoritme implementeert. Het is langzamer maar meer willekeurig.

In het volgende hoofdstuk gebruiken we alleen de methode nextInt() van een GKRandomSource . Daarnaast is er de nextBool() -> Bool en de nextUniform() -> Float

Generatie

Importeer eerst GameplayKit :

Snel

import GameplayKit

Doelstelling C

#import <GameplayKit/GameplayKit.h>

Gebruik vervolgens deze code om een willekeurig getal te genereren:

Snel

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

Doelstelling C

int randomNumber = [[GKRandomSource sharedRandom] nextInt];

Notitie

De functie nextInt () retourneert een willekeurig getal tussen -2.147.483.648 en 2.147.483.647, inclusief zichzelf, als deze zonder parameters wordt gebruikt, dus we weten niet zeker of het altijd een positief of niet-nul getal is.

Een nummer genereren van 0 tot n

Om dit te bereiken, moet u n geven aan de methode nextIntWithUpperBound() :

Snel

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

Doelstelling C

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

Deze code geeft ons een nummer tussen 0 en 10, inclusief zichzelf.

Een nummer genereren van m tot n

Hiertoe maakt u een GKRandomDistribution object met een GKRandomSource en geeft u de grenzen op. Een GKRandomDistribution kan worden gebruikt om het distributiegedrag zoals GKGaussianDistribution of GKShuffledDistribution .

Daarna kan het object worden gebruikt zoals elke reguliere GKRandomSource omdat het ook het GKRandom protocol implementeert.

Snel

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

Doelstelling-C verouderd

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

Als u bijvoorbeeld een willekeurig getal tussen 3 en 10 wilt genereren, gebruikt u deze code:

Snel

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

Doelstelling-C verouderd

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

GKEntity en GKComponent

Een entiteit vertegenwoordigt een object van een spel zoals een spelersfiguur of een vijandelijk figuur. Omdat dit object niet veel doet zonder armen en benen kunnen we de componenten hieraan toevoegen. Apple heeft de klassen GKEntity en GKComponent om dit systeem te maken.

Laten we aannemen dat we de volgende klasse hebben voor de volgende hoofdstukken:

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

GKEntity

Een entiteit is een verzameling componenten en biedt verschillende functies om componenten toe te voegen, te verwijderen en ermee te werken.

Hoewel we de GKEntity gewoon kunnen gebruiken, is het gebruikelijk om deze te subclasseren voor een specifiek type game-entiteit.

Het is belangrijk dat het slechts eenmaal mogelijk is een component van een klasse toe te voegen. In het geval dat u een tweede component van dezelfde klasse toevoegt, vervangt deze de eerste bestaande component binnen de 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

Je vraagt je misschien waarom. De reden hiervoor is de methode die component(for: T.Type) die de component van een specifiek type entiteit retourneert.

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

Naast de componenten-methoden heeft het een update die wordt gebruikt om de delta-tijd of huidige tijd van de spellogica te delegeren aan de componenten.

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

GKComponent

Een component vertegenwoordigt iets van een entiteit, bijvoorbeeld de visuele component of de logische component.

Als een updatemethode van een entiteit wordt genoemd, wordt deze aan alle componenten overgedragen. Het overschrijven van deze methode wordt gebruikt om een entiteit te manipuleren.

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

Daarnaast is het mogelijk om de methode didAddToEntity en willRemoveFromEntity te willRemoveFromEntity om andere componenten te informeren over de verwijdering of toevoegen.

Om een andere component in een component te manipuleren, is het mogelijk om de GKEntity te krijgen waaraan de component is toegevoegd.

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

Hoewel dit mogelijk is, is het geen gebruikelijk patroon omdat het de twee componenten aan elkaar verbindt.

GKComponentSystem

Terwijl we net gesproken over het gebruik van de update afgevaardigde mechanisme van de GKEntity om de update GKComponents is er een andere manier om te werken GKComponents die heet GKComponentSystem .

Het wordt gebruikt voor het geval dat alle componenten van een specifiek type in één keer moeten worden bijgewerkt.

Een GKComponentSystem is gemaakt voor een specifiek type component.

let system = GKComponentSystem(componentClass: PlayerSpriteComponent.self)

Om een component toe te voegen, kunt u de methode toevoegen gebruiken:

system.addComponent(PlayerSpriteComponent())

Maar een meer gebruikelijke manier is om de gecreëerde entiteit met zijn componenten door te geven aan het GKComponentSystem en het zal een overeenkomende component vinden binnen de entiteit.

system.addComponent(foundIn: player)

Om alle componenten van een specifiek type bij te werken, roept u de update aan:

system.update(deltaTime: delta)

Als u het GKComponentSystem wilt gebruiken in plaats van een op een entiteit gebaseerd updatemechanisme, moet u voor elke component een GKComponentSystem hebben en de update op alle systemen aanroepen.