API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 30th, 2016
126
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 10.30 KB | None | 0 0
raw download clone embed print report
  1. import pygame
  2. import random
  3. import sys
  4.  
  5. SCREEN_SIZE = SCREEN_WIDTH, SCREEN_HEIGHT = 640, 480
  6. BLACK = (0, 0, 0)
  7. WHITE = (255, 255, 255)
  8. RED = (255, 0, 0)
  9.  
  10.  
  11. class PongGame():
  12.     def __init__(self):
  13.         self.screen = pygame.display.set_mode(SCREEN_SIZE)
  14.         pygame.display.set_caption('Pong')
  15.  
  16.         self.FPS = 60
  17.         self.fps_clock = pygame.time.Clock()
  18.  
  19.         self.background = pygame.Surface(self.screen.get_size())
  20.         self.background.fill(BLACK)
  21.  
  22.         self.main_menu = MyGameMenu()
  23.         self.main_menu.add_option("Start")
  24.         self.main_menu.add_option("Quit")
  25.  
  26.         self.pause_menu = MyGameMenu()
  27.         self.pause_menu.add_option("Continue")
  28.         self.pause_menu.add_option("Main menu")
  29.  
  30.         self.paddle_img = pygame.image.load("paddle.png").convert()
  31.         self.ball_img = pygame.image.load("ball.png").convert()
  32.         self.border_img = pygame.image.load('strips.png').convert_alpha()
  33.  
  34.         self.score1 = 0
  35.         self.score2 = 0
  36.  
  37.         self.player1 = None
  38.         self.player2 = None
  39.         self.ball = None
  40.  
  41.         self.showing_main_menu = True
  42.         self.playing = False
  43.         self.paused = False
  44.  
  45.     def start(self):
  46.         self.paused = False
  47.         self.playing = True
  48.  
  49.         self.score1 = 0
  50.         self.score2 = 0
  51.  
  52.         self.player1 = Paddle(self.screen, self.paddle_img, 60, SCREEN_HEIGHT/2, 0, 350)
  53.         self.player2 = Paddle(self.screen, self.paddle_img, SCREEN_WIDTH - 80, SCREEN_HEIGHT/2, 0, 350)
  54.  
  55.         self.ball = Ball(self.screen, self.ball_img, SCREEN_WIDTH/2, SCREEN_HEIGHT/2, 250, 250)
  56.         self.ball.stuck = True
  57.  
  58.         self.game_objects = [self.player1, self.player2, self.ball]
  59.  
  60.     def check_intersection(self, rect1, rect2):
  61.         return rect1.x + rect1.w > rect2.x \
  62.                and rect1.x < rect2.x + rect2.w \
  63.                and rect1.y + rect1.h > rect2.y \
  64.                and rect1.y < rect2.y + rect2.h
  65.  
  66.     def get_intersection_rect(self, rect1, rect2):
  67.         x_min, x_max, y_min, y_max = 0, 0, 0, 0
  68.  
  69.         if rect1.x > rect2.x:
  70.             x_min = rect1.x
  71.         else:
  72.             x_min = rect2.x
  73.  
  74.         if rect1.x + rect1.w < rect2.x + rect2.w:
  75.             x_max = rect1.x + rect1.w
  76.         else:
  77.             x_max = rect2.x + rect2.w
  78.  
  79.         if rect1.y > rect2.y:
  80.             y_min = rect1.y
  81.         else:
  82.             y_min = rect2.y
  83.  
  84.         if rect1.y + rect1.h < rect2.y + rect2.h:
  85.             y_max = rect1.y + rect1.h
  86.         else:
  87.             y_max = rect2.y + rect2.h
  88.  
  89.         width = x_max - x_min
  90.         height = y_max - y_min
  91.  
  92.         return x_min, y_min, width, height
  93.  
  94.     def handle_collision(self, obj1, obj2):
  95.         rect1 = obj1.rect
  96.         rect2 = obj2.rect
  97.  
  98.         if not self.check_intersection(rect1, rect2):
  99.             return
  100.  
  101.         rect = pygame.Rect(self.get_intersection_rect(rect1, rect2))
  102.  
  103.         if rect.w > rect.h:
  104.             if rect1.y < rect2.y:
  105.                 obj2.rect.y += rect.h
  106.             else:
  107.                 obj2.rect.y -= rect.h
  108.  
  109.             obj2.dy = -obj2.dy
  110.         else:
  111.             if rect1.x < rect2.x:
  112.                 obj2.rect.x += rect.w
  113.             else:
  114.                 obj2.rect.x -= rect.w
  115.  
  116.             obj2.dx = -obj2.dx
  117.  
  118.     def main_loop(self):
  119.         fps_clock = pygame.time.Clock()
  120.  
  121.         while True:
  122.             dt = fps_clock.tick(self.FPS) / 1000.0
  123.  
  124.             for event in pygame.event.get():
  125.                 if event.type == pygame.QUIT:
  126.                     return
  127.                 elif event.type == pygame.KEYDOWN:
  128.                     if event.key == pygame.K_ESCAPE:
  129.                         if self.showing_main_menu:
  130.                             return
  131.                         elif self.paused:
  132.                             self.paused = False
  133.                             self.playing = True
  134.                         elif self.playing:
  135.                             self.playing = False
  136.                             self.paused = True
  137.                     elif event.key == pygame.K_SPACE:
  138.                         if self.playing:
  139.                             if self.ball.stuck:
  140.                                 self.ball.dx *= random.choice([-1, 1])
  141.                                 self.ball.dy *= random.choice([-1, 1])
  142.                                 self.ball.stuck = not self.ball.stuck
  143.                         elif self.showing_main_menu:
  144.                             if self.main_menu.option_idx == 0:
  145.                                 self.showing_main_menu = False
  146.                                 self.start()
  147.                             elif self.main_menu.option_idx == 1:
  148.                                 return
  149.                         elif self.paused:
  150.                             if self.pause_menu.option_idx == 0:
  151.                                 self.paused = False
  152.                                 self.playing = True
  153.                             elif self.pause_menu.option_idx == 1:
  154.                                 self.paused = False
  155.                                 self.playing = False
  156.                                 self.showing_main_menu = True
  157.                     elif event.key == pygame.K_DOWN:
  158.                         if self.showing_main_menu:
  159.                             self.main_menu.move_up()
  160.                         elif self.paused:
  161.                             self.pause_menu.move_up()
  162.                     elif event.key == pygame.K_UP:
  163.                         if self.showing_main_menu:
  164.                             self.main_menu.move_down()
  165.                         elif self.paused:
  166.                             self.pause_menu.move_down()
  167.  
  168.             if self.playing:
  169.                 keys = pygame.key.get_pressed()
  170.                 if keys[pygame.K_UP]:
  171.                     self.player1.rect.y += -self.player1.dy * dt
  172.                 if keys[pygame.K_DOWN]:
  173.                     self.player1.rect.y += self.player1.dy * dt
  174.  
  175.                 if keys[pygame.K_w]:
  176.                     self.player2.rect.y += -self.player1.dy * dt
  177.                 if keys[pygame.K_s]:
  178.                     self.player2.rect.y += self.player1.dy * dt
  179.  
  180.                 if self.ball.rect.x < 0:
  181.                     self.score2 += 1
  182.                 elif self.ball.rect.x + self.ball.rect.w > SCREEN_WIDTH:
  183.                     self.score1 += 1
  184.  
  185.                 for obj in self.game_objects:
  186.                     obj.update(dt)
  187.  
  188.                 self.handle_collision(self.player1, self.ball)
  189.                 self.handle_collision(self.player2, self.ball)
  190.  
  191.                 self.screen.blit(self.background, (0, 0))
  192.                 self.screen.blit(self.player1.img, self.player1.rect)
  193.                 self.screen.blit(self.player2.img, self.player2.rect)
  194.                 self.screen.blit(self.ball.img, self.ball.rect)
  195.                 self.screen.blit(draw_text(str(self.score1), 'notalot35.ttf', WHITE, 72), (200, 50))
  196.                 self.screen.blit(draw_text(str(self.score2), 'notalot35.ttf', (255, 255, 255), 72), (SCREEN_WIDTH - 200, 50))
  197.                 self.screen.blit(self.border_img, (SCREEN_WIDTH/2, 10))
  198.             elif self.paused:
  199.                 self.screen.blit(self.background, (0, 0))
  200.                 self.screen.blit(draw_text("PAUSED", "notalot35.ttf", WHITE, 72), (SCREEN_WIDTH/2 - 80, 40))
  201.                 self.pause_menu.display(self.screen)
  202.             elif self.showing_main_menu:
  203.                 self.screen.blit(self.background, (0, 0))
  204.                 title_surf = draw_text("PONG GAME ver 0.1", "notalot35.ttf", WHITE, 72)
  205.                 self.screen.blit(title_surf, (SCREEN_WIDTH/2 - title_surf.get_rect().w/2, 40 - title_surf.get_rect().h/2))
  206.                 self.main_menu.display(self.screen)
  207.  
  208.             pygame.display.flip()
  209.  
  210.  
  211. def draw_text(message, font_name, color, size):
  212.     font = pygame.font.Font(font_name, size)
  213.     text = font.render(message, False, color)
  214.     text = text.convert_alpha()
  215.     return text
  216.  
  217.  
  218. class GameObject():
  219.     def __init__(self, screen, img, x, y, dx, dy):
  220.         self.screen = screen
  221.         self.img = img
  222.         self.dx = dx
  223.         self.dy = dy
  224.         self.rect = img.get_rect()
  225.         self.rect.x = x
  226.         self.rect.y = y
  227.  
  228.     def update(self, dt): pass
  229.  
  230.  
  231. class Ball(GameObject):
  232.     def __init__(self, screen, img, x, y, dx, dy):
  233.         GameObject.__init__(self, screen, img, x, y, dx, dy)
  234.         self.stuck = True
  235.  
  236.     def update(self, dt):
  237.         if self.stuck:
  238.             return
  239.  
  240.         if self.rect.x < 0 or self.rect.x + self.rect.w > self.screen.get_width():
  241.             self.rect.x, self.rect.y = self.screen.get_width()/2, self.screen.get_height()/2
  242.             self.stuck = True
  243.             return
  244.  
  245.         if self.rect.y < 0:
  246.             self.rect.y = 0
  247.             self.dy *= -1
  248.         elif self.rect.y + self.rect.h > self.screen.get_height():
  249.             self.rect.y = self.screen.get_height() - self.rect.h
  250.             self.dy *= -1
  251.  
  252.         self.rect.x += self.dx * dt
  253.         self.rect.y += self.dy * dt
  254.  
  255.  
  256. class Paddle(GameObject):
  257.     def __init__(self, screen, img, x, y, dx, dy):
  258.         GameObject.__init__(self, screen, img, x, y, dx, dy)
  259.  
  260.     def update(self, dt):
  261.         if self.rect.y < 0:
  262.             self.rect.y = 0
  263.         elif self.rect.y + self.rect.h > SCREEN_HEIGHT:
  264.             self.rect.y = SCREEN_HEIGHT - self.rect.h
  265.  
  266.  
  267. class MyGameMenu():
  268.     def __init__(self):
  269.         self.options = []
  270.         self.option_idx = -1
  271.  
  272.     def add_option(self, text):
  273.         if not len(self.options):
  274.             self.option_idx = 0
  275.         self.options.append(text)
  276.  
  277.     def move_up(self):
  278.         if self.option_idx < len(self.options) - 1:
  279.             self.option_idx += 1
  280.  
  281.     def move_down(self):
  282.         if self.option_idx > 0:
  283.             self.option_idx -= 1
  284.  
  285.     def display(self, screen):
  286.         for i, option in enumerate(self.options):
  287.             clr = WHITE
  288.             if i == self.option_idx:
  289.                 clr = RED
  290.  
  291.             text_surf = draw_text(str(option), 'notalot35.ttf', clr, 72)
  292.             screen.blit(text_surf, (screen.get_width()/2 - text_surf.get_rect().w/2,
  293.                                     screen.get_height()/2 - text_surf.get_rect().h/2 + i*72 - 40))
  294.  
  295.  
  296. def main():
  297.     pygame.init()
  298.  
  299.     PongGame().main_loop()
  300.  
  301.     pygame.quit()
  302.     sys.exit()
  303.  
  304. if __name__ == '__main__':
  305.     main()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!