Cave : Guide pour débutants

Cave est conçu pour être simple à apprendre, mais il a tout de même quelques concepts importants que vous devez comprendre.

Cette leçon explique les termes clés que vous trouverez partout dans l'éditeur : scène, entité, composant, actif, modèle d'entité, transformation, corps rigide, composant de caractère, composant Python, brique logique, chronologie, et temps d'exécution.

Ceci est une vue d'ensemble générale, et cela ne détaille pas chaque mot, mais il est important de commencer à améliorer votre compréhension du moteur. Une fois que ces mots ont du sens, le reste du moteur devient beaucoup plus facile à lire.

La Vue d'Ensemble

La plupart des projets Cave sont construits à partir de quelques idées répétées :

Par exemple, imaginez une caisse en bois dans un niveau :

• Le niveau est une Scène.
• La caisse placée dans le niveau est une Entité.
• La position de la caisse est stockée dans sa Transformation.
• Le modèle visible est géré par un Composant de Maillage.
• La collision peut être gérée par un Composant de Corps Rigide.
• Le modèle, le matériau et la texture utilisés par la caisse sont des Actifs.

Si vous souhaitez réutiliser cette configuration de caisse dans de nombreuses scènes, vous pouvez l'enregistrer comme un Modèle d'Entité.

Scène

Une scène est une collection d'entités.

Les scènes peuvent être utilisées pour :

• Niveaux de jeu.
• Menus.
• Cartes de test.
• Chambres de prototypes.
• Espaces de cinématiques.

Seule la scène active est modifiée dans la vue 3D principale. Lorsque vous testez le jeu, Cave exécute la scène comme gameplay au lieu de juste le contenu de l'éditeur.

Lors de l'exportation ou du test du projet en tant que temps d'exécution, les paramètres du projet décident de la scène à utiliser comme scène de démarrage. Vous pouvez modifier cela en allant dans l'Onglet Paramètres.

Entité

Une entité est un objet dans une scène.

Les entités peuvent être visibles ou invisibles. Elles peuvent être simples ou complexes.

Exemples d'entités :

• Un personnage joueur.
• Une porte.
• Une caméra.
• Une lumière.
• Un déclencheur.
• Un bouton UI.
• Un point d'apparition.
• Un dossier utilisé pour l'organisation.

Une entité par elle-même est surtout un conteneur. Ce qu'elle peut réellement faire dépend des composants qui lui sont attachés.

Composant

Un composant ajoute un comportement ou des données à une entité.

Au lieu d'avoir un énorme type d'objet pour chaque chose possible, Cave vous permet de construire des entités en combinant des composants. Et c'est exactement comme cela que vous êtes censé construire les différents éléments de votre jeu, en compositant les entités avec plusieurs types de composants différents.

Par exemple :

C'est l'une des idées les plus importantes dans Cave : Les entités sont des conteneurs. Les composants leur donnent des fonctionnalités.

Il est aussi important de mentionner ici qu'une autre façon de composer vos différents types d'objets est d'utiliser plusieurs entités dans la hiérarchie d'entités enfants.

Nommage des Entités

Lorsque vous créez une nouvelle entité, Cave propose différents types de départ, tels que Dossier, Vide, Maillage, Lumière Ponctuelle, Caméra, Élément UI, Texte, et Bouton.

Ce ne sont pas des mondes complètement séparés. Ce sont des points de départ pratiques.

Par exemple :

• Un Vide est une entité de base avec une transformation.
• Une entité Maillage est une entité préparée pour afficher un maillage.
• Une entité Lumière Ponctuelle est une entité prête à se comporter comme une lumière.
• Une entité Caméra est une entité préparée pour rendre une vue.
• Un Dossier est une entité principalement utilisée pour l'organisation.

Vous pouvez généralement ajouter, supprimer ou modifier des composants plus tard, donc le type de départ n'est qu'un raccourci utile.

Transformation

La transformation indique à Cave où se trouve une entité et comment elle est orientée.

Elle inclut :

• Position.
• Rotation.
• Échelle.

Quasi chaque entité de scène a une transformation car la plupart des objets doivent exister quelque part dans le monde. Lorsque vous déplacez, faites pivoter ou mettez à l'échelle une entité avec le gizmo, vous modifiez sa transformation. Lorsqu'une entité est parentée à une autre entité, sa transformation est évaluée par rapport à cette hiérarchie.

Actif

Un actif est un contenu réutilisable du projet stocké dans le Navigateur des Actifs. Il est important de mentionner que bien qu'une Entité soit considérée comme un Actif en interne, un Actif n'est pas la même chose qu'une Entité.

Par exemple :

• Un actif de maillage est les données du modèle. Une entité de maillage est un objet placé dans la scène qui utilise cet actif de maillage.
• Un actif de matériau définit comment une surface apparaît. Une entité de maillage peut référencer ce matériau.
• Un actif de script Python contient du code. Un composant Python peut utiliser ce script.

Cette séparation est puissante car un actif peut être réutilisé de nombreuses fois. Si dix caisses utilisent le même matériau, modifier l'actif de matériau peut les mettre à jour toutes.

Modèle d'Entité

Un modèle d'entité est une configuration d'entité réutilisable. Consultez la capture d'écran ci-dessous. Les Actifs de Modèle d'Entité sont marqués d'une ligne Verte sous leur miniature :

Si vous venez d'un autre moteur, vous pouvez le penser comme similaire à un prefab.

Un modèle d'entité peut stocker :

• Une hiérarchie d'entité.
• Composants.
• Paramètres de composants.
• Références d'actifs.
• Entités enfants.

Ceci est utile pour tout ce que vous souhaitez réutiliser :

