Explore
For Enterprise
Join for Free
Log In

artes y humanidades
Negocios
Ciencias de la Computación
Ciencia de Datos
Tecnología de información
salud
Matemáticas y Lógica
Desarrollo Personal
Ciencias Físicas e Ingeniería
Ciencias sociales
Aprendizaje de un idioma
Grados
Certificados

Explorar todo lo que Coursera tiene para ofrecer

Explorar
Buscar
For Enterprise
Inicia Sesión
Únete de forma gratuita

Working for the Clampdown

Loading...

Introduction to C# Programming and Unity

Sistema Universitario de Colorado

4.8 (437 calificaciones) | 16K estudiantes inscritos

Curso 1 de 5 en C# Programming for Unity Game Development Programa Especializado

This course is all about starting to learn how to develop video games using the C# programming language and the Unity game engine on Windows or Mac. Why use C# and Unity instead of some other language and game engine? Well, C# is a really good language for learning how to program and then programming professionally. Also, the Unity game engine is very popular with indie game developers; Unity games were downloaded 16,000,000,000 times in 2016! Finally, C# is one of the programming languages you can use in the Unity environment. This course doesn't assume you have any previous programming experience. Don't worry if you've never written code before; we'll start at the very beginning and work our way up to building small games by the end of the course. Throughout the course you'll learn core programming concepts that apply to lots of programming languages, including C#, and you'll also learn how to apply those concepts when you develop games. Computer programming is really fun in general, and programming games is even better! Caution: Beginning (assuming no prior programming knowledge) is not the same as easy (not hard to do). Learning to program IS hard to do, especially since this course is essentially the first half of a freshman-level college course. Meeting the course challenges while you master the material will be rewarding to you, but doing that will require hard work and maybe even a few expletives along the way. Module 1: Write your first C# console application and Unity script and learn how we store data in our programs Module 2: Learn how we use classes and objects to implement our code Module 3: Learn the basics of Unity 2D games and discover how we make decisions in our code Module 4: Get and use player input in your Unity games Module 5: Complete final peer review and take "Final Exam" “Unity” is a trademark or registered trademark of Unity Technologies or its affiliates in the U.S. and elsewhere. This course is an independent work and is not sponsored by, authorized by, or affiliated with Unity Technologies or its affiliates

Destrezas que aprenderás

