Merge pull request #1279 from siddharth2016/add-pongpong

Add pongpong, a game made using pyglet

Author: geekcomputers

PongPong_Game/README.md

@@ -0,0 +1,39 @@
+# PongPong
+
+Are you just starting your Game Development journey ?
+
+Do you want to learn something new ?
+
+PongPong, a game that every developer should try their hands on !
+
+I really enjoyed making this game when I went ahead and completed a task from Zero To Mastery Academy monthly challenge.
+
+It was super fun learning something new, the basics of game development and how to view a game as just like a geometry plane to work with, was simply mind blowing for me.
+
+I chose pyglet for development work, motivation behind this was to completely learn something new and not to work with the good old pygame !
+
+Go through the following parts to get familiar with pyglet game development style:
+
+1. [Making PONGPONG - Game Development using Pyglet - Part 1](https://blog.codekaro.info/making-pongpong-game-development-using-pyglet-part-1)
+2. [Making PONGPONG - Game Development using Pyglet - Part 2](https://blog.codekaro.info/making-pongpong-game-development-using-pyglet-part-2)
+3. [Making PONGPONG - Game Development using Pyglet - Part 3](https://blog.codekaro.info/making-pongpong-game-development-using-pyglet-part-3)
+
+I really loved writing my experience and how I approached the problem, hoping you will find it insightful, will learn something new and get to know basics of developing a game like PongPong.
+
+---
+
+Library used:
+
+**pyglet**
+
+Install to your virtual environment or global using pip:
+
+*pip install pyglet*
+
+Game Play Demo on MacOS:
+
+![Game_play on mac](pong_game_play.gif)
+
+---
+
+*Actual game was developed using Pygame shown in a youtube tutorial and can be found at [Pong, Python & Pygame](https://www.youtube.com/watch?v=JRLdbt7vK-E)*

PongPong_Game/pong/__init__.py

@@ -0,0 +1 @@
+

PongPong_Game/pong/ball.py

@@ -0,0 +1,29 @@
+# ./PongPong/pong/ball.py
+
+import pyglet
+import random
+from typing import Tuple
+
+
+class BallObject(pyglet.shapes.Circle):
+
+    def __init__(self, *args, **kwargs):
+        super(BallObject, self).__init__(*args, **kwargs)
+        self.color = (255, 180, 0)
+        self.velocity_x, self.velocity_y = 0.0, 0.0
+
+    def update(self, win_size: Tuple, border: Tuple, other_object, dt) -> None:
+        speed = [2.37, 2.49, 2.54, 2.62, 2.71, 2.85, 2.96, 3.08, 3.17, 3.25]    # more choices more randomness
+        rn = random.choice(speed)
+        newx = self.x + self.velocity_x
+        newy = self.y + self.velocity_y
+
+        if newx < border + self.radius or newx > win_size[0] - border - self.radius:
+            self.velocity_x = -(self.velocity_x/abs(self.velocity_x))*rn
+        elif newy > win_size[1] - border - self.radius:
+            self.velocity_y = -(self.velocity_y/abs(self.velocity_y))*rn
+        elif (newy-self.radius < other_object.height) and (other_object.x <= newx <= other_object.rightx):
+            self.velocity_y = -(self.velocity_y/abs(self.velocity_y))*rn
+        else:
+            self.x = newx
+            self.y = newy

PongPong_Game/pong/load.py

@@ -0,0 +1,31 @@
+# ./PongPong/pong/load.py
+
+from . import ball, paddle, rectangle
+from typing import Tuple
+
+def load_balls(win_size : Tuple, radius : float, speed : Tuple, batch=None):
+    balls = []
+    ball_x = win_size[0]/2
+    ball_y = win_size[1]/2
+    new_ball = ball.BallObject(x=ball_x, y=ball_y, radius=radius, batch=batch)
+    new_ball.velocity_x, new_ball.velocity_y = speed[0], speed[1]
+    balls.append(new_ball)
+    return balls
+
+
+def load_paddles(paddle_pos : Tuple, width : float, height : float, acc : Tuple, batch=None):
+    paddles = []
+    new_paddle = paddle.Paddle(x=paddle_pos[0], y=paddle_pos[1], width=width, height=height, batch=batch)
+    new_paddle.rightx = new_paddle.x + width
+    new_paddle.acc_left, new_paddle.acc_right = acc[0], acc[1]
+    paddles.append(new_paddle)
+    return paddles
+
+
+def load_rectangles(win_size : Tuple, border : float, batch=None):
+    rectangles = []
+    top = rectangle.RectangleObject(x=0, y=win_size[1]-border, width=win_size[0], height=border, batch=batch)
+    left = rectangle.RectangleObject(x=0, y=0, width=border, height=win_size[1], batch=batch)
+    right = rectangle.RectangleObject(x=win_size[0] - border, y=0, width=border, height=win_size[1], batch=batch)
+    rectangles.extend([left, top, right])
+    return rectangles

PongPong_Game/pong/paddle.py

@@ -0,0 +1,35 @@
+# ./PongPong/pong/paddle.py
+
+import pyglet
+from pyglet.window import key
+from typing import Tuple
+
+
+class Paddle(pyglet.shapes.Rectangle):
+
+    def __init__(self, *args, **kwargs):
+        super(Paddle, self).__init__(*args, **kwargs)
+
+        self.acc_left, self.acc_right = 0.0, 0.0
+        self.rightx = 0
+        self.key_handler = key.KeyStateHandler()
+        self.event_handlers = [self, self.key_handler]
+
+    def update(self, win_size : Tuple, border : float, other_object, dt):
+
+        newlx = self.x + self.acc_left
+        newrx = self.x + self.acc_right
+
+        if self.key_handler[key.LEFT]:
+            self.x = newlx
+        elif self.key_handler[key.RIGHT]:
+            self.x = newrx
+
+        self.rightx = self.x + self.width
+
+        if self.x < border:
+            self.x = border
+            self.rightx = self.x + self.width
+        elif self.rightx > win_size[0]-border:
+            self.x = win_size[0]-border-self.width
+            self.rightx = self.x + self.width

PongPong_Game/pong/rectangle.py

@@ -0,0 +1,8 @@
+# ./PongPong/pong/rectangle.py
+
+import pyglet
+
+class RectangleObject(pyglet.shapes.Rectangle):
+
+    def __init__(self, *args, **kwargs):
+        super(RectangleObject, self).__init__(*args, **kwargs)

PongPong_Game/pong_game_play.gif

@@ -0,0 +1,54 @@
+# ./PongPong/pongpong.py
+
+import pyglet
+from pong import load
+
+# Variables, Considering a vertical oriented window for game
+WIDTH = 600   # Game Window Width
+HEIGHT = 600  # Game Window Height
+BORDER = 10   # Walls Thickness/Border Thickness
+RADIUS = 12   # Ball Radius
+PWIDTH = 120  # Paddle Width
+PHEIGHT = 15  # Paddle Height
+ballspeed = (-2, -2)    # Initially ball will be falling with speed (x, y)
+paddleacc = (-5, 5)   # Paddle Acceleration on both sides - left: negative acc, right: positive acc, for x-axis
+
+
+class PongPongWindow(pyglet.window.Window):
+    def __init__(self, *args, **kwargs):
+        super(PongPongWindow, self).__init__(*args, **kwargs)
+
+        self.win_size = (WIDTH, HEIGHT)
+        self.paddle_pos = (WIDTH/2-PWIDTH/2, 0)
+        self.main_batch = pyglet.graphics.Batch()
+        self.walls = load.load_rectangles(self.win_size, BORDER, batch=self.main_batch)
+        self.balls = load.load_balls(self.win_size, RADIUS, speed=ballspeed, batch=self.main_batch)
+        self.paddles = load.load_paddles(self.paddle_pos, PWIDTH, PHEIGHT, acc=paddleacc, batch=self.main_batch)
+
+    def on_draw(self):
+        self.clear()
+        self.main_batch.draw()
+
+
+game_window = PongPongWindow(width=WIDTH, height=HEIGHT, caption='PongPong')
+game_objects = game_window.balls + game_window.paddles
+
+for paddle in game_window.paddles:
+    for handler in paddle.event_handlers:
+        game_window.push_handlers(handler)
+
+
+
+def update(dt):
+    global game_objects, game_window
+
+    for obj1 in game_objects:
+        for obj2 in game_objects:
+            if obj1 is obj2:
+                continue
+            obj1.update(game_window.win_size, BORDER, obj2, dt)
+
+
+if __name__ == '__main__':
+    pyglet.clock.schedule_interval(update, 1/120.0)
+    pyglet.app.run()

PongPong_Game/pongpong.py

@@ -0,0 +1 @@
+pyglet==1.5.14