Ce projet a été créé pour aider à mieux comprendre le processus de création d'un jeu dans Niantic Studio qui nécessite des actions physiques de la part de l'utilisateur pour contrôler le mécanisme central du jeu. Dans cet exemple, la rotation de la tête de l'utilisateur est utilisée pour contrôler le joueur principal. Il utilise également le composant d'animation intégré pour contrôler de nombreux éléments du jeu, tels que les mouvements des ennemis. 

Le jeu s'appelle « THE LAST PIN » (la dernière quille) et vous incarnez une quille de bowling qui tente d'esquiver les boules qui lui sont lancées. Plus vous survivez longtemps, plus vous gagnez de points. Une fois que le joueur est touché par une boule de bowling, la partie est terminée. Tout au long du jeu, la fréquence à laquelle les boules de bowling apparaissent augmente, tout comme leur vitesse.

• de la scène 3D

  La scène globale est assez simple et utilise un mélange de modèles 3D et de formes primitives pour créer l'environnement. Il utilise également des éléments d'interface utilisateur 3D afin que leur position puisse être manipulée dans un espace 3D.

  Ressources

  d'

• Ce projet comprend 2 ressources 3D. La gouttière est placée de chaque côté de la piste de bowling et la quille est contrôlée par l'utilisateur à l'aide des mouvements de sa tête. Vous pouvez penser à la broche et au joueur principal. 
• Il y a 1 fichier audio qui est lu lorsque la broche est touchée par la balle. 
• Dans le dossier texture se trouve une combinaison de textures de modèles et d'éléments d'interface utilisateur.
• Il y a également un total de 10 textures de balles différentes. Ils sont appliqués de manière aléatoire à chaque balle lorsqu'elle apparaît.

  Scripts

  d'

• Il n'y a qu'un seul script dans ce projet, « GameController », qui gère toute la logique nécessaire au jeu. Comme il s'agit d'un jeu assez simple, un seul script est nécessaire, ce qui devrait faciliter la compréhension du fonctionnement et de l'interaction de toutes les fonctions, composants et valeurs. 

Cette section de la documentation passe en revue certains des mécanismes fondamentaux du jeu.

- Déplacement du joueur 
Dans le schéma, il est fait référence à l'objet « Pin », qui vous permet de modifier les composants de l'objet tels que la position, la rotation, l'échelle, le matériau, etc. 

Maintenant, dans la hiérarchie des scènes, sélectionnez le composant Game Controller (où le script « GameController » est associé) et accédez au script dans le panneau Inspecteur. Il existe une option pour épingler, alors assurez-vous de sélectionner le bon objet à l'aide du menu déroulant.

Maintenant, dans la fonction add du script « GameController », nous pouvons créer une référence à cet objet afin de pouvoir facilement y faire référence dans d'autres fonctions. 

Dans la fonction add, nous créons également deux écouteurs d'événements. L'un écoute lorsque le visage est visible « facecontroller.faceupdated » et l'autre écoute lorsque le visage est masqué « facecontroller.facelost ». À la fin de l'écouteur d'événement, nous définissons le nom de la fonction que nous voulons appeler lorsque cet événement se produit : lorsque le visage est mis à jour, appeler la fonction « show » et lorsque le visage est perdu, appeler la fonction « lost ». 

La fonction « show » transmet les valeurs de la position et de la rotation de la tête de l'utilisateur. Une variable est créée dans cette fonction « xRot » à laquelle est attribuée la valeur de la rotation x de la tête de l'utilisateur. À l'intérieur d'une instruction IF, qui vérifie si le jeu est en cours, la valeur xRot est constamment appliquée à la position X des broches dans la scène. Cette valeur est multipliée par une autre variable « pinSpeed » qui peut facilement être modifiée dans l'objet de scène GameController, car il s'agit d'une autre variable de schéma. 

de vitesse de la broche