• Ennemis.
• Objets à ramasser.
• Portes.
• Accessoires.
• Véhicules.
• Widgets UI.
• Objets de gameplay.

Au lieu de reconstruire le même objet encore et encore, vous le créez une fois comme un modèle d'entité et placez des instances où cela est nécessaire.

Corps Rigide

Un corps rigide donne un comportement physique à une entité. Il est utilisé lorsque qu'un objet a besoin de collision ou de mouvement physique.

Exemples :

• Une caisse qui bloque le joueur.
• Une balle qui peut rouler.
• Une porte avec collision.
• Un mur que le joueur ne peut pas traverser.

Les corps rigides font partie du côté physique du moteur. Vous les utiliserez lorsque les objets doivent interagir physiquement avec le monde.

Composant de Caractère

Un composant de caractère est utilisé pour le mouvement de style personnage. Ceci est différent d'un corps rigide régulier car un personnage a généralement besoin d'un comportement spécial :

• Marcher.
• Glisser le long des murs.
• Gérer des pentes.
• Sauter.
• Réagir aux entrées du joueur.

Pour un joueur ou un PNJ, un composant de caractère est généralement un meilleur point de départ que d'essayer de faire un objet physique de base se comporter comme un personnage.

Lorsque nous parlons d'un Composant de Caractère dans Cave, nous faisons référence à sa Physique de Caractère, pas à la logique spécifique au jeu (comme le mouvement, etc).

Étiquettes et Propriétés

Les étiquettes et les propriétés vous aident à identifier et configurer des entités.

• Une étiquette est une étiquette qui peut aider les scripts ou la logique à trouver et classer des choses.
• Les propriétés sont des valeurs modifiables exposées à l'éditeur. Elles vous permettent d'ajuster le comportement sans réécrire le code à chaque fois.

Par exemple, un ennemi pourrait avoir des propriétés telles que :

• Vitesse de marche.
• Santé.
• Distance d'attaque.
• Cible de patrouille.

Une bonne utilisation des propriétés rend votre jeu plus facile à régler.

Les propriétés ne sont pas limitées aux Entités : Les Scènes, Briques Logiques et autres Actifs peuvent également en avoir.

Lorsque nous parlons de propriétés dans Cave, nous faisons spécifiquement référence à de telles propriétés qui peuvent être accessibles à l'aide de dictionnaires Python via le code. Elles sont presque toujours disponibles dans l'éditeur également.

Composant Python

Un composant Python permet à une entité d'exécuter de la logique Python.

Cela est utile lorsque vous souhaitez un comportement personnalisé, tel que :

• Ouvrir une porte.
• Déplacer une plateforme.
• Gérer l'entrée du joueur.
• Générer un objet.
• Mettre à jour le texte de l'UI.
• Déclencher des événements.

Les composants Python sont l'un des principaux moyens de programmer le gameplay dans Cave.

Composant de Code Python

Un composant de Code Python est utilisé lorsque le code est stocké directement dans le composant au lieu d'être lié en tant qu'actif de script séparé. Cela peut être utile pour des tests rapides, de petits comportements, ou des prototypes.

Pour des systèmes de gameplay plus grands, un actif de script Python séparé est généralement plus facile à organiser et à réutiliser.

Brique Logique

Les briques logiques sont un moyen visuel de construire de la logique. Elles sont utiles lorsque vous souhaitez un comportement sans écrire directement du code Python.

Si vous connaissez les Blueprints d'Unreal, les briques logiques font partie de la même famille d'idées : vous connectez la logique visuellement au lieu d'écrire tout en texte.

Elles sont particulièrement utiles pour créer tout type de logique que vous souhaitez sans exiger d'écrire du code Python. Par exemple, des événements et logique de gameplay, le comportement des objets, connecter des systèmes ensemble, des déclencheurs, etc.

Vous les apprendrez plus tard dans ce guide.

Chronologie

Une chronologie est un actif utilisé pour des séquences créées. Les chronologies peuvent animer ou déclencher des choses au fil du temps.

Elles sont utiles pour :

• Cinématiques.
• Mouvements de caméra.
• Événements scriptés.
• Séquences de gameplay coordonnées.

Les chronologies ne sont pas requises pour chaque jeu, mais elles sont utiles lorsque vous souhaitez que quelque chose se produise dans un ordre spécifique créé.

Important : Les chronologies ne sont pas des moyens pour l'édition d'animation individuelle, comme par exemple l'édition d'une animation de Cycle de Marche pour votre personnage. Dans ce cas, vous devez utiliser un logiciel DCC spécialisé, tel que Blender, puis l'importer dans Cave.

Joueur et Temps d'Exécution du Jeu

• L'Éditeur Cave est où vous construisez le projet.
• Le Lecteur Cave est le temps d'exécution qui exécute le jeu.

Lorsque vous appuyez sur Play dans l'éditeur, Cave exécute votre scène dans un mode semblable à un jeu à l'intérieur de l'éditeur. Lorsque vous testez en tant que temps d'exécution autonome, Cave lance le jeu dans une fenêtre de lecteur séparée.

Le jeu exporté final fonctionne comme une build de joueur/runtime, et non comme l'éditeur. Cette séparation est importante car certaines choses sont réservées à l'éditeur (pour que vous puissiez déboguer et/ou développer votre projet), tandis que d'autres font partie du jeu réel.

La Relation la Plus Importante

Si vous ne vous souvenez que d'une chose de cette leçon, souvenez-vous de ceci :

Une scène contient des entités, les entités contiennent des composants, et les composants utilisent souvent des assets.

C'est la colonne vertébrale d'un projet Cave.