It's now time for us to begin work on the character controller that we'll be creating. This video introduces and summarizes the lessons found in this section.
For those who have not yet seen it, this video gives a quick rundown of the level we'll be using. Please note that if you followed along with the first section, over this level's creation, you may want to skip this one!
As we do not yet have a character for use, we take a moment in this video to create a very simple temporary stand-in that we can use for the lessons.
This video provides a high-level overview of the camera system itself, helping you to see what we have in store and how we'll be approaching development.
The first class we're going to be creating is named TP_Controller. In this video, we give the underlying theory of how this class will be created.
Our first step in the coding proecss for TP_Controller is to create the method skeleton, which is what we cover in this video.
The next class we'll be creating is the TP_Motor class. In this video we discuss the primary theory behind what it does and how it works.
In this video we code out the method skeleton for the TP_Motor class.
With the method skeleton in place, we take this video to fully implement TP_Motor's functionality.
Now that the TP_Motor class is pretty much wrapped, we can finally implement the functionality of the TP_Controller class.
With these basic classes now in place, we can get the initial wiring onto our character and test out the initial motion.
Now that our character is working, we now need to start looking at the camera. This video provides a high-level overview of how the camera system should work.
We begin by taking care of our secondary functionality, which we overview in this video. From here, we will
Now that the theory of the secondary funcationlity is behind us, we go about getting it implemented into our camera system.
Our secondary features are in place, but now we need to look at the primary camera behavior, which we summarize in this video.
It's time to implement the primary behavior of our camera. In this video we take care of the C# scripts to make that happen.
Our camera system needs to know what to do about player inputs. In this video we cover the theory behind the method that will handle this.
In this video we implement the functionality for the HandlePlayerInput method.
As our camera zooms in and out, we need to be able to calculate the desired position of where it will end up, which is handled by this method.
We have now discussed what the CalculateDesiredPosition method does, and now we simply need to code in its implementation.
Our system can now determine where it needs to place the camera. We now need a way to update that position.
As before, our theory is out of the way and we can now focus on implementing the code.
Our basic camera system is now in place and ready to test. In this video we check and make sure everything is working properly, and then wrap up and prepare to move on.