GameplayKit Espace de noms

L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.

Classes

GKAgent	qui GKComponent peut se déplacer et a des objectifs.
GKAgent2D	GKAgent dont le mouvement est limité à deux dimensions.
GKAgent3D	Agent 3D qui répond aux objectifs.
GKAgentDelegate	Objet Délégué qui fournit des méthodes relatives à la synchronisation de l’état d’un GKAgent avec des contraintes externes, des objectifs et des représentations.
GKAgentDelegate_Extensions	Méthodes d’extension à l’interface IGKAgentDelegate pour prendre en charge toutes les méthodes du GKAgentDelegate protocole.
GKARC4RandomSource	Générateur aléatoire basé sur l’algorithme ARC4. Souvent un bon choix.
GKBehavior	Collection d’objets et de GKGoal poids, définissant ensemble un comportement de jeu cohérent.
GKBillowNoiseSource	dont GKCoherentNoiseSource la sortie est similaire au bruit Perlin, mais avec des caractéristiques plus arrondies.
GKCheckerboardNoiseSource	dont GKNoiseSource la sortie se compose d’une alternance de carrés noirs et blancs.
GKCircleObstacle	GKObstacle défini par un emplacement et un rayon.
GKCoherentNoiseSource	dont GKNoiseSource la sortie varie en douceur et en continu.
GKComponent	Superclasse abstraite pour les composants, y compris GKAgent les objets, dans une architecture Entity-Component (voir remarques).
GKComponentSystem<TComponent>	Contient GKComponent des objets d’un sous-type spécifique et les met à jour régulièrement.
GKCompositeBehavior	GKBehavior qui combine d’autres GKBehavior objets.
GKConstantNoiseSource	GKNoiseSource dont la sortie est une valeur unique.
GKCylindersNoiseSource	dont GKNoiseSource la sortie se compose de coquilles cylindriques concentriques. Adapté aux textures de grain de bois.
GKDecisionNode	Élément d’un GKDecisionTree.
GKDecisionTree	Arborescence de questions, de réponses et d’actions.
GKEntity	Type composé d’un certain nombre d’objets GKComponent dans une architecture Entity-Component.
GKGameModel	Décrit le gameplay d’une manière qui peut être optimisée avec un GKMinMaxStrategist.
GKGameModel_Extensions	Méthodes d’extension à l’interface IGKGameModel pour prendre en charge toutes les méthodes du GKGameModel protocole.
GKGameModelPlayer_Extensions	Méthodes d’extension à l’interface IGKGameModelPlayer pour prendre en charge toutes les méthodes du IGKGameModelPlayer protocole.
GKGaussianDistribution	GKRandomDistribution qui produit une distribution gaussienne (normale).
GKGoal	Influence le déplacement d’un ou de plusieurs GKAgent objets.
GKGraph	Graphique mathématique utilisé pour la navigabilité et le pathfinding.
GKGraphNode	Classe de base pour les nœuds d’un GKGraph.
GKGraphNode2D	GKGraphNode qui contient une position à virgule flottante 2D.
GKGraphNode3D	GKGraphNode qui existe dans un espace tridimensionnel.
GKGridGraph	dans GKGraph lequel le mouvement est limité à une grille d’entiers
GKGridGraphNode	GKGraphNode qui contient une position entière 2D.
GKHybridStrategist	IGKStrategist qui combine Recherche d’arbres Monte Carlo et recherche locale via MinMax.
GKLinearCongruentialRandomSource	Un rapide GKRandomSource. Les bits de faible ordre sont un peu moins aléatoires que dans GKARC4RandomSource.
GKMersenneTwisterRandomSource	Un lent GKRandomSource avec une très bonne aléatoire.
GKMeshGraph<NodeType>	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
GKMinMaxStrategist	Ia de jeu qui évalue les états de jeu potentiels, les note et tente de maximiser son propre score tout en minimisant ses adversaires.
GKMonteCarloStrategist	Stratégiste qui arrive à une solution qui est probablement proche de l’optimale dans un laps de temps déterministe.
GKNoise	Utilise un GKNoiseSource pour générer de manière procédurale un champ de bruit tridimensionnel infini.
GKNoiseMap	Coupe un rectangle à deux dimensions fini du champ de bruit infini et tridimensionnel d’un GKNoise objet.
GKNoiseSource	Classe de base abstraite pour les générateurs de bruit procéduraux.
GKNSPredicateRule	GKRule qui utilise un NSPredicate pour déterminer si son action doit être appelée.
GKObstacle	Classe abstraite représentant les zones que GKAgent les objets ne peuvent pas parcourir.
GKObstacleGraph	GKGraph qui génère un réseau de remplissage d’espace pour la représentation, ce qui permet des chemins fluides, mais inefficaces.
GKObstacleGraph<NodeType>	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
GKOctree<ElementType>	Structure de données qui organise efficacement les éléments tridimensionnels.
GKOctreeNode	Nœud dans un GKOctree<ElementType>. Géré automatiquement par le lorsque les GKOctree<ElementType> objets sont ajoutés et supprimés.
GKPath	Contient un chemin polygonal 2D qui peut être suivi d’un GKAgent.
GKPerlinNoiseSource	qui génère un GKCoherentNoiseSource bruit Perlin amélioré.
GKPolygonObstacle	avec GKObstacle une forme arbitrairement complexe.
GKQuadTree	Structure de données qui organise efficacement les objets dans un espace à deux dimensions.
GKQuadTreeNode	Nœud dans une quadtree.
GKRandomDistribution	Définit une distribution de probabilité. Cette classe définit une distribution uniforme (toutes les valeurs sont également probables), tandis que les GKGaussianDistribution sous-classes et GKShuffledDistribution fournissent des probabilités différentes.
GKRandomSource	Classe de base pour les générateurs de nombres pseudo-aléatoires appropriés pour le jeu. N’utilisez pas à des fins de chiffrement ou de sécurité.
GKRidgedNoiseSource	GKCoherentNoiseSource dont la sortie est similaire au bruit Perlin, mais avec des limites nettes.
GKRTree<ElementType>	Structure de données permettant de rechercher efficacement des objets organisés dans un espace à deux dimensions.
GKRule	Élément unique, comprenant un prédicat et une action, qui représente une règle discrète dans un GKRuleSystem.
GKRuleSystem	Gère une collection d’objets GKRule , en les activant selon les besoins.
GKScene	Associe des objets GameplayKit à un SpriteKit SKScene.
GKSCNNodeComponent	GKComponent qui fonctionne sur un SCNNode.
GKShuffledDistribution	GKRandomDistribution qui mélange une collection de manière à rendre peu probables les séquences de valeurs similaires (séries chaudes/froides minimales).
GKSKNodeComponent	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
GKSphereObstacle	GKObstacle qui est un volume sphérique impraticable.
GKSpheresNoiseSource	GKNoiseSource dont la sortie se compose de shells concentriques. Adapté aux textures de grain de bois.
GKState	Classe abstraite représentant un état discret dans un GKStateMachine.
GKStateMachine	Conserve les GKState objets et gère les transitions entre eux.
GKVoronoiNoiseSource	GKNoiseSource dont la sortie divise l’espace en cellules entourant les points de départ. Approprié pour les textures cristallines.
NSArray_GameplayKit	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
SCNNode_GameplayKit	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
SKNode_GameplayKit	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.

