Mini-project #4 - "Pong"

原创
2014/10/27 20:16
阅读数 53

Mini-project #4 - "Pong"

In this project, we will build a version of Pong, one of the first arcade video games (1972). While Pong is not particularly exciting compared to today's video games, Pong is relatively simple to build and provides a nice opportunity to work on the skills that you will need to build a game like Asteroids. As usual, we have provided a program template that can be used to guide your development of Pong.

Mini-project development process

  1. Add code to the program template that draws a ball moving across the Pong table. We recommend that you add the positional update for the ball to the draw handler as shown in the second part of the "Motion" video.
  2. Add code to the function spawn_ball that spawns a ball in the middle of the table and assigns the ball a fixed velocity (for now). Ignore the parameterdirection at this point.
  3. Add a call tospawn_ball in the functionnew_gamewhich starts a game of Pong. Note that the program template also includes an initial call to new_gamein the main body of your program to get a game going immediately.    
  4. Modify your code such that the ball collides with and bounces off of the top and bottom walls. Experiment with different hard-coded initial velocities to test your code.
  5. Add randomization to the velocity inspawn_ball(direction)The velocity of the ball should be upwards and towards the right ifdirection == RIGHT and upwards and towards the left ifdirection == LEFT. The exact        values for the horizontal and vertical components of this velocity should be generated usingrandom.randrange(). For the horizontal velocity, we suggest a speed of aroundrandom.randrange(120, 240)pixels per second. For        the vertical velocity, we suggest a speed of aroundrandom.randrange(60, 180)pixels per second. (You will need to set the signs of velocities appropriately.)
  6. Add code to the draw handler that tests whether the ball touches/collides with the left and right gutters. (Remember that the gutters are offset from the left and right edges of the canvas by the width of the paddle as described in the "Pong" video.)        When the ball touches a gutter, use either spawn_ball(LEFT) or spawn_ball(RIGHT) to respawn the ball in the center of the table headed towards the opposite gutter.    
  7. Next, add code that draws the left and right paddles in their respective gutters. The vertical positions of these two paddles should depend on two global variables. (In the template, the variables werepaddle1_posandpaddle2_pos.)
  8. Add code that modifies the values of these vertical positions via an update in the draw handler.  The update should reference two global variables that contain the vertical velocities of the paddles. (In the template, the variables werepaddle1_velandpaddle2_vel.)
  9. Update the values of these two vertical velocities using key handlers. The "w" and "s" keys should control the vertical velocity of the left paddle while the "Up arrow" and "Down arrow" key should control the velocity of the right paddle. In our version        of Pong, the left paddle moves up at a constant velocity if the "w" key is pressed and moves down at a constant velocity if the "s" is pressed and is motionless if neither is pressed. (The motion if both are pressed is up to you.) To achieve this        effect, you will need to use both a keydown and a keyup handler to increase/decrease the vertical velocity in an appropriate manner.
  10. Restrict your paddles to stay entirely on the canvas by adding a check before you update the paddles' vertical positions in the draw handler. In particular, test whether the current update for a paddle's position will move part of the paddle off of        the screen. If it does, don't allow the update.
  11. Modify your collision code for the left and right gutters in step 6 to check whether the ball is actually striking a paddle when it touches a gutter. If so, reflect the ball back into play. This collision model eliminates the possibility of the ball        striking the edge of the paddle and greatly simplifies your collision/reflection code.
  12. To moderately increase the difficulty of your game, increase the velocity of the ball by 10% each time it strikes a paddle.
  13. Add scoring to the game as shown in the Pong video lecture. Each time the ball strikes the left or right gutter (but not a paddle), the opposite player receives a point and ball is respawned appropriately.
  14. Finally, add code tonew_gamewhich resets the score before callingspawn_ball. Add a "Restart" button that callsnew_gameto reset the score and relaunch the ball.

Your final version of Pong should be remarkably similar to the original arcade Pong game. Our full implementation of Pong took a little more than 100 lines of code with comments.

# Implementation of classic arcade game Pong

import simplegui
import random

# initialize globals - pos and vel encode vertical info for paddles
WIDTH = 600
HEIGHT = 400       
BALL_RADIUS = 20
PAD_WIDTH = 8
PAD_HEIGHT = 80
HALF_PAD_WIDTH = PAD_WIDTH / 2
HALF_PAD_HEIGHT = PAD_HEIGHT / 2
LEFT = False
RIGHT = True

# initialize ball_pos and ball_vel for new bal in middle of table
# if direction is RIGHT, the ball's velocity is upper right, else upper left
def spawn_ball(direction):
    global ball_pos, ball_vel # these are vectors stored as lists
    ball_pos = [WIDTH/2, HEIGHT/2];  
    ball_vel = [random.randrange(120, 240), random.randrange(60, 180)]
    if (direction == LEFT):
        ball_vel[0] = -ball_vel[0]
        ball_vel[1] = -ball_vel[1]
    elif (direction == RIGHT):
        ball_vel[1] = -ball_vel[1]