Video Game Development, C Sharp (C#) (Programming Language), Unity (User Interface), Game Programming

Revisiones

4.8 (437 calificaciones)

5 stars
365 ratings
4 stars
56 ratings
3 stars
9 ratings
2 stars
3 ratings
1 star
4 ratings

MR

Apr 09, 2018

Fantastic course!\n\nDr. T creates the best learning curve by balancing perfectly the level of difficulty in their courses. Worth it even for intermediate C#/Unity programmers.

EJ

Apr 08, 2019

This is a great course for those who want to learn C# for Unity. Dr. T is very effective in his instructions plus the program exercises will make you learn C# in no time. :-)

De la lección

Unity Input

In this module, you'll learn how we can process user input in our Unity games.

Lesson Introduction0:57

Mouse Location Processing7:52

Working for the Clampdown9:23

Mouse Button Processing7:29

The Input Manager7:21

Mouse Button Processing Revisited4:41

Stop the Madness6:12

Keyboard Processing8:37

Gamepad Processing5:04

Impartido por:

Dr. Tim "Dr. T" Chamillard
Associate Professor

Transcripción

Okay, the title of this lecture is also the title

of a song by one of my favorite groups of all time.

So if you've never checked out a group called The Clash,

you should go do that now and then you came back to this lecture video.

Once you do, within this lecture we're going to learn how to clamp

the game object so that it stays within the screen.

And the word clamp is used when we talk about keeping a particular value

within a range of values or a specified set of values.

So we clamp a value to stay valid, basically.

Okay, let's go to Unity and

see how we can do that to keep our character inside the screen.

In the previous lecture, we got our game set up so that the character follows

the mouse around but the character can leave the game window.

So we want to take care of that now.

I've done some preliminary work setting that up.

I've added a couple of additional scripts.

I've added a ScreenUtils script and a GameInitializer script,

and the Main Camera now has the GameInitializer script attached to it.

So let's look at those new scripts and the changes I've made to the Character script.

And then we can get to work keeping that character clamped in the game window.

So the ScreenUtils script is a static class that I wrote.

Notice it doesn't inherit from mono behavior here on the end, and it's static.

So when consumers of this class access the properties that this class provides,

they'll start by putting ScreenUtils, and we'll see that soon.

So basically what I'm trying to do here is to make it so that characters

don't have to calculate the locations of the screen edges every frame of the game.

Instead I want to do that calculation once here and save it.

And then have the consumers of the class,

the characters, just access the properties here.

So I'm going to save screenLeft, screenRight, screenTop and screenBottom.

And then I'm going to expose public static properties for those four different edges.

And here, I have an Initialize method that gets called at the beginning of the game.

And it's going to save the screen edges in world coordinates, and

there's a bunch of math here that I do to do that.

It's pretty straightforward, but you can walk through that on your own if you want

to understand how that math works.

Now ScreenUtils wasn't attached to the Main Camera,

the Game Initializer script was.

And all the Game Initializer script does

is it calls the ScreenUtils.Initialize method.

I'm actually doing this from within an Awake method,

which gets called before any of the start methods get called.

And when we need to worry about that, we'll talk about that some more.

But basically this initializes the ScreenUtils so

that consumers of the class can access these four properties.

And the consumers of the class in this case will be the Character script.

Now, I've added some stuff to the Character script as well.

I've added saving half the collider's width and half the collider's height.

Because if you think about this, for example, the way we can determine if

the character is outside the left-hand side of the screen.

Is that if we take the location of the character and

we subtract half the collider width, so that's the left edge of the character.

If that left edge of the character is less than the left edge

of the screen, then we've in fact exited the screen a little bit.

And we need to bring the character back into the window or the screen, I'll use

those terms interchangeably, to clamp the character to stay inside the window.

So I told you in the previous lecture that I knew I'd need the Start method and

here's where I need it.

So I'm going to retrieve the BoxCollider2D,

that is the component that's attached to the character.

And I'm going to save it into this local variable, and then I'm going to calculate

the colliderHalfWidth as the horizontal, or width,

size of that collider divided by 2.

And I do the same thing for colliderHalfHeight.

And this saves me from dividing by 2 to get half the width and

dividing by 2 to get half the height every frame of the game.

Down here in the Update method, we still follow the mouse around with the character

like we did in the previous lecture.

But we're also going to call a ClampInScreen method that I wrote that

doesn't do anything right now, so I'm going to add a comment,

position as necessary, And

the first I'm going to do is save the current

position into this position variable.

So now I'll check to see if

the position- colliderHalfWidth

< ScreenUtils.ScreenLeft.

If that's the case,

then my character is at least partially off the left-hand side of the screen.

If that's the case,

I will set the x location equal to the left side of the screen,

+ colliderHalfWidth.

And that will make it so

the character is pushed right up against the left-hand side of the screen.

Now I'll do an else if to check if I'm partially outside the right

side of the screen and I'll show you that once we come back,

I will point out that this is an else if rather than an if under

the assumption that the character is not wider that the screen.

You've got bigger problems if the character is wider than the screen.

So I can assume we're either outside a the little bit on the left,

or outside a little bit on the right, but never both.

So in this case I'm checking to see if position + colliderHalfWidth,

so it's the right side of the character.

If that's greater than the right side of the screen

then I'm sticking a little bit outside the right side of the screen.

And so I set the position to ScreenRight- colliderHalfWidth, and

that puts my character right up against the right-hand side of the screen.

I'll add the logic for top and bottom, and then we'll come back.

Okay, so here's the code for top and bottom.

And you might find that you need to draw some pictures on a piece of

paper with a pencil, and see that you understand why this all works.

So do that on your own.

So at this point, we've clamped the position so

that the character is totally inside the screen.

But we haven't actually changed the transform position

attached to the game object.

So our final step is to set

transform.position = the position that we just calculated here.

Now we might not have made any changes to position at all,

if we didn't need to clamp.

It's the same thing.

But we might have changed x or y or if we were in a corner, both.

So this makes sure that the game object transform position is set to

that clamped position.

And, of course, when I go to compile,

I get errors all over the place because I really needed to be checking postition.x,

position.x for the horizontal clamping, position.y,

and position.y for the vertical clamping.

Now I actually get a build successful so I can go back to the editor.

And now when I run my game, we can see the character is clamped on the left,

right, top, and bottom.

So we've implemented the clampdown so

that the character stays completely inside our screen as the player plays the game.

Before we finish the lecture,

you should do an in-video quiz showing your understanding of clamping.

To recap, today we learned how we can clamp

a game object's position to keep it inside the screen.

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.

© 2019 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play

Coursera
Acerca de
Liderazgo
Empleo
Catálogo
Certificados
Certificados MasterTrack™
Grados
For Enterprise
For Government

Comunidad
Learners
Partners
Developers
Beta Testers
Translators

Conectar
Blog
Facebook
LinkedIn
Twitter
Instagram
Youtube
Blog de Tecnología

Más
Términos
Privacidad
Ayuda
Accesibilidad
Prensa
Contacto
Directorio
Afiliados