Welcome to Application Systems Programming, the second course in the Unity Certified Programmer Specialization from Unity Technologies. This course will help you prepare for the Unity Certified Programmer exam, the professional certification for entry to mid-level Unity programmers. Unity is used to create real-time 3D applications for many industries, including video games, automotive, film, training, and more. In this course, you will be challenged to solve realistic Unity programming problems that are aligned to topics covered on the exam. Throughout the second course, you will expand upon the development of a 2D action video game that was started in the first course: AsteraX. In doing so, you will practice many of the skills covered in the exam, including adding particles effects, implementing user customizations, managing user and application data, and optimizing for different platforms. This is an intermediate course, intended for people who are ready for their first paying roles as Unity programmers, or enthusiasts who would like to verify their skills against a professional standard. To succeed, you should have at least 1-2 years of experience programming interactive applications in Unity. You should be proficient at programming in the C# language and familiar with Unity's scripting APIs. You should have experience in the full product development lifecycle, from concept to launch (and beyond). And you should understand multi-platform development, including deploying applications to XR (AR and VR) platforms.
Solution 2C |Bonus Challenge | Animated LevelAdvancePanel
Loading...
En provenance du cours de Unity
Application Systems Programming
notes
À partir de la leçon
User Progress and Reward Systems
In the following two lessons, you'll continue to add important application systems to the game. First, you'll implement multiple level support with progressively increasing difficulty, as well as the ability for the user to pause the game. Then you'll create a popular type of user reward system: a set of achievements that the player can earn for reaching defined milestones.
Rencontrer les enseignants
Jeremy Gibson Bond
Unity Technologies
Hi, everyone. I'm Jeremy Gibson Bond,
and welcome back to the Unity Certified Programmer Exam Preparation course.
In this video, we're going to be looking at
the solution to the Bonus Challenge you had of
animating that level advanced panel that transitions between levels and Asterax.
Let's take a look at what we're talking about.
Here I'm going to click Start,
and you'll see that the level text fades in,
then the info text fades in.
It fades out and level text fades out,
and we've got that nice bounce to the level text as well.
Let's take a look at how that works.
Here in the level advanced panel script,
you'll see there are lots of different states set up in the enum E-level advanced state.
So, each of these different states is set in here.
I have a set state machine.
However, you could, if you wanted to spend
a lot more time on this and make it more flexible,
so you could use it across multiple games, for instance.
You could create, say,
a class that stored information about what you wanted to
transition and how you wanted to transition it,
and stored information about what step to go to next,
or maybe you could store them in a list.
There's lots of different ways that you could do this.
You'll notice as well, these two values: fade time and display time,
which both default to one second.
Back in Unity, we actually still have them set to one second as well.
What this means is that,
it will take a full second for all the fade-in aspects to happen.
That's the text fading in and popping in,
and the background fading in, and all that stuff.
Then, it will display for a second,
and then it will take a full second for everything to
fade back out with the various animations that we have.
So, the top of the awake method,
we first set the private singleton S,
then we get the image component that we know is there because we required it,
and then we go through and grab components out of
the different sub-game objects or child game objects under this panel.
This includes the text that says level which is the level text.
It includes the info text.
It includes a transform on the level text,
and it includes the image that's the background or the frame around the info text.
As you can see later in the same method,
for each of these,
we double check to make sure that they exist,
and we log a warning if they do not.
Then, the final thing that we do as we call SetState with the idle state,
so we're moving from the non-state to the idle state,
which just gets this ready to accept new transition calls.
Here in SetState, the first thing we do is,
we set the start time of this state to real-time.
Now, real-time is a property that I created,
and all that it does is it gives us time.realtimeSinceStartup.
Honestly, the only reason I made this it was because
time.realtimeSinceStartup is really long
and it was forcing a lot of lines to go off screen
which was bad for me showing to you in this video.
So, I made a shorter version as a property,
you really don't need to do this yourselves.
Back in SetState, when we set the state to be idle,
the first thing we do is,
we make the game object inactive.
This makes the entire level advance panel invisible,
and it stops it from receiving updates,
fixed updates and other things like that.
The next thing that happens is,
we call the idle callback delegate.
There are two delegates on this.
One delegate is called whenever we reach, the display state.
So, whenever the fading is done and it's going to show a static screen for a second.
This is called because that is
exactly the right time for Asterax to create all those new asteroids and
all these other things that could cause a little glitch
in our frame rate if it was happening while we were doing the transition.
So, you do the cool-looking transition,
then when it's just showing a static screen,
we do things that might mess up the frame rate because no one will tell,
because it's a static screen,
and then we fade back out and the level is ready to go.
Now, the idle callback is called when we're done with the whole transition.
So, we transition, we fade in,
we display it for a second, we fade out,
and then the level events panel goes back to its idle state,
at which point, it calls the idle callback.
You'll note that idle callback is called once, and then nullified.
So, we're ready to start
the next level that gets sent back to Asterax and tells it to start the level,
and then we nullify it, so that we don't accidentally call that again.
Now, it should be pointed out here that delegates are multi-casting,
so that means you could register multiple methods to be called as part of that delegate,
and they all would get cleared when we set idle call back to null.
Down at the bottom of the level advance panel script is advanced level,
which is a static method that is called by
Asterax whenever it wants to advance the level.
There are two things that are passed in,
which are those two callbacks,
the display callback and idle callback that I mentioned before.
These two callback methods get assigned to the two different delegates,
and then we set the state to fade in.
Here we are in the set state method where we're setting the state to fade in.
The first thing we do is set the game object active.
Making it appear again,
making it receive updates, those kinds of things.
Then, we set the level text.
So, the level text needs to say something like level two,
and the info text needs to say the number of initial asteroids
and the number of sub asteroids or children for each one of those asteroids.
Next, we set the initial state of all
of these different components that we have access to.
So, we clear the color of the background,
the info text, and the info frame,
and we set the scale of the level rect transform for
the level text to be zero in
the y dimension making it invisible because it's completely flat.
Next up, we set the state duration to 0.2 times the fade time.
So, the total fade time is one,
meaning that 0.2 times one is 0.2, of course,
but we're making this 20 percent of our total fade time.
So, rather than set each individual thing in the inspector,
we just set the total time we want it to take,
and we're going to have the first part take two-tenths of that time,
the middle part takes six tenths,
and the final part take two tenths,
adding up to a total of one second.
The next state is set to fade in two.
So, whenever we're done with this 0.2 seconds,
we'll automatically advanced to fade in two.
Let's look at the update where that happens.
Here in update on line 195,
we set U which is that linear interpolation value.
It's sort of a standard name for the linear interpolation value to the amount of
time that has passed since our start time divided by the duration that we want.
So, if say a tenth of a second has passed and our state duration is 0.2,
then our U value is going to be 0.5 or one half.
If the U value exceeds one,
then we know that it's time to move on to the next state.
So, we set moveNext to true,
and we also set the U value back to one to
avoid any extrapolation that we don't want to experience.
You'll note as well that on line 202,
u1 is set to the value of one minus U.
One minus u is used a lot in linear interpolation and so I
just simplify it into u1 so it doesn't have to calculate it over and over again.
Slightly further down, you can see that in the fade-in state,
all we do is set the background color to fade in in opacity.
So, the U is applied to the alpha value of the color for the background color.
At the bottom of the update method,
if moveNext is true we set state to
the next state which in this case will be fade in two.
Here in fade in two,
we set the initial state of everything.
We set the color of the background to black.
We set the local scale of the level rect transform to 101,
and we clear the info text in the info frame color.
Now, this is kind of redundant.
We just did this in the fade in set state.
But, the reason we're doing it again is because, if somehow,
something happens and we get asked to jump into
a state without the previous state having taken place,
we want to make sure that we reset everything to
where we need it to be for the beginning of this state.
So, it is slightly redundant,
but it's a security measure to keep us from screwing up in some other way.
We set the fade-in time 2.6 or six tenths of a second,
and we set the nextState to fade in three.
Similarly, you can see in fade in three that we set
the initial state of everything to be where it will be at the end of fade in two,
and we set the fade time 0.2,
which is the remainder of that initial fall second time,
and then we set the nextState to display.
When we enter the display state,
that's when we go ahead and send that display callback that we talked about,
and then we wait a second,
and we go into the three fade out states,
where we reverse everything we did for the fade-in states.
Now, down an update for each of those,
you can see that fade in three is just a color transition like we've done before.
Display doesn't do anything,
it just waits around.
But here in fade in two, there's something interesting,
and that's what causes the y-value to do this for the level text.
So, let's take a look at this level text y scale effect.
Here you can see that that scale effect takes the U value which ranges from zero to one.
It multiplies it by pi,
and then takes the sign of that.
So, the sign of pi is going to go up and down,
over the course of from zero to pi which is our zero to one multiplied by pi zero to pi.
So, that gives us this,
and then we add U which runs from zero to one like this.
So, when you add this to this,
you get this bounce,
which is exactly what we wanted for that y-scaling.
I have found that I use sine and cosine a lot when dealing
with linear interpolations that I want to
bounce and move and have some easing and things like that.
This is because sine and cosine can convert any number
into something that moves in a smooth way from zero to one,
or one to zero,
or has some bounce to it.
So, I encourage you to play around with that
if you ever want to add some character to your transitions,
like the character that we added to this level text transition.
There's not much left to say about this except you can
see when we set state to fade out three,
the next state is the idle state,
and then that jumps us back to the top and fires off that idle callback.
So, that's it for the solution to your Bonus Challenge here.
I hope you enjoyed it, and I will see you in the next video.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