# define event handlers
def new_game():
    global paddle1_pos, paddle2_pos, paddle1_vel, paddle2_vel  # these are numbers
    global score1, score2  # these are ints
    paddle1_pos = HEIGHT / 2
    paddle2_pos = HEIGHT / 2
    paddle1_vel = 0
    paddle2_vel = 0
    score1 = 0
    score2 = 0
    if score1 >= score2:
        spawn_ball(LEFT)
    else:
        spawn_ball(RIGHT)

def draw(canvas):
    global score1, score2, paddle1_pos, paddle2_pos, ball_pos, ball_vel
 
        
    # draw mid line and gutters
    canvas.draw_line([WIDTH / 2, 0],[WIDTH / 2, HEIGHT], 1, "White")
    canvas.draw_line([PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1, "White")
    canvas.draw_line([WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1, "White")
        
    # update ball
    # check up and down bound
    if (ball_pos[1] <= BALL_RADIUS) or (ball_pos[1] >= HEIGHT-BALL_RADIUS):  
        ball_vel[1] = -ball_vel[1]
    # check left and right  
    if ball_pos[0] <= BALL_RADIUS:  
        if paddle1_pos - HALF_PAD_HEIGHT <= ball_pos[1]<=paddle1_pos + HALF_PAD_HEIGHT:  
            ball_vel[0] = -ball_vel[0]  
            ball_vel[0] = ball_vel[0]*1.1  
            ball_vel[1] = ball_vel[1]*1.1  
        else:  
            spawn_ball(RIGHT)  
            score2 += 1  
    elif ball_pos[0] >= WIDTH-BALL_RADIUS:  
        if paddle2_pos - HALF_PAD_HEIGHT <= ball_pos[1] <= paddle2_pos + HALF_PAD_HEIGHT:  
            ball_vel[0] = -ball_vel[0]  
            ball_vel[0] = ball_vel[0]*1.1  
            ball_vel[1] = ball_vel[1]*1.1  
        else:  
            spawn_ball(LEFT)  
            score1 += 1
        
    ball_pos[0]+=ball_vel[0]/60  
    ball_pos[1]+=ball_vel[1]/60
            
    # draw ball
    canvas.draw_circle(ball_pos, 20, 1, "Green", "White")
    
    # update paddle's vertical position, keep paddle on the screen
    if HALF_PAD_HEIGHT <= paddle1_pos + paddle1_vel <= HEIGHT - HALF_PAD_HEIGHT:
        paddle1_pos += paddle1_vel  
    if HALF_PAD_HEIGHT <= paddle2_pos + paddle2_vel <= HEIGHT - HALF_PAD_HEIGHT:
        paddle2_pos += paddle2_vel
    
    # draw paddles
    canvas.draw_line([HALF_PAD_WIDTH, paddle1_pos + HALF_PAD_HEIGHT], 
                [HALF_PAD_WIDTH, paddle1_pos - HALF_PAD_HEIGHT], 
                PAD_WIDTH, "White")   
    canvas.draw_line([WIDTH - HALF_PAD_WIDTH, paddle2_pos + HALF_PAD_HEIGHT], 
                [WIDTH - HALF_PAD_WIDTH, paddle2_pos - HALF_PAD_HEIGHT], 
                PAD_WIDTH, "White")
    
    # draw scores
    canvas.draw_text(str(score1)+"  :  "+str(score2), 
                (WIDTH / 2 - 36, 40), 36, "Yellow")
        
def keydown(key):
    global paddle1_vel, paddle2_vel
    vel = 4
    if key == simplegui.KEY_MAP['s']:  
        paddle1_vel = vel  
    elif key == simplegui.KEY_MAP['w']:  
        paddle1_vel = -vel  
    elif key == simplegui.KEY_MAP['up']:  
        paddle2_vel = -vel  
    elif key == simplegui.KEY_MAP['down']:  
        paddle2_vel = vel 
   
def keyup(key):
    global paddle1_vel, paddle2_vel
    if key == simplegui.KEY_MAP['s']:  
        paddle1_vel = 0  
    elif key == simplegui.KEY_MAP['w']:  
        paddle1_vel = 0  
    elif key == simplegui.KEY_MAP['up']:  
        paddle2_vel = 0  
    elif key == simplegui.KEY_MAP['down']:  
        paddle2_vel = 0


# create frame
frame = simplegui.create_frame("Pong", WIDTH, HEIGHT)
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.add_button("Reset", new_game)


# start frame
new_game()
frame.start()



#http://www.codeskulptor.org/#user38_BNS4rw7yYa_0.py

 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部