- Génération des balles 
Lorsque le jeu commence (l'utilisateur tape sur l'écran), les balles commencent à apparaître. Chaque balle a une position X de départ aléatoire et une position X d'arrivée aléatoire, afin que les balles se déplacent en diagonale, ce qui rend le jeu plus difficile. Une vitesse croissante mais aléatoire est appliquée à chaque balle, une rotation est appliquée en fonction de la distance entre la position de départ X et la position finale, et une texture aléatoire (parmi 10 options) est appliquée à chaque balle. La plupart de ces fonctions sont gérées par l'implémentation du contrôleur d'animation intégré à Niantic Studio. 
De la même manière que nous avons créé une référence d'objet vers la broche, nous devons à nouveau créer 10 références d'objet différentes dans le schéma pour les 10 boules de bowling. 

Une fois encore, nous pouvons utiliser la barre de sélection déroulante du script GameController associé à l'objet GameController dans la scène pour appliquer chaque balle.

Dans la fonction Add, nous pouvons créer une référence à chaque balle afin qu'elle soit facilement accessible dans tout le script. 

Lorsque le jeu démarre, soit au début de l'expérience, soit lorsqu'il est redémarré, la fonction « spawnBall » est appelée. 

Tout ce qui se trouve à l'intérieur de la fonction « spawnBall » est imbriqué dans une instruction if qui vérifie si le jeu est en cours. Cela permet d'éviter que d'autres balles apparaissent une fois la partie terminée. 
À la fin de la fonction, vous pouvez voir qu'une fonction « setTimeout » est utilisée pour rappeler la fonction « spawnBall ». La valeur « spawnTime » correspond au temps qui doit s'écouler avant que la fonction soit appelée. Cette valeur est modifiée au début de la fonction à chaque fois qu'elle est appelée. 

Ces deux fonctions fonctionnent de la même manière et commencent par définir la valeur « negativeStart » avec une valeur aléatoire comprise entre 0 et 1. Ceci sert à déterminer si la position X est négative ou positive. Ensuite, la variable « xValue » se voit attribuer une valeur aléatoire comprise entre 0 et 2. Cette valeur est ensuite renvoyée, mais si « negativeStart » est égal à 0, alors la valeur xValue est inversée. 

Nous calculons ensuite dans quelle direction se déplace la balle : se déplace-t-elle en diagonale vers la gauche ou vers la droite ? Nous utilisons cela à nouveau pour appliquer l'animation de rotation. Si la balle se déplace vers la gauche, elle doit également tourner vers la gauche.

La fonction suivante appelée est la fonction « applyMaterial ». Au début de la fonction add, un tableau pour les noms de textures a été créé. Un autre tableau est défini qui contient toutes les balles, afin que nous puissions suivre quelle balle est générée et appliquer des éléments tels que l'animation de position et le nouveau matériau à la bonne balle. 

Il est important que ces noms correspondent aux textures de votre dossier de ressources, mais n'incluent pas l'extension, par exemple png. 
Au début de la fonction « applyMaterial », un nombre aléatoire compris entre 0 et 9 est généré. En fonction de ce nombre, une texture spécifique est ensuite appliquée à la balle. La fonction ecs.Material.set est appliquée à la balle actuelle dans le tableau et définit une nouvelle texture à partir de la liste de noms du tableau de textures, en fonction de l'option générée aléatoirement. 

Il est important que ces noms correspondent aux textures dans votre dossier de ressources, mais n'incluent pas l'extension, par exemple png. 
Au début de la fonction « applyMaterial », un nombre aléatoire compris entre 0 et 9 est généré. En fonction de ce nombre, une texture spécifique est ensuite appliquée à la balle. La fonction ecs.Material.set est appliquée à la balle actuelle dans le tableau et définit une nouvelle texture à partir de la liste de noms du tableau de textures, en fonction de l'option générée aléatoirement. 

Ensuite, la fonction « applyScaleAnimation » est appelée.

Ensuite, la fonction « applyScaleAnimation » est appelée.

La fonction « applyPositionAnimation » est ensuite appelée pour ajouter le mouvement de la boule de bowling. Les valeurs « randomxStart » et « randomxEnd » sont transmises à cette fonction. C'est un excellent exemple du fonctionnement du système d'animation intégré au studio Niantic. L'avantage d'utiliser le système d'animation plutôt qu'un système physique qui applique une force est que vous pouvez mieux contrôler la vitesse et que celle-ci ne varie pas en fonction de la qualité de l'appareil, par exemple. 

