This two-part course is designed to help students with very little or no computing background learn the basics of building simple interactive applications. Our language of choice, Python, is an easy-to learn, high-level computer language that is used in many of the computational courses offered on Coursera. To make learning Python easy, we have developed a new browser-based programming environment that makes developing interactive applications in Python simple. These applications will involve windows whose contents are graphical and respond to buttons, the keyboard and the mouse. In part 1 of this course, we will introduce the basic elements of programming (such as expressions, conditionals, and functions) and then use these elements to create simple interactive applications such as a digital stopwatch. Part 1 of this class will culminate in building a version of the classic arcade game "Pong".
Velocity Control
Loading...
Do curso por Rice University
An Introduction to Interactive Programming in Python (Part 1)
1673 ratings
Na lição
Week 4 - Lists, keyboard input, the basics of modeling motion
Learn the basics of lists in Python, model moving objects in Python, recreate the classic arcade game "Pong"
Conheça os instrutores
John GreinerLecturer
Department of Computer Science
Stephen WongLecturer
Computer Science
Scott RixnerProfessor
Computer Science
Joe WarrenProfessor
Computer Science
Well, welcome to lecture. In this lecture, we're going to talk about control.
Now Scott says I have control issues when it comes to running this course, but we're
not going to talk about that kind of control.
We're going to talk about the kind of control you need whenever you want to play
pong and you want to control the position of the paddle on your screen.
In the second lecture this week, Scott talked about using keyboard input to
control the position of the circle on the canvass.
We're going to go back and revisit that example.
And, I'm going to talk about a way you can change the scheme for controlling the
position of the wall where as if controlling the position directly, you're
actually controlling the velocity of how the ball moves around on the canvas.
And, we'll talk a little bit on one note and then we'll go and I'll actually just
walk you through a second example that will actually have a lot of similar
functionality to that which you'll need inside pong.
So, let's pay attention to this lecture, I don't want you to have control issues now.
So let's look at Scott's example of controlling the position of a circle on
the canvas, using the arrow keys. So let's just run the application to
start. So here we have our canvas, and we've got
a white circle in the middle, and I'm going to go through, and I'm going to
just, if you can hear me, I'm just going to start banging the arrow keys here, and
I'm slowly moving the circle to the left. I can go back and make the right arrow
key. You can actually see there in the status
area, that I've got, continually hitting the arrow key, and go up.
I can go around and then kind of a rectangle.
And You could see over here actually, I am printing out the position so you can kind
of keep track of the list just to see and really just matching the keys a lot.
Now, If you're not an Arcane Mage on the World
of Warcraft, where button mashing is your main skill, okay, maybe this is a, a good
control for you. But, in general, if I want the, the circle
to go up, I should probably just hit the key once and it starts moving up.
And then, maybe if I hit again, it stops or release the key, it stops, just
something like that. That's what you see in most games.
So, this is a not, not a great way to control the position of this circle.
Let's take a quick peek at the code and see kind of what the need the code was
that Scott used here. So what do we have?
Well, we have a kind of one critical variable here, it was the ball position,
it was a global and in our key down handler.
We simply checked to see if we hit an arrow key, and if that we did, depending
on which arrow key, as we changed one of the components of this ball position, and
we changed it by some step size. We've actually moved it four pixels.
So every time I hit the key, left key, the horizontal component of the ball position
was decreased by four. And so essentially, just, I mashed the key
a lot. The key in would get called a lot, and I
changed the position of the ball. Another thing I know here is that I didn't
do anything interesting the drawing handler, drawing handler just set there.
It was just drawing the ball over and over.
So, what I'm going to do is I'm going to try and go back and revisit how does this
ball pause as an example and show you a different way to control the position of
the ball. So, just pop on the one note real quick
and I'll roll out what I'm going to do and then, we'll go back and we'll kind of look
at a modified version of this. Alright, let's think about the code we
just took a look at and see if we can improve the manner in which we move the
ball around on the canvas. So, the critical thing here was that we
had, the ball had a center p here. So, we're going to control the position of
that point p. So, this was a positional control scheme
we looked at. And there are some critical things that we
noted, there was no update on the draw handler so the only place that we modify
things were inside the key handler. So in the key handler, if you recall, we
updated this position P, was a global variable.
If we hit the left arrow, we took the horizontal component, and we decreased it.
Okay, that's what this equation says here. We hit the right arrow, we took the
horizontal component, and we increased it, and the same thing for up and down.
So that's why, if we want to move the ball a lot, we had to hit the keys a lot.
So, what I want to do is I'm going to think about how we might be able to modify
just using some of the ideas we saw from the ball physique example to build a
better control scheme. So, the critical thing here is again, we
have p. Okay, that's the center of the ball, but
we also have V here. What's V going to be?
V is the velocity. Okay, so it's going to be how fast the
circle was actually moving, so we're going to use an update that's exactly like what
we saw in the ball physics exam. We're going to continually take the, take
the center of the circle's position, and we're going to update it based on a
velocity vector. So now, what's going to happen when you
hit a key? When you hit a key, we're going to control
the contents of that velocity vector. So, down here, now when you hit your keys.
What will happen is that, that velocity vector will be changed.
It maybe, for example, will start out of the velocity vector to be zero in both
components and if we hit a little after arrow key, what we're going to do?
We're going to take that, that horizontal component, the first component, we're
going to decrease it a little bit. Now, as you run the update loop, the
ball's position will start to be updated and so it moves to where the left-hand
side of the canvass. We hit the right arrow key then.
Well, we're going to kind of cancel that out and the ball come back to rest.
Hit the right arrow key again, the ball starts moving to the right,
And so forth. Now this is not the exactly the way pong
works. Pong is going to work a little
differently. You're going, it's going to work where if
you hit a key, and hold it down, your paddle will start to move.
When you let, let the key up, your paddle will start moving.
But this kind of gives you a feel for kind of the, the trends that you have to go to
actually implement pong So let's take what I've shown you here now, and just, we'll
look at the code that actually implements it, and then we'll play around with it for
a second. Alright.
I've gone through that and implemented the ideas we talked about just a second ago
inside the inside CodeSkulptor. So, let's just kind of walk through what
that code would look like. So, the first thing to notice here is that
now, we have both the position and the velocity.
They are global variables and we're going to have our, build our draw handler and
our key handler and we're going to update those.
Probably the famous most different is, we actually have an update now inside of the
draw handler where we're going to continually update the position of the
ball based on its velocity. Since the velocity starts out to be zero,
no big deal. The ball is not going to move but to make
the ball move, what we're going to do is we're now going to modify the key handler.
So, instead of trying to change the position of the ball, we're going to
change the velocity vector associated with the ball.
So, for example, if I hit a Left Arrow key, we're going to make the component,
make the velocity vector to have a component in the left direction on the
canvass and you can go and hit the left key multiple times, you can make it move
faster and we get the Right Arrow key to slow it down, I could get it moving right.
So, let's just do a quick demo here and you kind of see how this works.
So, here we are. Ball setting in the mail screen.
I'm going to hit the left arrow key once. All starts moving left.
Not hitting any key. See, here's my hand.
Hit right, stopped. No keys now.
Now I'm going to hit the right key again. Hit it twice.
Ball is moving faster, stopped, it's fine. You know, as I can get it moving pretty
faster, it's like kind of a game here that you can play where, you know, you can just
bounce the ball back and forth. Do you want to look here, you can see over
behind I'm actually printing out both the position and the velocity vector.
So, you can see how the velocity vector is being changed as I hit the Left and right
arrow keys. Now, here's a little interesting
challenge. This will show why this control scheme is
not the one that you see in most games. Remember before when I was in position or
control, I can make the ball kind of go into a rectangle.
So, let's see if I can get the ball going really fast and kind of a circular motion
here. It takes here a little bit of skill, let's
see. Oh, now, okay.
No, dang, no, no, oh, hang right. Oh, there we go, gee, here we go.
Alright, you can see that the problem is, oh, I think that might be it.
Okay, I'm going to stop, stop ahead here. The problem you see is, I'm trying to get
the ball really fast here, that, as I hit the keys, the keystrokes start to add up,
and I can get the velocity of that to moving faster than what I can keep on the
screen. So, this is not the kind of control
schemes that most games use. It's like that something is going to be,
going to be the kind of control scheme you're going to want to use in pong.
There's just simpler, safer scheme that you can use which is if you hold out a
key, you increment the corresponding component of the velocity vector.
When you release the key, when there's a key up event, then you decrement the same
component of a velocity vector. This has the property that you can't
really kind of build up multiple key presses in one direction.
That limits the velocity of the object on the screen.
That's the model that you're going to use inside all.
Okay, John is going to do his programming tips video, and then I'll be back, and
we'll talk about Pong more. Just take a little look at this, play
around with it, modify it. I think this will kind of get you going,
and figure out how to control the paddles in pong.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2018 Coursera Inc. Todos os direitos reservados.
