The device or "platform" that a game is developed for and played on has a massive impact on the game development process. In this hands-on course you will explore how to develop a game for a variety of modern platforms, including Web, Windows, Mac OS X, iOS, and Android. While building a complete game, you will learn intermediate and advanced game development techniques in the Unity game engine. By the end of the course, you will understand how to develop, refine, package, and prepare your game for distribution on a variety of game platforms. Particular attention will be given to developing a 2D platformer game that supports multiple forms of input (keyboard/mouse, controller, and touch), works across multiple forms of output (screen size, screen resolution, sound), and performs well on a variety of computing devices.
Character Controller Code Part 1
Loading...
來自 Michigan State University 的課程
现代平台上的游戏开发
611 個評分
從本節課中
Getting the Game Playable
Welcome back!
This week we will continue to build our 2D platformer game, getting into some level design and gameplay enhancements, including adding an enemy to our game. Along the way we will start to introduce some Unity Editor tips and tricks and some more advanced programming concepts.
As always, if you are having troubles with a concept, quiz, or technical issue with Unity or the project, you should post on the Discussion Forum to ask for help. Remember to be a good Coursera community member and help others out when you can.
Onward!
與講師見面
Brian WinnAssociate Professor
Media and Information
[MUSIC]
Now that we're starting to get some interesting game play,
let's do a quick walk-through of the character controller code.
Our objectives will be to explore the public and
private variables in the character controller 2D script and
explore how the variables are set up in the Awake function.
So if we click on Sparti once again and
look at the character controller component just to re-familiarize ourselves.
We got the move speed with the slider.
We've got jump force, player health.
We've got what is ground.
And the ground checked.
And of course, all the sound effects.
So we set these up all in a previous stage.
So let's go ahead and open the script.
We can just double-click on the script here to bring it up in my develop.
And see how this is all created.
So, here at the very top of our public class, we define our public variables.
So, you can see we have this new construct that we haven't seen before
with the double brackets.
That's defining a range between zero and ten.
So this is a float, this move speed is a float variable defaulted to three but
this range attribute above it is actually what's creating the slider that me see and
the slider has a range between zero and ten.
So we're basically limiting our desires to pick
what we view as a valid range for this property.
Of course the jump force we didn't do that we just
made it wide open people can take them whenever they want.
Player health, same sort of way it's an integer.
The layer mask, so this is what created this drop down
that was built out of all the layers that are currently in the project and then we
using the FA's we could select whichever ones we wanted to define as ground.
[SOUND] The ground check is a transform that we dragged into this.
So, that's the ground check.
And then we have something that we haven't seen before.
Once again, we're using this sort of double bracket with a special term here.
Like we did with range.
So, this is a public bouillon, it could be true or false, called player can move.
But, we're actually hiding it in the inspector.
So, by putting this just before the variable it doesn't show up out here.
So, this is something that we wanted to make a public variable so other scripts
can access this property and determine if a player can move currently or
not, but we didn't wanna actually expose it in the editor, because we don't expect
it to be something that a designer would turn on or turn off, but
it still needed to be a public variable, so that's why we hid it in the inspector.
So, then we've got all of the audio clip sound effects that we see down here.
And then down below we've got a whole bunch of private variables, so
these are variables of course that aren't exposed in the editor.
They're not exposed to the outside world of the script but
we want to use them within the script.
So we have a bunch of variables here to store references to the components
of the game object.
So we've got a transformer rigid body an animator in an audio source for
a private variables I've been calling this naming scheme of using the underscore.
So you'll often see either M underscore or
just an underscore in the name of the variable that's private.
Just so it's easy to see that.
So we've got these defined.
We've got variables to hold the player motion and
the change of motion in the X and Y.
You can see we've got a couple bulions,
which we did not follow that naming scheme.
So you don't necessarily have to follow that scheme, but
if I wanted to, one nice thing that you can do is you can rename these and
have it change everywhere in the script immediately.
So if you right click on facing right and go to re-factor and choose rename.
It will select the whole variable name and
if I scroll through It'll actually select them everywhere.
And then while I'm on that, I can just type something new.
So let me type underscore facing right and then hit returns.
So down here it says, accept, return.
Escape to cancel.
So if I do that, now everywhere in the script that it had,
just facing right will now be underscore facing right.
So I can do the same thing for is grounded.
Refactor that, choose rename,
do _isGrounded and the same thing for
is running, rename this as _isRunning.
And as we look through the script,
all of those variables will now be changed to the proper name.
So if I look down into the awake function, this is where we typically do our set up.
Either in a start function or an awake function.
Awake happens first and then start.
So if there's things that you wanna do before start,
you typically can do them in awake.
And you can see one thing I'm doing is I'm setting up all these private variables so
the _Transform = GetComponent=Transform.
So this is getting the transform component of this game object,
it's getting a reference to that.
Because we're gonna be potentially moving this through the transform,
we get the RigidBody2D component.
Get a reference to that cuz we're gonna be modifying that through code.
And in the past you might have just got the component
when you needed to adjust it, but that process is actually less efficient.
Unity takes time to actually access the component.
So if in awake we actually.
Create a variable and get the component just one time at the beginning,
then we can access it throughout the script in update, for example, and
it'll be a lot more efficient.
Couple of other things I'm doing is I'm checking to see if it returns null.
So every game object has a transform, so that's never gonna be null.
But they might not have a RigidBody2D cuz the designer may have forgot to attach it.
So in this case, I'm checking to see if the result of GetComponent is null.
So if it equals null, the RigidBody must be missing.
So I actually output an error to the console.
So here it'd say, Rigidbody2D component is missing from the game object.
So I do that across all these for, I get the animator,
if it's missing, I output that.
One difference is the AudioSource.
So, we do have an AudioSource component on Sparty.
But if a return null whether than an output in error which is a red
message down in the console.
I output a warning which is yellow typically I believe.
This says audio part is missing from this game object adding one.
So what it actually does is it just adds it.
So rather than get component, we add component.
So you could dynamically attach components to game objects at run time.
Of course, when you stop playing it's gonna go away.
But for purposes of during the play session,
this will add an audio source component to this game object.
Which we could then use while we're playing if it didn't already have one.
So this is just making more robust code that both outputs messages,
warning messages or error messages to the designer to make the script
more powerful and in this case it actually dynamically adds a component to clean up
after a designer that maybe forgot to add that audio source.
So the next thing that we do is we set a private variable
to the layer of this game object.
So this is the layer that's define up here and is actually a number.
So if we go back to our layer editing, all of this odd numbers, so the player
layer in this case is number eight and the platform, for example, is number nine.
So if I go back to my script, you know, we basically dynamically get the layer
of the player here, and then the next line, determine the platform layer.
So we can use this LayerMask.NameToLayer and
pass at the name platform layer, and we can get back the result of that.
So a lot of these things in scripting you may not remember, you might remember well,
how did this happen, how did I get the layer number of a given layer.
You can go back to code and
you can maybe see an example you can look in the documentation.
Remember, any of these things you can select and hit either control,
apostrophe on Windows, or command apostrophe on the back.
Or, with it selected under help, you can go to Unity API reference.
And that will essentially do a search on whatever is selected.
So LayerMask.NameToLayer give a layer name, returns the layer index
as defined by either built in or user layer in the tags and layer manager.
And you can click on that and get more documentation and
see how that might be used.
So it's always really helpful to pull up the documentation
while you're writing code.
So all those things we've done in awake that's basically setting
up those private variables so we're going to use those later in the script.
[MUSIC]
