Adding Behaviors

Loading...

Del curso dictado por Michigan State University

Introduction to Game Development

2742 calificaciones

Michigan State University

Introduction to Game Development

2742 calificaciones

Curso 1 de 5 en SpecializationGame Design and Development

If you love games and want to learn how to make them, then this course will start you down that path. Making games is a creative and technical art form. In this course you will familiarize yourself with the tools and practices of game development. You will get started developing your own videogames using the industry standard game development tools, including the Unity3D game engine and C#. At the end of the course you will have completed three hands-on projects and will be able to leverage an array of game development techniques to create your own basic games. This course is for individuals interested in becoming a game designer, game artist, or game programmer.

De la lección

Intro to Unity3D Development

One of the reasons we use Unity3D is its visual editor which makes creating interactive games accessible to both creative and technical individuals. In this module, you will create your first Unity3D project from start to finish. Using a variety of graphical and audio assets and a library of scripts, you will create a simple model of our solar system. By the end of the module, you should have a good understanding of the Unity3D editor and the workflow for creating games.

Project Overview1:57

Getting Started3:50

Working in 3D Space9:15

Setting up the scene9:57

Adding Behaviors12:06

Conoce a los instructores

Brian Winn
Associate Professor
Media and Information

[SOUND] In this video we'll get our solar

system moving through the use of behaviors.

Our objectives will be to use behaviors to get our game objects rotating in

a logical fashion.

Understand a bit about parent/child relationships between game objects in

unity.

And understand the difference between the world coordinate system and

local coordinate systems of game objects.

All right, so the first thing that we wanna do is get our sun moving.

So we've got this scripts folder.

This contains a number of pre-created C

sharp scripts that we're gonna be using in our project today.

Most notably for this part we're gonna be using the RotateAround script.

So if you click on a script you can kinda see a preview over here.

You don't edit a scripts directly within Unity.

You typically open up external script editing tool or text editing tool.

Unity comes with a tool called Mono Develop,

which we'll talk about later in this course.

But for now, we're not gonna actually do any coding, we're just gonna use

these pre created scripts that come with these set of assets.

So, over here, let me go ahead and select on the Sun,

and of course I can hit the F key to zoom right in.

We're gonna attach that RotateAround script,

often they're called Behaviors right to the sun.

So, there's many ways of doing everything in Unity.

It is a very visual environment.

So I could literally click and hold on the RotateAround script,

I can drag it over and drop it right in the scene view on the Sun game object.

I could also drop it right on the sun in the hierarchy, or

if the sun is selected, I can also drop it right in the inspector.

So all three of those methods do the exact same thing.

If I let go here,

it will add that RotateAround script to the sun game object.

Scripts basically become components.

Just like the transform component,

we've got another component now in our inspector, and

you can see it says RotateAround.

The script has two additional properties that we can set.

One is the Target.

The Target is what we wanna rotate around, and the second is the Speed.

If you don't set a target,

it will basically rotate around the center of the world, I believe.

But we can actually set a target.

These things, once again, you can drag and drop things.

Or when you've got the little dot next to it, you can click on that.

It will open up a selection tool, which will show

all the possible things that you can select of that certain data type.

So this is looking for a transform attached to a GameObject, and

these are all of our GameObjects that have transforms on them in the world.

And we want the Sun to spin around itself, so I can just go ahead and select Sun.

So once again I could do it that way through that little selection pop-up.

I could have also just grabbed the Sun game object, dragged it over here, and

dropped it into that slot.

The final thing I wanna do is set the speed.

And this script is set to

pick the number of degrees per rotation the number of degrees rotating per second.

So let me go ahead and pick five degrees per second.

And hit Return.

And we haven't actually played our project yet.

But, so now that we actually have a do something,

I can actually hit the play button and the script will start to execute.

And it's kinda hard to see down in the game view because

we don't have any textures or any materials applied yet to the game object.

We'll do that here in the moment.

But we can tell up in the scene view that it is actually rotating

when the Sun is selected.

If I click on a different object like the Earth, it's a little hard to tell.

But once again, if I click on the Sun, you can see the Sun is actually rotating.

Now while I'm playing, the unity interface darkens all a bit,

you can see the play button is to press.

I can actually make changes over here.

So with a Speed of five, let me go up, let me go ahead and change it to 50, for

example, and hit Return.

You can see now I'm rotating much faster.

But notice what happens when I stop playing.

So let me hit the Play button to stop playing.

Notice the speed went back to 5.

Okay, so when you're not playing, you're in edit mode.

And in edit mode, you can make changes.

So I could, let's say, change this to ten.

That change sticks, in essence, it stays.

When I hit play now I'm rotating at ten.

If I go ahead and modify this and change it to 100 for example.

We can see the result of that as we're playing it sort of a quick way

to do iterative development to kinda test things out.

Kind of I can actually click and

drag right by the speed to kinda get the speed that I really want.

But once again after then I have to kind of look at that and say oh, it's 156.

And then when I stop playing, it goes back to the original setting.

I then have to change that.

So for sake of example, the Sun is gonna rotate fairly slow, so

