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

Ils vous permettent de créer des comportements de jeu en connectant des nœuds au lieu d'écrire directement du code Python.

Cette leçon présente 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 cette vue d'ensemble vous aidera à comprendre où les Logic Bricks s'insèrent dans le workflow de Cave.

Tutoriel Vidéo

Nous avons un Tutoriel Vidéo complet sur la façon de commencer avec les Logic Bricks. Nous vous recommandons de le visionner.

Regarder sur YouTube

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

Mais si vous voulez continuer ici, faisons une brève introduction :

Que sont les Logic Bricks ?

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

Si vous connaissez d'autres approches de script visuel telles que les Blueprints d'Unreal Engine, chaque brick est essentiellement un nœud. Mais selon la convention de nommage de Cave, ils s'appellent des Bricks. Les Bricks peuvent représenter de nombreux types de logique :

• Événements.
• Actions.
• Valeurs.
• Mathématiques.
• Chaînes de caractères.
• Utilitaires du moteur.
• Opérations sur les Entity.
• Opérations sur les Component.
• Références d'Asset.
• Fonctions.

Vous construisez un comportement en connectant les bricks entre eux.

Si vous débutez en programmation, les Logic Bricks peuvent être une façon amicale 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 genre d'interaction est souvent plus facile à comprendre visuellement qu'en tant que long script quand vous apprenez encore.

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

Cette leçon est seulement une vue d'ensemble.

Les Logic Bricks peuvent aller beaucoup plus loin :

• Fonctions.
• Contrôle de flux.
• Sockets de valeurs.
• Débogage à l'exécution.
• Commentaires.
• Bricks gestionnaires d'Asset.
• Graphes réutilisables.
• Intégration avec State Machine.

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

Pour l'instant, l'objectif est de comprendre le rôle des Logic Bricks : ils sont un moyen visuel de construire des comportements, connecter des systèmes, prototyper des interactions et faire répondre les objets de jeu aux événements.

Si vous souhaitez un tutoriel complet sur les Logic Bricks, veuillez regarder ceci.

Assets Logic Bricks

Un graphe Logic Bricks est un asset. Vous le créez dans l'Asset Browser, comme vous créez des scènes, scripts Python, timelines, matériaux ou entity templates.

Parce qu'il est un asset, il peut être :

• Nommé.
• Organisé en dossiers.
• Sélectionné dans l'Asset Browser.
• Édité dans l'onglet Properties.
• Réutilisé par plusieurs entities.
• Sauvegardé avec le projet.

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

Par exemple, vous pourriez créer un asset Door Logic et l'utiliser sur plusieurs portes. Plus tard, si vous améliorez le graphe, ces portes peuvent partager le comportement mis à jour selon la façon dont vous structurez la réutilisation.

Logic Bricks Component

Pour exécuter un asset Logic Bricks dans le jeu, attachez-le à une entity avec un Logic Bricks Component.

Le component choisit quel asset Logic Bricks il doit utiliser. À l'exécution, le component crée une instance runtime du graphe pour son entity propriétaire.

Cela signifie :

• L'asset définit le comportement partagé.
• Chaque entity obtient sa propre instance en cours d'exécution.
• Le même graphe peut être utilisé par plusieurs entities.

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

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 asset Logic Bricks appelé Open Door. Plusieurs entities porte pourraient alors utiliser ce même graphe.

La logique réutilisable fonctionne bien quand :

• Plusieurs objets partagent le même comportement.
• Chaque objet nécessite des valeurs locales légèrement différentes.
• Vous voulez améliorer le comportement à un seul endroit.
• Vous voulez que le projet reste organisé.

C'est similaire à :

Au lieu de copier le même graphe à plusieurs endroits, vous conservez un asset de comportement et configurez chaque entity selon ses 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 Logic Bricks Component, où elles peuvent être surchargées localement.

Par exemple, un graphe de dégâts réutilisable pourrait exposer :

• Vie maximale.
• Quantité de dégâts.
• Temps de recharge des dégâts.
• Tag de cible.
• S'il détruit l'objet après déclenchement.

Chaque entity utilisant ce graphe peut ensuite avoir des valeurs différentes.

Un piège à pointes peut infliger peu de dégâts, tandis qu'une zone de lave peut utiliser la même logique avec des dégâts bien plus élevés.

Événements de flux

La logique commence généralement par des événements.

Parmi les événements de flux courants :

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

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

Flux de la logique

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

Par exemple :

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

La distinction importante pour les débutants est :

Une fois que cela est clair, 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 entities et communiquer avec des components.

Débogage à l'exécution

Les Logic Bricks peuvent montrer un retour utile pendant les tests.

Lorsque l'entity propriétaire est sélectionnée en mode Play, les bricks et liens exécutés peuvent être mis en surbrillance pour voir ce qui a été exécuté :

Le débogage à l'exécution peut aider à répondre à des questions comme :

• L'événement s'est-il déclenché ?
• La condition a-t-elle été validée ?
• L'action s'est-elle exécutée ?
• Le graphe a-t-il atteint le bon objet ?
• Une erreur a-t-elle été affichée dans la Console ?

Si une porte ne s'ouvre pas, ce retour aide à inspecter si l'événement déclencheur a fonctionné, si la condition a été validée, et si l'action a atteint la porte.

Lorsque vous sélectionnez un logic brick après avoir testé le jeu, il affiche aussi en bas à gauche de l'écran combien de fois il a été exécuté et le temps moyen d'exécution.

Logic Bricks dans les State Machines

Les Logic Bricks ne sont pas seulement utilisés comme Components autonomes. Ils peuvent aussi s'utiliser dans les State Machines.

Par exemple :

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

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

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

Quand utiliser les Logic Bricks

Les Logic Bricks conviennent bien à :

• Les débutants qui apprennent 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.

Des exemples simples pour débutants incluent :

• Une plaque de pression qui ouvre une porte.
• Un objet ramassable qui augmente la santé.
• Un déclencheur qui lance une Timeline.
• Un bouton UI qui change de scène.
• Un danger qui inflige des dégâts au joueur.
• Un point de sauvegarde qui enregistre une position.

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

Une règle simple

Le script visuel de Cave Engine a une parité un-à-un avec l'API Python, ce qui signifie que chaque fonction disponible par code doit aussi être disponible via les Logic Bricks.

Cela signifie que vous pouvez librement choisir celle que vous préférez pour créer la logique de votre jeu. À savoir :

• Utilisez les Logic Bricks lorsque vous voulez voir le comportement sous forme de graphe.
• Utilisez Python lorsque le comportement s'exprime plus facilement en code.
• Vous pouvez aussi combiner les deux !

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