Logic Bricks sont le système de script visuel de Cave.

Ils vous permettent de créer un comportement de jeu en connectant des nœuds plutôt qu'en écrivant du code Python directement.

Cette leçon introduit ce que sont les Logic Bricks, où ils se trouvent, comment ils fonctionnent et quand vous devriez les utiliser. Vous apprendrez le système complet dans des leçons plus approfondies plus tard, mais cet aperçu vous aidera à comprendre où les Logic Bricks s'intègrent dans le flux de travail de Cave.

Tutoriel Vidéo

Nous avons un Tutoriel Vidéo complet sur comment commencer avec les Logic Bricks. Nous vous recommandons de le regarder.

Regarder sur YouTube

Cela sera une bien meilleure approche pour les apprendre en profondeur.

Mais si vous voulez continuer ici, faisons une rapide introduction :

Qu'est-ce que les Logic Bricks ?

Logic Bricks sont des graphes logiques visuels qui vous permettent de créer rapidement une logique visuellement, sans écrire de code.

Si vous êtes familier avec d'autres approches de script visuel telles que les Blueprints d'Unreal Engine, chaque brick est essentiellement un nœud. Mais selon les conventions de nommage de Cave, ils sont appelés Bricks. Les Bricks peuvent représenter plusieurs types de logique :

• Événements.
• Actions.
• Valeurs.
• Mathématiques.
• Chaînes.
• Utilitaires moteur.
• Opérations sur les entités.
• Opérations sur les composants.
• Références d'actifs.
• Fonctions.

Vous construisez le comportement en connectant les bricks ensemble.

Si vous êtes nouveau en programmation, les Logic Bricks peuvent être un moyen convivial de commencer à créer des interactions car vous pouvez voir le comportement sous forme de graphe.

Par exemple, un graphe simple pourrait signifier :

Quand le joueur touche ce déclencheur:
  Ouvrir une porte.
  Jouer un son.
  Désactiver le déclencheur.

Ce type d'interaction est souvent plus facile à comprendre visuellement qu'en tant que long script lorsque vous apprenez encore.

Ce n'est pas le cours complet sur les Logic Bricks

Cette leçon est seulement un aperçu.

Les Logic Bricks peuvent aller beaucoup plus loin que cela :

• Fonctions.
• Contrôle de flux.
• Prises de valeur.
• Débogage en temps réel.
• Commentaires.
• Bricks de gestion d'actifs.
• Graphes réutilisables.
• Intégration de la machine à états.

Ces sujets méritent des leçons plus ciblées plus tard.

Pour l'instant, l'objectif est de comprendre le rôle des Logic Bricks : ils sont une manière visuelle de construire un comportement, de connecter des systèmes, de prototyper des interactions et de faire réagir des objets de jeu aux événements.

Si vous voulez un tutoriel complet sur les Logic Bricks, veuillez le regarder ici.

Actifs Logic Bricks

Un graphe de Logic Bricks est un actif. Vous le créez dans le Navigateur d'Actifs, tout comme vous créez des scènes, des scripts Python, des timelines, des matériaux ou des modèles d'entités.

Parce que c'est un actif, il peut être :

• Nommé.
• Organisé dans des dossiers.
• Sélectionné dans le Navigateur d'Actifs.
• Édité dans l'onglet Propriétés.
• Réutilisé par plusieurs entités.
• Enregistré avec le projet.

C'est important : le graphe lui-même est du contenu de projet.

Par exemple, vous pourriez créer un actif Logique de Porte et l'utiliser sur plusieurs portes. Plus tard, si vous améliorez le graphe, ces portes peuvent partager le comportement mis à jour en fonction de la façon dont vous structurez la configuration réutilisable.

Composant Logic Bricks

Pour exécuter un actif Logic Bricks dans le jeu, attachez-le à une entité avec un Composant Logic Bricks.

Le composant choisit quel actif Logic Bricks il doit utiliser. Au moment de l'exécution, le composant crée une instance d'exécution du graphe pour son entité propriétaire.

Cela signifie :

• L'actif définit le comportement partagé.
• Chaque entité obtient sa propre instance d'exécution.
• Le même graphe peut être réutilisé par plusieurs entités.

C'est similaire à la façon dont un script Python réutilisable peut s'exécuter séparément sur de nombreuses entités.

Logic Bricks Réutilisables

Les Logic Bricks sont réutilisables et c'est l'une de leurs plus grandes forces.

Par exemple, vous pourriez créer un actif Logic Bricks appelé Ouvrir la Porte. Ensuite, plusieurs entités de porte pourraient utiliser ce même graphe.

La logique réutilisable fonctionne bien lorsque :

• Beaucoup d'objets partagent le même comportement.
• Chaque objet a besoin de valeurs locales légèrement différentes.
• Vous souhaitez améliorer le comportement à un seul endroit.
• Vous souhaitez que le projet reste organisé.