Structures

GKBox	Boîte rectangulaire tridimensionnelle alignée sur l’axe.
GKQuad	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
GKTriangle	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.

Interfaces

IGKAgentDelegate	Interface représentant les méthodes requises (le cas échéant) du protocole GKAgentDelegate.
IGKGameModel	État actuel du jeu. Particulièrement utile conjointement avec GKMinMaxStrategist.
IGKGameModelPlayer	Un joueur identifié de manière unique d’un jeu. Les développeurs doivent implémenter GetPlayerId(IGKGameModelPlayer).
IGKGameModelUpdate	Un déplacement de jeu valide. Données minimales nécessaires pour faire passer un valide IGKGameModel à un état ultérieur valide.
IGKRandom	Interface pour les générateurs de nombres pseudo-aléatoires GameplayKit.
IGKSceneRootNodeType	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.
IGKStrategist	Interface pour un stratège de jeu (IA).

Énumérations

GKMeshGraphTriangulationMode	Contient des options pour la façon dont les nœuds doivent être générés dans un GKMeshGraph<NodeType>.
GKRTreeSplitStrategy	L’espace de noms GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que le pathfinding, les moteurs de règles et les adversaires d’IA.

Remarques

Introduit dans iOS 9, GameplayKit fournit des classes pour les mécanismes de jeu de haut niveau tels que l’authentification, les moteurs de règles (à la fois flous et classiques) et un adversaire IA prédéfini sous la forme de GKMinMaxStrategist.

Adversaire IA

Le théorème minimax, énoncé pour la première fois par John von Neumann en 1928, soutient que dans un jeu à deux personnes, somme nulle, avec des stratégies limitées, il existe un jeu optimal (ou des jeux) qui maximise simultanément la valeur attendue pour le joueur actuel et réduit la valeur attendue pour le joueur adverse. En d’autres termes, dans de tels jeux, il y a un « meilleur coup » (même si, bien sûr, même le meilleur coup peut entraîner une perte ou une égalité, selon l’état du jeu).

GameplayKit implémente l’algorithme minimax dans sa GKMinMaxStrategist classe et les classes associées (en particulier GKGameModel). Le GKMinMaxStrategist est une version optimisée de l’algorithme minimax qui utilise efficacement la mémoire et analyse l’arborescence de recherche sur les nœuds de terminal, mais les développeurs doivent savoir que l’algorithme peut être coûteux : l’efficacité du temps de l’algorithme minimax est O(b^m) l’emplacement où b est le nombre d’états d’un « ply » d’aperçu unique et m le nombre de plis recherchés (voir P:MonoTouch>GameplayKit.GKMinMaxStrategist.MaxLookAheadDepth). L’efficacité de l’espace de l’algorithme est O(m).

