Les crochets pour chats ajoutent des mécaniques amusantes et intéressantes au jeu. Vous pouvez les utiliser pour vous déplacer dans les niveaux, combattre dans les arènes et obtenir des objets. Mais malgré l'apparente simplicité, la physique de la gestion des cordes et la création d'un comportement réaliste peuvent être difficiles!
Dans la première partie de ce tutoriel, nous implémentons notre propre système crochet-chat bidimensionnel et apprenons ce qui suit:
- Créez un système de visée.
- Utilisez le rendu de ligne et le joint de distance pour créer la corde.
- Nous apprendrons à la corde à enrouler les objets du jeu.
- Calculez l'angle de swing sur la corde et ajoutez de la force dans cette direction.
Remarque : ce didacticiel est destiné aux utilisateurs avancés et expérimentés, et il ne couvre pas des sujets tels que l'ajout de composants, la création de nouveaux scripts GameObject et la syntaxe C #. Si vous avez besoin d'améliorer vos compétences Unity, consultez nos didacticiels Prise en main de Unity et Introduction à Unity Scripting . Étant donné que DistanceJoint2D est utilisé dans ce didacticiel, vous devez également parcourir les joints physiques dans Unity 2D , puis revenir à ce didacticiel.
Se rendre au travail
Téléchargez le
brouillon de ce didacticiel, puis ouvrez-le dans l'éditeur Unity. Unity 2017.1 ou supérieur est requis pour le fonctionnement.
Ouvrez la scène du
jeu à partir du dossier
Scènes et voyez par où commencer:
Pour l'instant, nous avons un personnage joueur simple (limace) et des pierres suspendues dans les airs.
Les composants importants de GameObject
Player jusqu'à présent sont le collisionneur de capsules et le corps rigide, qui lui permettent d'interagir avec des objets physiques au niveau. En outre, un script de mouvement simple (
PlayerMovement ) est attaché au personnage, lui permettant de glisser sur le sol et d'effectuer des sauts simples.
Appuyez sur le bouton
Lecture pour démarrer le jeu et essayez de contrôler le personnage.
A et
D le déplacent vers la gauche / droite, et lorsque vous appuyez sur la
barre d'espace, il saute. Essayez de ne pas glisser et de tomber de la falaise, sinon vous mourrez!
Nous avons déjà les bases de la gestion, mais le plus gros problème est le manque d'hameçons.
Création de crochets et de cordes
Au début, le système de crochet de chat semble assez simple, mais pour sa mise en œuvre de haute qualité, il est nécessaire de prendre en compte de nombreux aspects. Voici quelques-unes des exigences pour la mécanique du crochet à deux dimensions:
- Rendu de ligne pour afficher la corde. Lorsque la corde s'enroule autour d'objets, nous pouvons ajouter plus de segments au rendu de ligne et placer les sommets aux points correspondant aux ruptures de la corde.
- DistanceJoint2D. Il peut être utilisé pour fixer le point d'ancrage actuel du crochet pour chat afin que notre limace puisse se balancer. Cela nous permet également d'ajuster la distance qui peut être utilisée pour allonger et réduire la corde.
- GameObject enfant avec RigidBody2D, qui peut être déplacé en fonction de l'emplacement actuel du point d'ancrage du crochet. En substance, ce sera le point de suspension / d'ancrage de la corde.
- Raycast pour lancer un crochet et attacher à des objets.
Sélectionnez l'objet
Player dans la hiérarchie et ajoutez-lui un nouvel GameObject enfant nommé
RopeHingeAnchor . Ce GameObject sera utilisé pour positionner le point de suspension / d'ancrage du crochet pour chat.
Ajoutez des composants
SpriteRenderer et
RigidBody2D à
RopeHingeAnchor .
Pour SpriteRenderer, définissez la propriété
Sprite pour utiliser la valeur
UISprite et remplacez
Order in Layer par
2 . Désactivez le composant en
décochant la case à côté de son nom.
Pour le composant
RigidBody2D, définissez la propriété Type de corps sur
Cinématique . Ce point sera déplacé non pas par le moteur physique, mais par le code.
Sélectionnez le calque
Corde et définissez les valeurs d'échelle X et Y du composant Transformer sur
4 .
Sélectionnez à nouveau
Player et attachez le nouveau composant
DistanceJoint2D .
Faites glisser le
RopeHingeAnchor de la hiérarchie sur la propriété
Corps rigide connecté du composant
DistanceJoint2D et désactivez la
configuration automatique de la distance .
Créez un nouveau script C # appelé
RopeSystem dans le dossier du projet
Scripts et ouvrez-le dans l'éditeur de code.
Supprimez la méthode
Update .
En haut du script à l'intérieur de la
RopeSystem classe
RopeSystem ajoutez de nouvelles variables, la méthode
Awake() et la nouvelle méthode
Update :
Analysons chaque partie dans l'ordre:
- Nous utilisons ces variables pour suivre les différents composants avec lesquels le script RopeSystem interagira.
- La méthode
Awake démarre au début du jeu et désactive ropeJoint (composant DistanceJoint2D). Il définit également playerPosition à la position actuelle du lecteur. - C'est la partie la plus importante de la boucle principale
Update() . Tout d'abord, nous obtenons la position du curseur de la souris dans le monde en utilisant la ScreenToWorldPoint caméra ScreenToWorldPoint . Ensuite, nous calculons la direction de notre regard en soustrayant la position du joueur de la position de la souris dans le monde. Ensuite, nous l'utilisons pour créer aimAngle , qui est une représentation de l'angle de visée du curseur. La valeur stocke une valeur positive dans la construction if. aimDirection est une touche qui sera utile plus tard. Nous ne sommes intéressés que par la valeur Z, car nous utilisons une caméra 2D, et c'est le seul OS correspondant. Nous passons aimAngle * Mathf.Rad2Deg , qui convertit l'angle radian en angle en degrés.- La position du joueur est surveillée à l'aide d'une variable pratique qui vous permet de ne pas vous référer constamment à
transform.Position . - Enfin, nous avons la construction
if..else , que nous utiliserons bientôt pour déterminer si la corde est attachée au point d'ancrage.
Enregistrez le script et revenez à l'éditeur.
Attachez le composant
RopeSystem à l'objet Player et accrochez les différents composants dans les champs publics que nous avons créés dans le script
RopeSystem . Faites glisser
Player ,
Crosshair et
RopeHingeAnchor dans les champs appropriés:
- Ancre de charnière de corde : Ancrage de corde
- Joint de corde : Joueur
- Réticule : Réticule
- Crosshair Sprite : Crosshair
- Mouvement du joueur: Joueur
Maintenant, nous faisons juste tous ces calculs complexes, mais jusqu'à présent, il n'y a aucune visualisation qui pourrait les montrer en action. Mais ne vous inquiétez pas, nous le ferons bientôt.
Ouvrez le script
RopeSystem et ajoutez-y une nouvelle méthode:
private void SetCrosshairPosition(float aimAngle) { if (!crosshairSprite.enabled) { crosshairSprite.enabled = true; } var x = transform.position.x + 1f * Mathf.Cos(aimAngle); var y = transform.position.y + 1f * Mathf.Sin(aimAngle); var crossHairPosition = new Vector3(x, y, 0); crosshair.transform.position = crossHairPosition; }
Cette méthode positionne le viseur en fonction de l'
aimAngle transmis (la valeur flottante que nous avons calculée dans
Update() ) afin qu'il tourne autour du joueur avec un rayon de 1 unité. Nous incluons également une portée de sprite au cas où cela ne serait pas déjà fait.
Dans Update() nous modifions la construction !ropeAttached pour vérifier !ropeAttached afin qu'il ressemble à ceci:
if (!ropeAttached) { SetCrosshairPosition(aimAngle); } else { crosshairSprite.enabled = false; }
Enregistrez le script et lancez le jeu. Maintenant, notre limace devrait pouvoir viser avec une vue.
Le prochain morceau de logique qui doit être implémenté est un coup de crochet. Nous avons déjà déterminé la direction de la visée, nous avons donc besoin d'une méthode qui la recevra en paramètre.
Ajoutez les variables suivantes sous les variables du script
RopeSystem :
public LineRenderer ropeRenderer; public LayerMask ropeLayerMask; private float ropeMaxCastDistance = 20f; private List<Vector2> ropePositions = new List<Vector2>();
LineRenderer contiendra un lien vers un rendu de ligne qui dessine la corde.
LayerMask vous permet de personnaliser les couches physiques avec lesquelles le crochet peut interagir. La valeur
ropeMaxCastDistance définit la distance maximale que raycast peut "tirer".
Enfin, la liste des positions de Vector2 sera utilisée pour suivre les points d'enroulement de la corde, dont nous discuterons plus tard.
Ajoutez les nouvelles méthodes suivantes:
Voici ce que fait le code ci-dessus:
- HandleInput est appelé à partir de la boucle
Update() et interroge simplement l'entrée des boutons gauche et droit de la souris. - Lorsqu'un clic gauche est enregistré, la ligne de corde est activée et un lancer de rayons 2D est tiré depuis la position du joueur dans la direction de visée. La distance maximale est définie de sorte que le chat crochet ne puisse pas être abattu à une distance infinie, et un masque est appliqué afin qu'il soit possible de sélectionner les couches de physique avec lesquelles raycast peut entrer en collision.
- Si un coup de rayon est détecté, alors
ropeAttached est true , et une liste des positions des sommets de la corde est vérifiée pour s'assurer qu'il n'y a pas de point là. - Si la vérification est vraie, alors une petite impulsion de force est ajoutée au limace pour qu'il rebondisse au-dessus du sol, le
ropeJoint (DistanceJoint2D) est activé, qui est réglé sur une distance égale à la distance entre le limace et le point d'impact Raycast. Un sprite de point d'ancrage est également inclus. - Si raycast ne touche rien, le rendu de ligne et ropeJoint sont désactivés et l'indicateur
ropeAttached est faux. - Si le bouton droit de la souris est enfoncé, la méthode
ResetRope() est ResetRope() , ce qui désactive et réinitialise tous les paramètres liés à la corde / crochet aux valeurs qui devraient être si le crochet n'est pas utilisé.
Tout en bas de notre méthode
Update , ajoutez un appel à la nouvelle méthode
HandleInput() et transmettez-lui la valeur
aimDirection :
HandleInput(aimDirection);
Enregistrez les modifications apportées à
RopeSystem.cs et revenez à l'éditeur.
Ajout d'une corde
Notre limace ne pourra pas voler dans les airs sans corde, il est donc temps de lui donner quelque chose qui sera une représentation visuelle de la corde et aura la capacité de "tourner" dans les coins.
Le rendu de ligne est idéal pour cela, car il nous permet de transférer le nombre de points et leur position dans l'espace du monde.
L'idée ici est que nous stockons toujours le premier sommet de la corde (0) à la position du joueur, et tous les autres sommets sont positionnés dynamiquement lorsque la corde doit s'enrouler autour de quelque chose, y compris la position actuelle de la charnière, qui est le prochain point le long de la corde du joueur.
Sélectionnez
Player et ajoutez-y le composant
LineRenderer . Définissez la
largeur sur
0,075 . Développez la liste des
matériaux et, en tant
qu'élément 0, sélectionnez le matériau
RopeMaterial situé dans le dossier
Matériaux du projet. Enfin, pour le rendu de ligne, pour le
mode Texture, sélectionnez
Distribuer par segment .
Faites glisser le composant Line Renderer dans le champ
Rope Renderer du composant
Rope System .
Cliquez sur la liste déroulante du
masque de calque de
corde et sélectionnez comme calques avec lesquels raycast
Default, Rope et Pivot peuvent interagir. Pour cette raison, lors de la prise de vue d'un raycast, il n'entrera en collision qu'avec ces couches, mais pas avec d'autres objets, comme un lecteur.
Si vous démarrez le jeu maintenant, vous remarquerez un comportement étrange. Lorsque nous visons une pierre au-dessus de la tête de la limace et tirons avec un crochet, nous obtenons un petit saut vers le haut, après quoi notre ami commence à se comporter de manière plutôt aléatoire.
Nous n'avons pas encore défini la distance pour le joint de distance, de plus, les sommets du rendu de ligne ne sont pas configurés. Par conséquent, nous ne voyons pas la corde, et puisque le joint de distance est directement au-dessus de la position de la limace, la valeur actuelle de la distance du joint de distance le pousse vers le bas jusqu'aux pierres en dessous.
Mais ne vous inquiétez pas, nous allons maintenant résoudre ce problème.
Dans le script
RopeSystem.cs, ajoutez un nouvel opérateur au début de la classe:
using System.Linq;
Cela nous permet d'utiliser des requêtes LINQ, qui dans notre cas nous permettent simplement de trouver facilement le premier ou le dernier élément de la liste
ropePositions .
Remarque : Language-Integrated Query (LINQ) est le nom d'un ensemble de technologies basées sur l'incorporation de capacités de requête directement en C #. Vous pouvez en lire plus ici .
Ajoutez une nouvelle variable privée bool appelée
distanceSet sous les autres variables:
private bool distanceSet;
Nous utiliserons cette variable comme un indicateur afin que le script puisse reconnaître que la distance de la corde (pour le point entre le joueur et le point de référence actuel où le crochet de chat est attaché) est correctement définie.
Ajoutez maintenant une nouvelle méthode que nous utiliserons pour définir les positions des sommets de la corde pour rendre la ligne et définir la distance du joint dans la liste des positions stockées avec la corde (
ropePositions ):
private void UpdateRopePositions() {
Expliquez le code ci-dessus:
- Quittez la méthode si la corde n'est pas attachée.
- Nous attribuons la valeur des points de rendu de la ligne de corde au nombre de positions stockées dans
ropePositions , plus 1 de plus (pour la position du joueur). - Nous
ropePositions autour de la liste ropePositions et ropePositions pour chaque position (sauf la dernière), affectons la position du sommet du rendu de ligne à la valeur de la position Vector2 stockée par l'index de boucle dans la liste ropePositions . - Attribuez au point d'ancrage de la corde la seconde à partir de la position finale de la corde, dans laquelle le point d'articulation / d'ancrage actuel devrait être, ou si nous n'avons qu'une seule position de la corde, faites-en le point d'ancrage. Nous définissons donc la distance
ropeJoint égale à la distance entre le joueur et la position actuelle de la corde, que nous ropeJoint dans la boucle. - La construction if gère le cas où la position actuelle de la corde dans la boucle est la deuxième à partir de la fin; c'est-à-dire le point auquel la corde se connecte à l'objet, c'est-à-dire charnière / point d'ancrage actuel.
- Ce bloc
else gère l'attribution de la position du dernier sommet de la corde à la valeur de la position actuelle du joueur.
N'oubliez pas d'ajouter l'appel
UpdateRopePositions() à la fin de
Update() UpdateRopePositions() :
UpdateRopePositions();
Enregistrez les modifications apportées au script et relancez le jeu. Faites un "petit espace" un petit saut en visant et en tirant avec un crochet sur une pierre au-dessus du personnage. Vous pouvez maintenant profiter des fruits de votre travail - la limace se balance calmement sur les pierres.
Vous pouvez maintenant aller à la fenêtre de la scène, sélectionner Joueur, utiliser l'outil de déplacement (par défaut, la touche
W ) pour le déplacer et regarder comment les deux sommets de la ligne de corde rendent la position du crochet et la position du joueur pour tirer la corde. Après avoir relâché le lecteur, DistanceJoint2D calcule correctement la distance et la limace continuera de se balancer sur la charnière connectée.
Gestion des points de bouclage
Jouer avec une limace balançante n'est jusqu'à présent pas plus utile qu'une serviette hydrofuge, nous devons donc absolument la compléter.
La bonne nouvelle est que la méthode nouvellement ajoutée pour le traitement des positions de corde peut être utilisée à l'avenir. Jusqu'à présent, nous n'utilisons que deux positions de corde. L'un est lié à la position du joueur, et le second à la position actuelle du point d'ancrage du crochet lors du tir.
Le seul problème est que même si nous ne suivons pas toutes les positions potentielles de la corde, cela nécessite un peu de travail.
Pour reconnaître les positions sur les pierres autour desquelles la corde doit être enroulée, en ajoutant une nouvelle position de sommet au rendu de ligne, nous avons besoin d'un système qui détermine si le point de sommet du collisionneur se situe entre la ligne droite entre la position actuelle du limace et le point d'articulation / d'ancrage actuel de la corde.
On dirait que cela fonctionne à nouveau pour le bon vieux raycast!
Tout d'abord, nous devons créer une méthode qui peut trouver le point le plus proche dans le collisionneur en fonction du point d'impact du raycast et des bords du collisionneur.
Ajoutez une nouvelle méthode au script
RopeSystem.cs :
Si vous n'êtes pas familier avec les requêtes LINQ, ce code peut sembler être une sorte de magie C # compliquée.
Si oui, alors n'ayez pas peur. LINQ fait beaucoup de travail pour nous:
- Cette méthode prend deux paramètres - l'objet RaycastHit2D et l' objet PolygonCollider2D . Toutes les pierres du niveau ont des collisionneurs PolygonCollider2D, donc si nous utilisons toujours des formes PolygonCollider2D, cela fonctionnera bien.
- C'est là que la magie des requêtes LINQ commence! Ici, nous transformons la collection de points du collisionneur polygonal en dictionnaire de position Vector2 (la valeur de chaque élément du dictionnaire est la position elle-même), et la clé de chaque élément est affectée de la distance entre ce point et la position du joueur (valeur flottante). Parfois, quelque chose d'autre se passe ici: la position résultante est convertie en espace mondial (par défaut, les positions des sommets du collisionneur sont stockées dans l'espace local, c'est-à-dire local par rapport à l'objet auquel appartient le collisionneur, et nous avons besoin de positions dans l'espace mondial).
- Le dictionnaire est trié par clé. En d'autres termes, par la distance la plus proche de la position actuelle du joueur. La distance la plus proche est renvoyée, c'est-à-dire que tout point renvoyé par cette méthode est le point de collision entre le joueur et le point actuel de la charnière de corde!
Revenons au script
RopeSystem.cs et ajoutons une nouvelle variable de champ privé en haut:
private Dictionary<Vector2, int> wrapPointsLookup = new Dictionary<Vector2, int>();
Nous l'utilisons pour suivre les positions autour desquelles la corde peut s'enrouler.
À la fin de la méthode
Update() , recherchez la construction
else qui contient
crosshairSprite.enabled = false; et ajoutez ce qui suit:
Expliquez ce morceau de code:
- Si certaines positions sont enregistrées dans la liste des positions de
ropePositions , alors ... - Nous tirons depuis la position du joueur en direction du joueur qui regarde la dernière position de la corde de la liste - le point d'ancrage auquel le crochet de chat est attaché à la pierre - avec une distance de lancer de rayons égale à la distance entre le joueur et la position du point d'ancrage de la corde.
- Si raycast entre en collision avec quelque chose, le collisionneur de cet objet est converti en toute sécurité au type PolygonCollider2D . Bien qu'il s'agisse d'un vrai PolygonCollider2D, la position de sommet la plus proche de ce collisionneur est retournée en utilisant la méthode que nous avons écrite plus tôt sous le nom de Vector2 .
- Il est vérifié par
wrapPointsLookup pour s'assurer que la même position n'est pas vérifiée à nouveau. Si elle est cochée, nous jetons la corde et la coupons, laissant tomber le joueur. - Ensuite, la liste des positions de corde est
ropePositions : la position est ajoutée autour de laquelle la corde doit s'enrouler. Le dictionnaire wrapPointsLookup est également mis à jour. Enfin, l'indicateur distanceSet est réinitialisé afin que la méthode UpdateRopePositions() puisse redéfinir la distance de la corde avec la nouvelle longueur de la corde et des segments.
Dans
ResetRope() ajoutez la ligne suivante afin que le dictionnaire
wrapPointsLookup effacé à chaque fois qu'un joueur déconnecte une corde:
wrapPointsLookup.Clear();
Enregistrez et lancez le jeu. Tirez sur le crochet du chat dans la pierre au-dessus de la limace et utilisez l'outil Déplacer dans la fenêtre Scène pour déplacer la limace sur plusieurs rebords de pierre.
C'est ainsi que nous avons appris à la corde à enrouler des objets!
Ajouter une capacité de basculement
La limace suspendue à la corde est assez statique. Pour résoudre ce problème, nous pouvons ajouter une capacité de swing.
Pour ce faire, nous devons obtenir une position perpendiculaire à la position de basculement vers l'avant (latéralement), quel que soit l'angle sous lequel il regarde.
Ouvrez
PlayerMovement.cs et ajoutez les deux variables publiques suivantes en haut du script:
public Vector2 ropeHook; public float swingForce = 4f;
La variable
ropeHook verra attribuer n'importe quelle position dans laquelle le crochet de corde est actuellement situé, et
swingForce est la valeur que nous utilisons pour ajouter le mouvement de swing.
Remplacez la méthode
FixedUpdate() nouvelle:
void FixedUpdate() { if (horizontalInput < 0f || horizontalInput > 0f) { animator.SetFloat("Speed", Mathf.Abs(horizontalInput)); playerSprite.flipX = horizontalInput < 0f; if (isSwinging) { animator.SetBool("IsSwinging", true);
Les principaux changements ici sont que le drapeau est vérifié en premier isSwingingafin que les actions ne soient effectuées que lorsque la limace est suspendue à la corde, et nous ajoutons également une perpendiculaire au coin de la limace, indiquant son point d'ancrage actuel en haut de la corde, mais perpendiculaire à la direction de son swing.- Nous obtenons le vecteur de direction normalisé du joueur au point d'attache du crochet.
- Selon que le slug oscille à gauche ou à droite, la direction perpendiculaire est calculée à l'aide de
playerToHookDirection. Un appel de débogage a également été ajouté afin que vous puissiez le voir dans l'éditeur si vous le souhaitez.
Ouvrez RopeSystem.cs et ajoutez ce qui suit en haut du bloc else à l'intérieur de la if(!ropeAttached)méthode Update(): playerMovement.isSwinging = true; playerMovement.ropeHook = ropePositions.Last();
Dans le bloc if de même conception, if(!ropeAttached)ajoutez ce qui suit: playerMovement.isSwinging = false;
Nous informons donc le script PlayerMovement que le joueur se balance, et déterminons également la dernière position (à l'exception de la position du joueur) de la corde - en d'autres termes, le point d'ancrage de la corde. Ceci est nécessaire pour calculer l'angle perpendiculaire que nous venons d'ajouter au script PlayerMovement.Voici à quoi cela ressemble si vous activez les gadgets dans un jeu de course et appuyez sur A ou D pour vous déplacer vers la gauche / droite:Ajout d'une descente sur corde
Bien que nous n'ayons pas la possibilité de monter et descendre la corde. Bien que dans la vraie vie, la limace ne puisse pas facilement monter et descendre le long de la corde, mais c'est un jeu dans lequel tout peut arriver, non?En haut du script RopeSystem, ajoutez deux nouvelles variables de champ: public float climbSpeed = 3f; private bool isColliding;
climbSpeeddéfinira la vitesse à laquelle la balle peut se déplacer de haut en bas sur la corde et isCollidingsera utilisée comme indicateur pour déterminer si la propriété de joint de distance de la corde de joint de distance peut être augmentée ou diminuée.Ajoutez cette nouvelle méthode: private void HandleRopeLength() {
Ce bloc if..elseiflit l'entrée le long de l'axe vertical (haut / bas ou W / S sur le clavier) et, en tenant compte des drapeaux, ropeAttached iscCollidingaugmente ou diminue la distance ropeJoint, créant l'effet d'allonger ou de raccourcir la corde.Nous accrochons cette méthode, en ajoutant son appel à la fin Update(): HandleRopeLength();
Nous avons également besoin d'un moyen de mettre le drapeau isColliding.Ajoutez les deux méthodes suivantes au bas du script: void OnTriggerStay2D(Collider2D colliderStay) { isColliding = true; } private void OnTriggerExit2D(Collider2D colliderOnExit) { isColliding = false; }
Ces deux méthodes sont des méthodes natives de la classe de base des scripts MonoBehaviour.Si le collisionneur touche actuellement un autre objet physique dans le jeu, la méthode se déclenchera constamment OnTriggerStay2D, en attribuant une isCollidingvaleur au drapeau true. Cela signifie que lorsque la limace touche la pierre, le drapeau isColliding se voit attribuer une valeur true.La méthode est OnTriggerExit2Ddéclenchée lorsqu'un collisionneur quitte la zone d'un autre collisionneur, définissant le drapeau sur faux.Gardez à l'esprit: la méthode OnTriggerStay2Dpeut être très coûteuse en calcul, alors utilisez-la avec précaution.Où aller ensuite?
Redémarrez le jeu et cette fois, appuyez sur les touches fléchées ou W / S pour monter et descendre la corde.Le projet terminé de cette partie du tutoriel peut être téléchargé ici .Nous avons parcouru un long chemin - de la limace-limace non balancée au mollusque acrobatique sans coquille de gastéropode!Vous avez appris à créer un système de visée qui peut tirer un hameçon sur n'importe quel objet qui a un collisionneur, s'y accrocher et se balancer simultanément dessus, se retournant sur une corde dynamique autour des bords des objets! Excellent travail.Cependant, une fonction importante manque ici - la corde ne peut pas se "dérouler" si nécessaire.Dans la deuxième partie du tutoriel, nous allons résoudre ce problème.Mais si vous êtes prêt à tenter votre chance, pourquoi ne pas essayer de le faire vous-même? Vous pouvez utiliser un dictionnaire pour cela wrapPointsLookup.