Comme vous pouvez le voir, la « durée » de cette animation est définie en appelant la fonction « getRandomSpeed ». La durée est exprimée en millisecondes et plus cette valeur est faible, plus l'animation sera rapide. 

La fonction « getRandomSpeed » génère un nombre aléatoire compris entre 0 et la valeur « ballSpeedVariation », qui est définie par défaut à 200. Cette valeur est ensuite ajoutée à la variable « initialSpeed » qui est définie sur 3000. Cela signifie que la durée de l'animation peut être comprise entre 3000 et 3200 millisecondes (avec quelques légères variations). Chaque fois que cette fonction est appelée, elle vérifie si « initialSpeed » est supérieur à « maximumBallSpeed ». Si c'est le cas, la valeur de « ballSpeedIncreaseValue » est soustraite, ce qui accélère l'animation de la position au fil du temps (rendant le jeu plus difficile à mesure que vous avancez).

Ensuite, la fonction « applyRotationAnimation » est appelée et la valeur « differenceInDistance » est transmise à cette fonction. C'est également ici que la variable « curveLeft » est utilisée. L'animation de rotation appliquée à la boule se fait uniquement sur l'axe Z, afin d'imiter la façon dont les boules de bowling tournent dans la réalité. Au début de la fonction, elle vérifie si « curveLeft » est vrai.

La vitesse de rotation est modifiée en modifiant la valeur « durée » de l'animation. Au début de la fonction, une variable « rotationValue » est définie en prenant 4000 et en soustrayant la valeur « differenceInDistance » multipliée par 50. Cela signifie que plus la différence entre la position de départ x et la position finale x est importante, plus la valeur de rotation appliquée à la durée de l'animation est faible (l'animation s'effectue donc plus rapidement). Cette animation est en boucle afin que les balles tournent en permanence. Il est également important de définir « shortestPath » sur « false », sinon cela donnerait l'impression que rien ne se passe. 

Enfin, à la fin de la fonction « spawnBall », la valeur « currentBall » est modifiée.

 de détection de collision

Tout au long du jeu, il y a deux cas où une collision est détectée. Une fois lorsqu'une balle entre en collision avec la « CollisionBox » située derrière la quille. Lorsque cette collision est détectée, cela signifie que le joueur a réussi à esquiver une boule de bowling et qu'un point doit être marqué. L'autre cas est celui où une balle touche la quille, ce qui met fin à la partie. 
Comme la plupart des éléments de ce projet, cela commence par la création d'une référence à l'objet dans le schéma. Le nom de l'objet que nous voulons vérifier est entré en collision avec quelque chose, c'est « collision ». Nous appliquons ensuite cet objet dans la scène et créons une référence au début de la fonction add. 

Toutes les boules sont également associées à un collisionneur physique, mais le paramètre « Rigidbody » est défini sur « Dynamic » car les boules sont en mouvement. La case « Event Only » (Événement uniquement) est également cochée ici, car nous voulons qu'une collision soit détectée, mais nous ne voulons pas que les balles interagissent réellement avec la boîte et rebondissent.

À l'intérieur de la fonction « add », un écouteur d'événement est créé : « ecs.physics.COLLISION_START_EVENT ». Ce composant est ajouté à l'objet « collision » et, lorsqu'une collision est détectée, il appelle la fonction « handleCollision ». Nous n'avons pas besoin de garder trace de l'objet qui entre en collision, car les balles sont les seuls éléments qui peuvent entrer en collision dans ce projet. 

La collision entre la balle et la broche est gérée exactement de la même manière, mais au lieu de créer un écouteur d'événement pour l'objet « collision », nous vérifions l'objet « broche » auquel nous avons déjà une référence, car nous contrôlons sa position à l'aide de la rotation de la tête de l'utilisateur. Il appelle la fonction « hitPin », qui contient toute la logique nécessaire au scénario de fin de partie. 

Personnaliser  