I'll just leave it at five.

Let's go ahead and do the same thing to the Earth.

So I'll select the Earth.

I'm gonna use the RotateAround script, so I'll use the other technique.

I'll drag and drop it right on the game object in the scene.

You can see it attached it over here, as a component on the Earth Game Object.

Once again, I'm gonna set the Target to itself.

So I'll drag the Earth Game Object out of the hierarchy,

set it as the Target, and go ahead and set a speed of.

Let's just say one degree per second.

And go ahead and play that.

And you can see it's moving very, very slow.

So let's go ahead and increase that up to ten.

And we can always quickly test things.

See it rotating.

And the last thing, let's go ahead and get the eart rotating or

the moon rotating as well.

So I'm gonna go ahead and drag and

drop the RotateAround right onto the Moon game object in the hierarchy.

Select the Moon to see it.

I'm gonna set the Target of that to the Moon through the Select_Transform pop-up.

And I'm gonna go ahead and set this speed,

let's just say to 15 degrees per second and go ahead and play.

So now, as I select these things, I can see they're all rotating.

Essentially spinning around their own internal axis.

They're sort of local axis or their local origin.

But what about making the planets rotate around each other?

After all, that's our end goal here.

So I'll go ahead and stop, so I go back into edit mode.

And there's a couple of different ways of doing this.

For the Earth, I want the Earth to rotate around the Sun.

So let me actually add a second RotateAround script to the game object.

So go ahead and drag and

drop it onto the inspector with the Earth game object selected.

And you can see I can actually have multiple of the same component type

when they are scripts.

I'll set the target of this to the Sun rather than to itself.

And I'll go ahead and set the speed, let's just say, so we can clearly see it.

You gotta make sure that you select the right component.

So the second component here, that's rotating around the Sun.

I'm gonna go ahead and set it to 40, go ahead and hit Play.

And you can see, oh yeah, the Earth is definitely rotating around the Sun.

But it's kinda leaving the moon behind.

Right?

So let's go ahead and stop this.

So we need to get the Moon rotating around the Earth.

But since the Earth is moving, rotating around the sun,

if I do the same technique basically, the moon will kinda be left behind.

So, I can show that really quick.

Add that rotate around script to the moon, set its target as the Earth.

Let's set the rotation speed a little bit slower.

Let's just say five per second and go ahead and hit Play, and you can see that

the moon is kinda chasing the Earth now as the Earth is spinning around the sun.

Clearly, that's not what we want.

And then as it comes by, it kinda tries to catch up there.

Let me go ahead and click the Y-axis, so we can see kind of a top-down view.

Zoom out a little bit so

as I'm playing it makes it a little clearer what's actually happening there.

So really the best way to resolve this is to make the Moon a child of the Earth.

So I'm gonna go ahead and remove that second rotate around script.

So you can always remove these components that are removable by clicking the little

gear drop down and you can select Remove Component, and

that gets rid of that rotator on.

I wanna keep the other one cuz I still want the moon to rotate around itself.

So I'm gonna basically take the Moon and drag it and drop it right on the Earth.

And what that does is it makes the Moon a child of the Earth.

So they're both game objects, of course, but this is the parent game object and

this is the child.

And the child basically, it's transformed now,

modified and it's realted, it's relative to its parent.

So notice the position is now negative one, zero,

zero cuz it's negative one meters in the extraction away from its parent.

If I drag it back to the top level, you can see it's

1.5 off of the world coordinate system, cuz the world is essentially its parent.

Once again, put it back on the Earth and

it's negative one meters from the center of its parent, which is the Earth.

So now when I play without adding any scripts, you can see that as

the Earth is rotating around the Sun so too is the Moon rotating.

So it basically maintains its same relationship to its

parent all the way around as the Earth moves.

And of course, it is spinning itself.

Now if we really wanna get fancy, we can have the Earth also,

sorry the Moon also rotate around the Earth.

So I can go ahead and add a second script like we had before.

Set the target as the Earth.

Give it a speed of five again.

And go ahead and play this.

[COUGH] And now of course we've got the Sun spinning,

we've got the Earth spinning and rotating around the Sun.

We've got the Moon spinning.

It's, of course, it's moving with the Earth as the Earth rotates around

the sun and it's also rotating around the Earth, so

as you watch this you can see that it does continue to circle the Earth.

So, to reiterate,

the world coordinate system is centered at the origin of the world.

Often it makes sense to discuss game objects' location

overall using the world coordinate system.

So, for example,

the Earth rotated around the center of the world, or zero, zero, zero.

The local coordinate system is the coordinate system where the origin

is a defined location related to the game object,

usually the center of the game object.

The local coordinate system made sense to talk

about when we spoke about the planet spinning around its own axis.

Like the Sun, the Earth and the Moon spun around it's own origin.

Parent/Child relationships add yet a third coordinate system.

That is a child may move relative to it's parents local coordinate system.

As we saw with the Moon moving around the Earth as the Earth moved around the Sun.

So what's next?

In the next video, we'll start to make our solar system look a bit more aesthetically

pleasing through the use of materials.

>> [MUSIC]

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2018 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play