Bolt Visual Scripting in Unity

Let's create our first visual script!  Here we create a Flow Machine component on our Unity GameObject.  Then, we can create a Flow Graph stored as a Macro in our project.

In order to add some more interesting logic to our Flow Graph, we add a Graph Variable to store and reuse data.

Variables can take different forms.  In this episode, we add an Object Variable, allowing data to be shared amongst more than one Flow Machine/Flow Graph.

As our graphs become more complex, we can encapsulate portions of the logic into a SuperUnit.  SuperUnits are reusable Flow Graph snippets that help keep your main graph easy-to-read and organized.

In this episode, we complete our CameraController graph.  Then we add a Null Check that can prevent some common errors that you may encounter at runtime.

In this episode, we add mouse input to control the camera rotation.

In this episode, we'll examine a few tips and tricks to help you troubleshoot your graphs.  We use visual aids like Align and Distribute to improve the graph legibility and check our dependencies using the Relations toggle.  Then we squelch a potential error using the Debug and Once units.

In our exercise, we add extra variables to toggle whether to invert the Pan and/or Tilt direction.  Then we add a Sequence node to help us reorganize the Flow Graph.

In this episode, we discuss the differences between Flow Graphs saved as Macros in the project versus those stored internally in the Flow Machine as Embeds.

In this challenge, you will build a slightly more complex graph designed to move the main camera.

In this episode, we show you one solution to the CameraMover graph.

In this episode, we show a slightly more condensed solution to the CameraMover graph.

In this section, we will build an intermediate-level graph describing a first-person movement controller. Get ready to flex your Bolt skills!

In this episode, we set up some components to make a first-person controller: a physics Rigidbody and Capsule Collider with the main camera as a child.  Then we create an FPSPlayerMovement graph to rotate the Player's Heading (y-rotation).

In this episode, we re-create portions of the MouseLook challenge for the FPS PlayerMovement to control the Camera Tilt (x-rotation).  We use a different set of Units so that we can limit the range of valid Euler angles.

In this episode, we add a quick toggle for the Mouse Cursor so that it's locked and invisible at runtime.

In this episode, we connect the keyboard (ASDW) input to the Rigidbody in order to translate the Player.

In this episode, we import a Graybox Level to test our FPS Player Movement graph.

In this episode, we add the ability for the Player to jump.

In this Challenge, you will add an extra modifier key to increase the player's movement speed. 

In this episode, we set up the Player's ability to run using the Shift keys as a modifier.

In this episode, we set up the crosshairs for the player's heads-up display. 

Here we add a PlayerHUD graph to handle some logic.  This is also a good time to introduce Custom Events in order for Bolt components to communicate.  We invoke a Custom Event Trigger in the FPSPlayerMovement to send the event to the PlayerHUD.

Here we create the listener/observer logic in the PlayerHUD to receive the Custom Event created in Part 1.

In this episode, we create a Hitscan weapon, using ray casting to determine the point of contact of our weapon projectiles.

In this episode, we replace the red stand-in HitSpheres with particle effects. 

In this episode, we add another particle system to help us aim.  The setup differs from the HitEffect, so we modify the PlayerWeapon graph to accommodate both effects.

In this episode, we create some targets to shoot and build a Health Flow Graph to track damage.

In this episode, we create a simple GameManager using a State Machine, a different type of Bolt graph.  State Machines controls a network of Flow States to describe something's current condition.  For the GameManager, we'll use State Graphs to switch between the Game Start, Game Play, and Game Over states.

In this episode, we add some introductory graphics before gameplay begins.  The StartScreen graph uses Custom Events from the GameManager to set up logic in a separate Macro.

In this episode, we create a GameEvents SuperUnit to make it easier for other GameObjects to listen for the main game loop's Custom Events.  Then, we use that SuperUnit to set up an EndScreen flow graph to show a Game Over screen.

In this episode, we set up a ScoreManager graph and object.  This assists the GameManager in tracking how many targets the player destroys. 

Just an update about updates...

Here are some resources to help you get started using Unity as a complete novice.  Don't worry!  Game dev is a lot of fun.