Upcoming SlideShare
×

# Python lecture 09

202 views

Published on

Published in: Education
1 Like
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
202
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
3
0
Likes
1
Embeds 0
No embeds

No notes for slide

### Python lecture 09

1. 1. Python & Perl Lecture 09 Department of Computer Science Utah State University
2. 2. Outline ● PyGame ● Sprite Movements ● Build a simple game
3. 3. Games ● ● ● Games are one of the most applicative areas of programming. To write even the simplest games, you have to get into graphics, math, physics and even AI. It’s a great and fun way to practice programming.
4. 4. Creeps A complete simulation of creeps, round creatures that move around the screen, bouncing off walls and changing their direction from time to time.
5. 5. Goals ● ● ● ● We want to have creeps moving around the screen The amount of creeps and their appearance should be easily configurable The creeps will bounce off walls correctly To make things more interesting, the creeps will exhibit semi-random behavior
6. 6. So what is a creep ? ● ● ● A creep is a small image that will be moved around the screen and rotated using Pygame’s capabilities In gaming terminology they are known as sprites We limit the rotations to quantas of 45 degrees (meaning that creeps will move up, down, left, right or in 4 diagonals)
7. 7. How do creeps "move" ? ● ● ● Movement is an illusion. Nothing really moves on a computer screen. Rather, the program displays a sequence of images with small displacements fast enough for the human eye to perceive movement. The rule of thumb is that anything with 30 updates per second or faster is good enough and looks smooth to the average person.
8. 8. Game Loop
9. 9. The game loop
10. 10. How often does this loop run ? ● This is decided by the call to clock.tick. ● clock is a pygame.time.Clock object. ● The call to tick basically says this: sleep until the next 1/50 second boundary, at most. This limits the game speed to 50 FPS, which is a good thing, because we want the game to be smooth on one hand, and not eat up most of the CPU on the other hand.
11. 11. What comes before the loop
12. 12. Creep class
13. 13. Creep constructor ● ● ● ● The Creep is provided with a random image from the list of images (choice is a function from Python’s standard random module) It is set in a random position on the screen (randint is also from random) A random direction (more about the direction later) The speed is set to 0.1 px/ms (0.1 pixels per millisecond), or 100 pixels per second
14. 14. Vectors and directions ● ● Vectors are the chief mathematical tool for making computations related to movement on the screen We’ll use vectors for two things:  Position  Velocity
15. 15. Vectors and directions
16. 16. Vectors and directions ● ● ● A point on the XY plane can be represented by a 2D vector. The difference between two vectors is the velocity (displacement) vector. In other words, adding the velocity vector to the original position vector yields the new position.
17. 17. Normalized Vectors ● In almost all graphical drawing interfaces, the top-left corner is (0, 0), X increases to the right, and Y increases to downwards. In other words, the screen drawing XY plane is:
18. 18. Implementing vectors ● ● ● Surprisingly, Pygame doesn’t have a "standard" vector implementation shipping with it. So game writers have to either roll their own or find vector modules online. We will use the vec2d.py file, a 2D vector implementation the Pygame Wiki.
19. 19. Updating the creep ● The most interesting function of this demo is the update method of Creep def update(self, time_passed) ● This method is called periodically by the main loop and is passed the amount of time passed (in milliseconds) since the previous call.
20. 20. Updating the creep
21. 21. Rotating the creeps ● transform.rotate rotates a given surface counterclockwise by the provided angle. self.image = pygame.transform.rotate (self.base_image, -self.direction.angle) ● We give it a negation of the angle because of the inverted "screen XY plane"
22. 22. Rotating the creeps ● ● Suppose our rotation direction is 45 degrees (that is, south-east in our screen coordinates) If we give 45 degrees to rotate, it will make the creep point north-east (as its rotation is counterclockwise). So to perform the correct rotation, we have to negate the angle.
23. 23. Update continued ● Next in update method we have
24. 24. Displacement displacement = vec2d(self.direction.x * self.speed * time_passed,self.direction.y * self.speed * time_passed) ● ● self.direction is a normalized vector that tells us where the creep points to The displacement is computed from the basic rule of motion that distance equals speed multiplied by time
25. 25. Blitting ● Blitting is the game programmers’ jargon for transferring an image (or a pattern) onto a drawable surface. In Pygame this is implemented with the blit function
26. 26. Blitting ● ● ● Blitting, like many other things in Pygame, uses the versatile pygame.Rect class The call to blit accepts an image (a surface, actually) and a rectangle that specifies where this image will be blitted to the surface on which blit is invoked We provide the drawing position as the creep’s current position (self.pos) but with a small adjustment
27. 27. Blitting ● ● ● When images are rotated in Pygame, their size increases. Since the image is square, Pygame has to include all of its information in the rotated image, so the rotated image has to grow in size. This only happens for rotations that are not multiples of 90 degrees Whenever a creep turns, its image size changes. Without a special adjustment, the creep will shift with each turn and the animation won’t be smooth and pretty.
28. 28. Blit adjustment ● ● We center the creep when we draw it The draw position is computed to be the center of the creep’s image. Even when the image rotates and grows, its center stays in the same place, so there will be no noticeable shift in the creep this way.
29. 29. Bouncing off walls
30. 30. Bouncing off walls ● ● First, the screen boundary itself is computed, by taking the rectangle representing the screen and adjusting it to the image size Then, for each of the 4 walls we compute whether the creep collides with it, and if it does, the creep’s direction is inverted in the axis perpendicular to the wall
31. 31. Change directions ● if self.pos.x < bounds_rect.left: self.pos.x = bounds_rect.left self.direction.x *= -1 This is for the bounce off the left wall. The creeps always arrives to it from the right, so when we negate the X component of its direction vector while keeping the Y component intact, it will start moving to the right but with the same vertical direction.
32. 32. Reading & References ● ● http://www.pygame.org/ http://eli.thegreenplace.net/2008/12/13/writing-a-game-inpython-with-pygame-part-i/