Le théorème minimax s’applique à un très grand nombre de jeux, des jeux trivials tels que Nim et Tic-Tac-Toe, aux jeux complexes comme Échecs et Go. Cependant, les jeux tels que Chess et Go ont tellement d’états de jeu possibles et plies que le coût du calcul du mouvement optimal devient rapidement astronomique. Même dans de tels cas, le GKMinMaxStrategist peut être utilisé pour évaluer plusieurs centaines ou milliers de mouvements et, si le développeur peut programmer avec précision une estimation de la force ou de la faiblesse d’un état de jeu donné, produire un adversaire fort.

Le GKMinMaxStrategist n’a pas besoin d’être sous-classé par le développeur. Au lieu de cela, le développeur implémente trois interfaces et les transmet au GKMinMaxStrategist:

Classe	Objectif
IGKGameModel	Les développeurs implémentent cette interface afin de modéliser le jeu et son état actuel. Dans un jeu de plateau, pour instance, il s’agit généralement du plateau et de toutes les pièces et d’une référence au joueur actif. En outre, si elle doit être utilisée avec GKMinMaxStrategist, cette classe doit implémenter les fonctions qui décrivent les déplacements potentiels (M:GameplayKit.GKGameModule.GetGameModelUpdates*) et les évaluer en termes de désirabilité (IsWin, IsLoss, GetScore).
IGKGameModelUpdate	Cette classe décrit un « déplacement » de jeu et contient suffisamment d’informations pour effectuer la IGKGameModel transition entre son état actuel et un nouveau valide. Plusieurs milliers d’instances de cette classe peuvent être requises par , GKMinMaxStrategistde sorte que le développeur doit veiller à le rendre léger.
IGKGameModelPlayer	le GKMinMaxStrategist s’appuie sur la valeur de M:GameplayKit.IGKGameModelPlayer.GetPlayerID*) pour faire la distinction entre les joueurs.

La méthode clé de est GKMinMaxStrategistGetBestMove. Lorsque cette méthode est appelée, la séquence d’appels suivante se produit :

Tout d’abord, les IGKGameModelPlayer objets sont récupérés. Ensuite, en commençant par l’état actuel du jeu, et bien que la profondeur de la page soit inférieure MaxLookAheadDepthà , l’ensemble des mouvements légaux possibles de l’état actuel est retourné par M:GameplayKit.GKMinMaxStrategist.GetGameModelUpdates*. Ensuite, pour chacun de ces mouvements, il peut être nécessaire d’allouer une nouvelle mémoire ; si c’est le GKMinMaxStrategist cas, M:GameplayKit.GKMinMaxStrategist.Copy* est appelé. Ensuite, sur l’un des nombreux GKGameModel objets gérés par , GKMinMaxStrategistun déplacement potentiel est exécuté avec des appels à SetGameModel et M:GameplayKit.IGKGameModel.ApplyGameState*.

Ensuite GKMinMaxStrategist , évalue chacun des mouvements potentiels en appelant, d’abord IsWin et IsLoss. Si l’une de ces méthodes retourne true, le GKMinMaxStrategist marque l’état du jeu en tant que nœud terminal et ne tentera pas de l’examiner plus en détail dans des plis ultérieurs. Si aucune des méthodes ne retourne true, la méthode M:GameplayKit.GKGameModel_Extensions.Score* est appelée.

Le développeur doit écrire une méthode M:GameplayKit.GKGameModel_Extensions.Score* pour retourner une valeur comprise entre MinScore (-16777216) et MaxScore (+16777216). Les valeurs plus élevées représentent les états de jeu qui sont meilleurs pour .GetActivePlayer Dans les jeux simples où l’arbre de jeu entier peut être recherché parce que ou toujours retourner true dans MaxLookAheadDepth, la méthode M:GameplayKit.GKGameModel_Extensions.Score* peut simplement retourner 0, car le GKMinMaxStrategist peut calculer le meilleur mouvement en fonction des coups gagnants et perdants.IsLossIsWin Toutefois, cela n’est susceptible d’être le cas que dans les jeux assez faciles et, en général, la création d’une fonction M:GameplayKit.GKGameModel_Updates.Score* exigera à la fois une expertise en jeu et en programmation. En termes de programmation, la méthode M:GameplayKit.GKGameModel_Updates.Score* est appelée plusieurs fois lors de la recherche de l’arborescence du jeu et doit être efficace et précise.

Les développeurs doivent noter que le GKMinMaxStrategist peut allouer de nombreuses copies de IGKGameModelPlayer et IGKGameModel ainsi que de nombreux IGKGameModelUpdate objets. Les développeurs doivent s’appuyer sur la valeur, pas sur la référence, sur l’égalité, et doivent faire preuve de prudence lorsqu’il s’agit de ces objets manipulant l’état global ou statique.