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"
Reading Documentation
Loading...
來自 University of Colorado System 的課程
Introduction to C# Programming and Unity
120 個評分
University of Colorado System
120 個評分
課程 1（共 5 門，Specialization C# Programming for Unity Game Development）
從本節課中
Starting to Program
In this module, you'll learn about the course and get Unity installed and configured. You'll write your first C# console application and C# script in Unity, and you'll also learn some of the ways we store and use information in our C# programs.
與講師見面
Dr. Tim "Dr. T" ChamillardAssociate Professor
Computer Science
In this lecture, we will explore a little more deeply how we read the documentation.
And this is an important skill that every programmer need.
You never reach the point where you don't have to look something up in the documentation,
whether it's the C-sharp documentation or the Unity documentation,
you are going to spend time through out your programming life looking up
information from the documentation that goes with code that others have provided to you.
So we're going to explore that a little more here,
but you're going to have to just practice.
You're going to have to just learn how to do this by doing it,
time and time again.
So let's go to MonoDevelop and solve
a very small problem that requires us to explore the documentation a little bit.
So here's our MonoDeveloped project that I created and commented,
including this comment that says calculate and print the cosine of 45 degrees.
So that is the problem that we're trying to solve.
Let's actually declare a float and we'll just call it cosine.
And we're going to need to set it to something,
specifically the cosine of 45 degrees.
Let's actually just set it to something right now.
And this is a temporary thing,
I want to show you another important detail about using float.
So let's say I set it to point eight even though that's incorrect.
And I tried to compile it with f8.
I actually get an error here that says the
literal of type double cannot be explicitly converted to float.
And it even tells us the answer,
it says use an 'F' suffix to create a literal.
So when the compiler sees a decimal number like this,
it assumes it's a double.
And one of the things we're not allowed to do,
is to put a larger data type like a double into
a smaller data type like a float because to do the B = N,
and we know that we will potentially lose some precision when we move from
a larger data type to a smaller data type
because the smaller data type can't represent as many things.
The message here says to use an 'F' suffix and you certainly can.
I tend to use lowercase f instead.
So now we can compile fine.
We get a warning that says cosine is assigned to but its value is never used,
so let's go ahead and use it.
Console.Writeline cosine of 45 degrees,
and we'll control f5 and of course we get our output, but it's a lie.
So now we have to figure out how we can actually calculate the cosine of 45 degrees.
And it's a good time to go look in the documentation.
Now, unfortunately, one of the things you have to know if you're going to
search is to search on something and you have to know what to search for.
So let's actually search on cosine because that's the thing we're trying to figure out.
I'll just hit enter here.
And it turns out that there's a whole bunch of
answers but the math.cosine method is the one we want.
So I'm going to click on it and that brings us right to the method.
Now another way we could get to this method,
is by actually looking at the math class.
So I'm going to scroll down to the bottom here and click Math Class.
So we could end up here.
Now the Math Class is a very useful class that has lots of
stuff in it that we will regularly use as we do math in our games,
including calculating cosine and including
one other piece that we'll get to in a few minutes.
So we could also get to cosine by finding
the cosine method from the Math Class and clicking it.
And this brings us back to the same page we were at.
Now, there are pieces in
the documentation that we need to understand to be able to use it.
First of all, we see that it's static and that means just like console.writeline,
it means that we will call math.cos by
putting the class name math dot in front of the method name.
The second thing we see is that it actually
returns something and that's good for us, right?
We're trying to calculate the cosine of an angle and it returns something to us.
And so we need to know that it's going
to return a double to us because we're going to store that double somewhere.
The method name comes next,
and then between the parentheses anything we're supposed to provide.
And if you race through reading this documentation, you'll say,
"Okay 'd' is an angle,
great", and you won't read the rest of it because you're in a big rush.
And so let's go use the call to this method in our code.
So instead of this,
we will say Math.Cosine,
the angle and we said we were going to do 45 degrees.
When I compile, it says wow this looks a lot like the previous error message,
although not exactly but it does say we can't implicitly convert double to a float.
Back in the documentation,
this says the method returns a double,
and here in the code,
we're trying to put it into a float.
So we can use the typecast that we
used when we were doing calculations in the previous lecture,
to say I want to typecast the double that you return to me into a float.
And I have to do that explicitly because this is a double so it's a bigger data type.
So pushing it into a smaller data type,
that means we could do some precision.
I'm allowed to do it,
I just have to explicitly do it.
Now, I'm going to control_f5.
And if you don't know what the cosine of 45 is,
you'll say wow this is great.
I got a number and I must have it correct.
One of the important things to do when you're doing math
and checking your code to make sure it's working properly,
is you need to know the right answer
before you can actually tell if your code is working properly.
And I can tell you that's not the cosine of 45 degrees.
So, we go back to the documentation and read this full comment,
that says an angle measured in radians.
We're not providing an angle measured in radians,
we're providing an angle measured in degrees.
So how do we convert from degrees to radians?
Well, you need to know that 360 degrees is the same as 2 pi radians,
so 180 degrees is the same as pi radians.
And so we need to multiply this times
pi divided by 180 and that will convert it to radians for us.
And you might say well I know pi, it's 3.1415.
And while we could get this to work,
there's a better way to use pi in our games
because back in the Math Class and this is the class not the cosine documentation,
we can see past all these methods,
we can see that math actually provides us a constant for pi.
So this is the value we get when we use Math.PI.
So let's just use Math.PI instead of hard coding it in our code.
And the way I do it,
is I say Math.PI.
Now I'll make sure I build fine, build successful,
I control_f5, and I get 0.707 which is in fact the cosine of 45 degrees.
So I'm done with this particular problem.
And we learned a couple of different things.
Importantly, we learned about type casting something that gets returned from a method,
but we also learn that we can read
the documentation to find out information about a particular method,
like what does it return,
what does it require as information we
pass in and we need to pay attention to all that stuff.
So that was a very small exercise in exploring C-Sharp documentation.
But you're going to be doing that,
as long as you program,
you're going to actually be looking stuff up in the documentation,
so you get lots of opportunities to practice doing that as you program.
