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 2B | Multiple Levels
Loading...
来自 Unity 的课程
Application Systems Programming
个评分
从本节课中
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.
与讲师见面
Jeremy Gibson Bond
Unity Technologies
[MUSIC]
Everyone, I'm Jeremy Bond and welcome back.
In this video, we're going to take a look at how I implemented the multiple
levels in the AsteraX game.
To start with, let's take a look at the AsteraX script.
You can see here that start with used to actually instantiate asteroids is a much
shorter now.
All it does is pass level progression and
then set the asteroids list to be empty and set the score to be 0.
So let's take a look at this parse level progression.
This pulls in the level progression string and
parses it to generate different levels.
You can see that parse level progression makes many calls to the split method of
strings.
Which takes a string and
splits it based on a certain character into an array of strings.
The first is on the comma which splits in the individual levels.
Then on the column which splits out the level number from the 3/2 for instance.
And then on the slash which gives us the 3 and the 2.
And then we parse each of those, the 3 and the 2 as integers.
If anything doesn't work out in this splitting we get
an error logged to the console.
So once we parse this out, it all goes into a level info struct.
So let's take a look at how that struct works.
So structs are very similar to classes.
Except did a struct is passed by value where classes passed by reference.
So that means if I were have a list of class instances and
I passed around that class instance.
There are really still just be one and
multiple things where reference to the same chunk of data in memory.
A struct on the other hand, any time I pass it to something else,
it makes a copy of it.
You've experienced this behavior with vector3s in Unity.
That's a very common thing that is passed by value instead of passed by reference.
So our LevelInfo is passed by value, it is a struct.
And as a struct, we have a constructor, which is the public LevelInfo on line 516.
And we passed in the level number, the name of the level,
the initial number of asteroids, which is the number of parent asteroids, and
then the number of sub asteroids per level.
So again on level 1, that starts out as three with three parent asteroids and
two sub-asteroids which means each parent asteroid will have two size two asteroids.
And each size two asteroid will have two size one asteroids attached to it.
So now that that's all set up with all the levels.
How do we start the game?
Well on the title screen panel, there is a button here that says Start on it.
And you click the button, and the button calls TitleScreenPanel.StartGame.
So let's track that down.
Start game calls AsteraX.StartGame.
AsteraX.StartGame is a static method which means it would be difficult for
us to call it from the button in the Unity inspector.
Which is why they added this title screen handled StartGame method to then call
the static method on AsteraX.
Let's track that method down.
Here, the StartGame method sets the GAME_LEVEL to 0,
which you can see just above it, is an automatic property.
So it's a static automatic property, it has a getter that is public and
a private setter.
So only AsteraX can set the GAME_LEVEL, but
everything else can get the GAME_LEVEL.
Then on the second line, of the StartGame method,
we call _S.EndLevel which calls EndLevel on the singleton instance of AsteraX.
Let's take a look at that.
Now this is a common thing that I do.
By calling EndLevels to start the game with GAME_LEVEL 0.
Then the GAME_LEVEL will increment on line 186 here to GAME_LEVEL 1.
And then go through the same process that happens whenever I end a regular level.
This means I don't have to have a special case for the beginning of the game.
I just have a kind of nonexistent level 0, which then ends and
allows level 1 to start.
So here you can see that if the GAME_STATE is not GAME_STATE none, and
the GAME_STATE is only set to GAME_STATE none, when the game ends.
So this is just to make sure that we don't try and
start a new level right as the game is stopping.
So I'm going to set PauseGame to true.
I'm going to increment the GAME_LEVEL,
gotta set the GAME_STATE to eGameState.postLevel.
So it's right kind of at the end of a level.
And then I'm going to call the LevelAdvancePanel.AdvanceLevel,
I'm going to pass it to different callbacks.
So AdvancedLevel, let's go take a look at it.
So AdvanceLevel inside the LevelAdvancePanel.
Set up these two call backs that we passed in as a displayCallback and
IdleCallback on the AdvanceLevelPanel singleton.
And then it sets the state to fadeIn.
So what happens then?
So we go to SetState, and then we set the state to fadeIn.
Now I'm going to go into more of the details of the various states of this one
I talked about the bonus challenge.
But the important thing to note here is that the LevelAdvancePanel flows
through multiple states.
And then eventually it gets to a point where it calls the first of those
callbacks.
And so we scroll down, and you see here, that when it gets to the display state.
Which is where everything is faded in, then it's going to call, displayCallback,
if it is not able to know.
So this is a delegate displayCallback, and then it calls the callback, and
then sets the call back to null so that it won't be called again.
So let's go look at this displayCallback.
That is going to be back in AsteraX, the LevelAdvancedSDisplayCallbacks right here.
So when that is called back, it calls StartLevel, and
this is where we actually set up the level.
So what happens is the LevelAdvancePanel fades in and everything nice, and
does a little animation.
And then while it's just waiting and showing the level, waiting for
the player to kind of read it.
It in the background instantiates all of the different asteroids and stuff.
And the reason we do this at that time is because we're instantiating a bunch of
objects and that can cause a performance hit.
But if we're doing a performance hit when we're just showing a static screen anyway,
no one will ever notice.
So let's take a look at this StartLevel method.
So here we are looking at the StartLevel method, where we pass in a level number.
Now first we make sure that the LEVEL_LIST is all set up,
and that there are levels in the list.
And then it says if the number that we passed in is greater than the LEVEL_ LIST
length, then just go back to the first level.
So that way, I mean I don't think anyone would get past level 10 in this game,
because it gets really difficult.
But if they do, it just loop back around,
that's not how it would work in a real game.
But that allows the game to keep in played in this prototype that we made.
It sets our game statement to preLevel, sets our level number,
and then calls the info from the LEVEL_LIST.
And you'll note that I have a levelNum -1 because the first level in
the list is level 1.
So we do 1 minus 1 gives us 0, and we get the 0th element
which is really kind of like the first element in that list.
Then I clear the asteroids and I clear the bullets,
now I'll show you those in a second.
And I find objects with a game tag destroy with level change that's
just another way to make sure that everything gets destroyed that
needs to be destroyed before we change levels.
And I set up everything for sort of spawning asteroids and
then I spawn them ParentAsteroids and that sets up my game.
Now all of this happening while the LevelAdvancePanel is still continuing with
its animation.
So it displayed for a while, and then the next state after display is fadeOut.
You can see that nextState is set there on line 118.
It's fadeOut and then for fadeOut, the nextState is fadeOut too.
And then it continues to flow through these different elements fading out
until finally the nextState on line 152 at the end of the third fadeOut is idle.
And when it sets the idleState which you can see up here at the top.
Then it calls the idleCallback and
again sets the idleCallback to null once it's done.
So that idleCallback is back on AsteraX.
Here, LevelAdvanceIdleCallback on line 200, and
that will set the GAME_STATE to the LEVEL_STATE and unpause the game.
So then everything is all set up and it just unpauses the game and
the player is able to play.
And that's how we handle the various level transitions.
Now I also mentioned that, we're keeping track of asteroids and bullets.
Now we keep track of the asteroids, to know when the level has ended.
Because the level is over, when all the asteroids are destroyed.
And that's this line 14 static list of asteroids.
And I keep track of the bullets, so
that I can destroy all of the bullets at the end of the level.
because we don't want to pause the game, advance the level, start the new level and
then have a bunch of bullets still flying around.
So we need to make sure and get rid of those.
And further down in AsteraX, I have an AddAsteroid and
a RemoveAsteroid method, and I have an AddBullet and RemoveBullet method.
So these just add and remove things to and from these lists.
And if I go into AddBullet for instance and look for all of the references,
you can see that whenever a bullet is created and
has its Start method called, it adds itself to the list of bullets.
And then whenever a bullet is destroyed,
it removes itself from the list of bullets.
And this add and remove methods, they do have protection on them.
So if it's already in the list, it doesn't add itself, and
if it's already been removed from the list, it doesn't try and subtract itself.
Now if you remember I also destroyed all the game objects,
that were tagged with destroy with level change.
One of those is the AsteroidExplosionPrefabs.
So the asteroid explosion happens, and it destroys itself when it's done.
But if it happens at the end of the level, I don't want to see it,
when I start the next level.
So you can see, that I have tagged it with destroy level change.
And I've done that for a lot of the different visual effects.
One thing you will see is if the player ship runs into the final asteroid
which causes the level to advance.
And the game is not over,
the ship will actually jump at the beginning of the next level.
And frankly, I think it should that,
because that helps the player understand that running into the asteroid at the end
of the level does still subtract a jump from them.
So I think that's everything for this and I hope you enjoyed this video.
I look forward to seeing you in the next one.
[MUSIC]