C'est similaire à la façon dont :

Au lieu de copier le même graphe à plusieurs endroits, vous gardez un actif de comportement et configurez chaque entité selon les besoins.

Propriétés des Logic Bricks

Les Logic Bricks peuvent exposer des propriétés.

Ces propriétés sont synchronisées dans le Composant Logic Bricks, où elles peuvent être remplacées localement.

Par exemple, un graphe de dommage réutilisable pourrait exposer :

• Santé Max.
• Montant de Dommage.
• Temps de Recharge de Dommage.
• Étiquette Cible.
• S'il détruit l'objet après déclenchement.

Alors chaque entité utilisant le graphe peut avoir des valeurs différentes.

Un piège à piques peut infliger peu de dégâts, tandis qu'un volume de lave peut utiliser la même logique avec des dégâts beaucoup plus élevés.

Événements de Flux

La logique commence généralement à partir des événements.

Les événements de flux courants incluent :

Les événements sont les points d'entrée du graphe.

Sans un événement ou un autre déclencheur, le graphe n'a aucune raison de commencer à travailler.

Flux de Logique

Le flux de logique décide ce qui se passe et dans quel ordre. Les sockets de flux connectent les bricks d'événements et d'actions.

Par exemple :

Cela signifie que l'action d'impression se produit lorsque le graphe commence.

La distinction importante pour les débutants est :

Une fois que cela est compris, les Logic Bricks deviennent beaucoup plus faciles à lire.

Les graphes plus complexes peuvent se ramifier, retarder, planifier, appeler des fonctions, lire des valeurs, modifier des entités et communiquer avec des composants.

Débogage en Temps Réel

Les Logic Bricks peuvent afficher des retours utiles en temps réel pendant les tests.

Lorsque l'entité propriétaire est sélectionnée pendant le Mode de Jeu, les bricks et les liens exécutés peuvent être mis en évidence pour que vous puissiez voir ce qui a été exécuté :

Le débogage en temps réel peut aider à répondre à des questions telles que :

• L'événement a-t-il été exécuté ?
• La condition a-t-elle été remplie ?
• L'action a-t-elle été exécutée ?
• Le graphe a-t-il atteint le bon objet ?
• Une erreur a-t-elle été imprimée dans la Console ?

Si une porte ne s'est pas ouverte, ce retour vous aide à inspecter si l'événement de déclenchement a été exécuté, si la condition a été remplie et si l'action a atteint la porte.

Lorsque vous sélectionnez un Logic Brick après avoir testé le jeu, il montre également dans le coin inférieur gauche de l'écran combien de fois il a été exécuté et le temps d'exécution moyen.

Logic Bricks dans les Machines à États

Les Logic Bricks ne sont pas seulement utilisés comme composants autonomes. Ils peuvent aussi être utilisés à l'intérieur des Machines à États.

Par exemple :

• Un état de Machine à États peut utiliser des Logic Bricks pour son comportement.
• Une transition peut utiliser des Logic Bricks pour sa condition.

Les Machines à États sont expliquées plus tard, mais il est utile de savoir que les Logic Bricks peuvent faire partie de systèmes de comportement structurés plus larges.

Cela signifie que vous pouvez utiliser une logique visuelle pour des interactions simples et aussi pour des comportements organisés comme les états des ennemis.

Quand Utiliser des Logic Bricks

Les Logic Bricks sont un bon choix pour :

• Les débutants apprenant la logique de gameplay.
• Les concepteurs qui préfèrent la logique visuelle.
• Les prototypes rapides.
• Les interactions simples.
• Les déclencheurs.
• Le comportement UI.
• Les événements de gameplay réutilisables.
• Connecter des systèmes ensemble.

De bons exemples pour les débutants incluent :

• Une plaque de pression ouvrant une porte.
• Un ramassage augmentant la santé.
• Un déclencheur démarrant une Timeline.
• Un bouton UI changeant de scènes.
• Un danger infligeant des dégâts au joueur.
• Un point de contrôle sauvegardant une position.

Pour les systèmes très grands ou complexes, Python peut être plus facile à organiser. Pour de nombreuses interactions de gameplay, les Logic Bricks sont rapides, visuels et faciles à inspecter.

Une Règle Simple

Le script visuel du moteur Cave a une parité un à un avec l'API Python, ce qui signifie que chaque fonction disponible par le code devrait également être disponible par les Logic Bricks. Cela signifie que vous pouvez librement choisir lequel vous préférez pour créer la logique de votre jeu. Cela signifie :

• Utilisez les Logic Bricks lorsque vous voulez voir le comportement comme un graphe.
• Utilisez Python lorsque le comportement est plus facile à exprimer sous forme de code.
• Vous pouvez aussi combiner les deux !

Les deux approches font partie de Cave, et de nombreux projets utilisent une logique visuelle pour certains systèmes et Python pour d'autres.