Toutes ces valeurs peuvent être modifiées en sélectionnant « GameController » dans la hiérarchie de la scène, puis en naviguant vers le panneau d'inspection où vous les trouverez sous le script « GameController ». 
Vitesse de la balle - Il s'agit de la vitesse à laquelle la balle (le joueur principal) se déplace. Plus cette valeur est élevée, plus le déplacement est rapide. Ne vous inquiétez pas, cela ne fera pas disparaître la broche de l'écran, car nous bloquons sa position. 
Fréquence d'apparition initiale - Il s'agit du temps (en millisecondes) nécessaire pour qu'une nouvelle balle apparaisse après la précédente. N'oubliez pas que cette valeur diminue à chaque fois qu'une balle apparaît. Il est donc conseillé de la garder assez élevée au début du jeu afin que celui-ci ne soit pas trop difficile dès le départ.

Spawn Frequency Multiplier (Multiplicateur de fréquence d'apparition) - Il s'agit de la valeur qui est soustraite de la fréquence d'apparition initiale. Vous pouvez considérer cette valeur comme le taux auquel le jeu devient plus difficile. Avec sa valeur par défaut actuellement fixée à 5, cela signifie que chaque fois qu'une balle apparaît, le temps nécessaire à l'apparition de la balle suivante est réduit de 5 millisecondes. Plus ce nombre est élevé, plus le temps d'apparition sera réduit et plus la fréquence maximale d'apparition des balles sera atteinte. Encore une fois, il est préférable de garder ce nombre assez bas, afin que le jeu ne devienne pas trop difficile trop rapidement. 

Fréquence minimale d'apparition - Il s'agit de la valeur minimale que vous souhaitez attribuer à la fréquence d'apparition. Par défaut, cette valeur est réglée sur 500 millisecondes, ce qui signifie que le délai d'apparition entre chaque balle ne sera jamais inférieur à une demi-seconde. Vous pouvez considérer cette valeur comme la difficulté maximale. Si vous souhaitez vraiment mettre le joueur à l'épreuve, vous pouvez réduire cette valeur afin que les balles apparaissent plus rapidement. 

Vitesse initiale de la balle - Il s'agit du temps initial nécessaire à la balle pour se déplacer vers le joueur. N'oubliez pas que cette valeur diminue au cours du jeu afin d'augmenter la vitesse de la balle. La valeur par défaut signifie qu'au début de l'expérience, la balle mettra environ 3 secondes pour atteindre le joueur (en fonction de la variation ajoutée). 

Variation de la vitesse de la balle - Il s'agit de la valeur aléatoire appliquée à la vitesse de la balle afin que toutes les balles à l'écran ne se déplacent pas à la même vitesse. Avec la valeur par défaut fixée à 200, cela signifie que la vitesse de la balle peut varier de 0 à 200 millisecondes plus rapide. Plus cette valeur est élevée, plus la vitesse des balles varie, plus le nombre est faible, plus la vitesse des balles est constante. 

Valeur d'augmentation de la vitesse de la balle - Ce nombre est soustrait de la vitesse de la balle chaque fois qu'une balle est générée. Cela signifie que chaque fois qu'une balle est générée, la vitesse augmente de 10 millisecondes. Plus ce chiffre est élevé, plus les balles atteindront rapidement leur vitesse maximale. 

Vitesse maximale des balles - Il s'agit de la vitesse maximale à laquelle les balles peuvent se déplacer. Pour l'instant, cette valeur est fixée à 2000 millisecondes, ce qui signifie qu'avec une variation potentielle de 200 millisecondes, le temps minimum nécessaire à une balle pour atteindre le joueur est de 1800 millisecondes. Si vous réduisez ce nombre, cela signifie que la vitesse maximale sera plus rapide. 

Aller de l'avant 
L'idée derrière ce modèle était de fournir les mécanismes de base d'un jeu. Le plus grand avantage de créer des jeux, c'est que vous pouvez raconter toutes les histoires que vous voulez ! Au lieu de simplement ajuster les valeurs de ce jeu, essayez de modifier l'histoire en échangeant les éléments. Pour l'instant, vous êtes une quille de bowling qui essaie d'esquiver des boules de bowling sur une piste de bowling, mais vous pourriez être un skieur esquivant d'énormes boules de neige tout en descendant une montagne, ou un vaisseau spatial qui doit éviter des astéroïdes. Si vous remplacez les boules de neige par des boules de neige, vous pourriez modifier la rotation afin qu'elles tournent vers l'avant et non sur le côté.