Pong Game Development – Pushp Gupta

1. State the Problem (16 marks)

1.1 Initial Concepts
Idea: The game developed is Pong, a classic arcade game that involves two
players controlling paddles to prevent the ball from passing. The game is simple,
fast-paced, and offers engaging competition for two players.
Name: "Pong Challenge"
Purpose: The game aims to recreate the traditional Pong experience in a modern
Python-based environment. The purpose is to entertain users with a nostalgic
game that is easy to play but can be quite challenging as players progress.
Type of App: The app is a game designed for entertainment and fun. It can be
classified as a sports game as it mimics the concept of a competitive sport (Ping
Pong).
Target Audience: The game is targeted towards casual gamers and retro gaming
enthusiasts. It is suitable for people of all ages who enjoy simple, competitive
games. The target age range could vary from 10 years to adults who enjoy quick
gaming sessions.
Needs of the User: The user needs a game that provides fun, competitive
gameplay. They should be able to easily understand the rules and play without
excessive setup. The game should be accessible on all platforms where Python
and Pygame are supported, including PC, Mac, and Linux.
Licensing: The game can be released under an open-source license, such as the
MIT License, which allows users to freely use, modify, and distribute the game.
This is ideal because it promotes community development and sharing of the
game.
1.2 Analysis of Similar Apps
Sample 1: Pong by Atari: This is the original Pong game, which started the arcade
revolution. It involves two paddles, and the objective is to prevent the ball from
passing your paddle. It's a simple, two-player game with no additional features.
Similarities: The game is essentially the same; the concept, paddle movement,
and ball bounce dynamics are similar.
Differences: Modern Pong games may include power-ups or different game
modes, which this implementation does not have.
Sample 2: 2D Pong Game (HTML5/JavaScript): Various online versions of Pong are
available using HTML5 and JavaScript. These versions typically have minimal
controls and may allow customization of paddle size and ball speed.
Similarities: The core game dynamics are identical.
Differences: Online versions often include competitive elements like
leaderboards or multiplayer over the internet, which our version doesn’t support.
Sample 3: Pong Quest (by Atari): A more modern take on the classic Pong game
that includes adventure and RPG elements, where players can unlock new
paddles and challenge various opponents.
Similarities: Basic Pong mechanics and gameplay.
Differences: Our Pong game is much simpler and lacks any added features like a
storyline, upgrades, or RPG elements.
1.3 Resources
Programming Language: Python with Pygame library. Python is an excellent
choice for rapid game development due to its simplicity, readability, and strong
community support. Pygame provides the necessary modules for handling game
development, including graphics, input events, and sound.
Equipment: A computer with Python and Pygame installed. Any modern PC or
Mac would suffice.
Skills and Expertise: Basic knowledge of Python programming, game mechanics,
object-oriented programming, and Pygame.
Testing Tools: Manual testing and user feedback to ensure the game works on
multiple platforms (Windows, Mac, Linux). You can use Pygame's built-in tools for
debugging.
1.4 Licensing Requirements
Main Types of Software Licenses:
Proprietary License: The software is owned by the developer and users must pay
to access it, with restrictions on copying, modifying, or redistributing the
software.
Open Source License: The software is made available for free, and users can
modify and distribute the code. Examples include the MIT License, GPL (General
Public License), and Apache License.
Shareware License: Users can access a limited version of the software for free
but must pay for the full version or additional features.
License Selection: For this Pong game, the MIT License is a suitable choice. It is a
permissive open-source license that allows users to freely modify, distribute, and
use the software for both personal and commercial purposes. This ensures the
game can be freely shared and built upon by the community, which aligns with
the project's goal of promoting simplicity and accessibility.
2. Plan and Design (20 marks)
2.1 Screen Layouts, Sketches, Colour Scheme, Graphics, User Interface
Screen Layout: The game screen is divided into three sections:
The top contains the score.
The middle is the game area where the paddles and ball move.
The bottom area shows the border where the paddles cannot go beyond.
Colour Scheme:
Background: Black ((0, 0, 0)).
Paddles: White ((255, 255, 255)).
Ball: White ((255, 255, 255)).
Score Text: White ((255, 255, 255)).
Graphics: Simple, pixel-based graphics with rectangular paddles and a circular
ball.
User Interface:
The game will display the current score at the top of the screen.
Players can use the keyboard (W, S for left paddle, Up/Down for right paddle).
The game area will show a divider line in the middle.
2.2 Algorithm, Flowchart, and Pseudocode
Flowchart:
Start → Initialize Game → Draw Elements (paddles, ball, score) → Player Input
(paddle movement) → Ball Movement → Check Collisions (with walls and paddles)
→ Update Score (if ball passes a paddle) → Repeat until quit.
Pseudocode:
Copy code
Start Game:
Initialize paddles, ball, and scores
While game is running:
Get player inputs
Move paddles based on inputs
Move ball in direction
Check for wall collision (reverse vertical direction)
Check for paddle collision (reverse horizontal direction)
If ball goes out of bounds, update score
Draw paddles, ball, and score
End Game
3. Develop
Below is the code:
import pygame
import sys
# Initialize Pygame
pygame.init()
# Set up the screen
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pong Game")
# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
# Paddle settings
PADDLE_WIDTH = 15
PADDLE_HEIGHT = 100
PADDLE_SPEED = 10
# Ball settings
BALL_SIZE = 20
BALL_SPEED_X = 5
BALL_SPEED_Y = 5
# Initialize paddles and ball
paddle_left = pygame.Rect(30, HEIGHT // 2 - PADDLE_HEIGHT // 2,
PADDLE_WIDTH, PADDLE_HEIGHT)
paddle_right = pygame.Rect(WIDTH - 30 - PADDLE_WIDTH, HEIGHT // 2 -
PADDLE_HEIGHT // 2, PADDLE_WIDTH, PADDLE_HEIGHT)
ball = pygame.Rect(WIDTH // 2 - BALL_SIZE // 2, HEIGHT // 2 - BALL_SIZE // 2,
BALL_SIZE, BALL_SIZE)
# Game variables
left_score = 0
right_score = 0
# Font for score
font = pygame.font.Font(None, 36)
# Function to reset ball to center
def reset_ball():
global BALL_SPEED_X, BALL_SPEED_Y
ball.center = (WIDTH // 2, HEIGHT // 2)
BALL_SPEED_X *= -1 # Change ball direction
BALL_SPEED_Y *= (-1 if BALL_SPEED_Y > 0 else 1) # Keep the vertical speed
direction same
# Game loop
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Get the keys being pressed
keys = pygame.key.get_pressed()
# Paddle movement for left paddle (W and S)
if keys[pygame.K_w] and paddle_left.top > 0:
paddle_left.y -= PADDLE_SPEED
if keys[pygame.K_s] and paddle_left.bottom < HEIGHT:
 paddle_left.y += PADDLE_SPEED
# Paddle movement for right paddle (Up and Down arrows)
if keys[pygame.K_UP] and paddle_right.top > 0:
paddle_right.y -= PADDLE_SPEED
if keys[pygame.K_DOWN] and paddle_right.bottom < HEIGHT:
paddle_right.y += PADDLE_SPEED
# Move the ball
ball.x += BALL_SPEED_X
ball.y += BALL_SPEED_Y
# Ball collision with top and bottom walls
if ball.top <= 0 or ball.bottom >= HEIGHT:
BALL_SPEED_Y *= -1
# Ball collision with paddles
if ball.colliderect(paddle_left) or ball.colliderect(paddle_right):
BALL_SPEED_X *= -1
# Ball out of bounds, score point
if ball.left <= 0:
right_score += 1
reset_ball()
if ball.right >= WIDTH:
left_score += 1
reset_ball()
# Drawing everything
screen.fill(BLACK)
# Draw paddles
pygame.draw.rect(screen, WHITE, paddle_left)
pygame.draw.rect(screen, WHITE, paddle_right)
# Draw ball
pygame.draw.ellipse(screen, WHITE, ball)
# Draw the center line
pygame.draw.line(screen, WHITE, (WIDTH // 2, 0), (WIDTH // 2, HEIGHT), 5)
# Draw the scores
 score_text = font.render(f"{left_score} - {right_score}", True, WHITE)
screen.blit(score_text, (WIDTH // 2 - score_text.get_width() // 2, 10))
pygame.display.flip()
pygame.time.Clock().tick(60)
5. Test
Trace table is below: