CODING

Pygame

Pygame is a Python library specifically designed to facilitate game development. While

Python itself is a general-purpose language, Pygame provides modules that allow
programmers to handle graphics, sound, and user input more efficiently. Through it, one can
create 2D games such as Pong or Tic-Tac-Toe, as well as basic 3D simulations like
wireframe cubes or fidget cube visualisations.

Over the last three years of programming, I have developed a variety of projects using Python
and Pygame. These experiences not only improved my understanding of Python syntax but
also taught me how to apply mathematical concepts (such as trigonometric functions) to solve
practical coding problems. A personal priority in my work is to write clear, well-structured
code that can be easily read and understood by others, even after I have moved on from the
project. This reflects an industry best practice often referred to as readability and
maintainability.

Challenges and Learning

One of the greatest challenges I faced was the hardware limitation of my laptop, which is
significantly outdated. Its slow processing speed forced me to learn how to optimise code for
efficiency rather than rely on hardware power. For example, I reduced the number of
calculations performed per frame, avoided redundant function calls, and simplified
mathematical operations wherever possible.

This limitation shaped my coding habits positively. Instead of brute-force solutions, I had to
adopt strategies closer to professional practices in computational optimisation, where
efficiency is critical for performance (particularly in mobile or embedded devices).

My most ambitious project was an attempted 4D tesseract simulation, which aimed to

visualise higher-dimensional objects. Unfortunately, due to the strain on my laptop’s
processor, the project caused repeated crashes and eventually had to be abandoned. Despite
this, it provided valuable lessons in resource management and highlighted the trade-offs
between computational ambition and hardware constraints.

The Role of Coding in Game Development

Coding underpins every aspect of game development. It controls the visual rendering of
objects, the responsiveness of the game to user input, and the internal logic governing physics
and interactions. Simple games like Pong or Tic-Tac-Toe provide accessible introductions to
key programming constructs such as loops, conditionals, and variables.

While many developers today rely on high-level engines such as Unity or Unreal Engine,
which automate significant portions of the development process, learning to code directly
allows for greater customisation and deeper technical understanding. Pygame, for instance,
does not abstract away the mathematics of projection or collision detection — the
programmer must implement them manually. This makes it a powerful learning tool even if it
is not as commercially scalable as professional engines.

The challenge, however, lies in optimisation. Unlike Unity or Unreal, which manage
rendering pipelines and physics simulations internally, Pygame requires the programmer to
manage these processes directly. This is both a limitation and a strength: while it restricts the
scope of what can realistically be built, it also encourages a much deeper appreciation of the
mechanics of computer graphics.

Research Focus

For this stage of my research, I concentrated on evaluating Pygame’s efficiency as a tool for
prototyping games and compared it against other libraries that meet the following conditions:

1. Free to use (so it is accessible to a wide audience).

2. Compatible with Python.
3. Supports a 2D interface for programming.
4. Integrates well with other packages.

The only notable competitor to Pygame within these conditions is Tkinter, Python’s standard
GUI library. Tkinter, however, is primarily intended for building user interfaces, not games.
It lacks the advanced rendering functions of Pygame and is restricted mainly to drawing basic
geometric shapes (e.g., lines and rectangles). While technically capable of producing simple
visualisations, its reliance on direct line rendering is more computationally expensive than
Pygame’s mask-based rendering, where only the necessary surfaces are drawn.

Therefore, while Tkinter remains useful for prototyping GUI-based applications, Pygame
offers broader scope for graphics-intensive projects such as animations, simulations, and
simple games.

Practical Project: A Rotating 3D Cube

To explore the mechanics of Pygame further, I developed a project simulating a rotating 3D

cube. This program demonstrates how mathematical concepts like trigonometry and
projection can be applied to create the illusion of three dimensions on a two-dimensional
screen.

import pygame

import math

[Link]()

# Screen setup

width, height = 800, 600

screen = [Link].set_mode((width, height))

[Link].set_caption("3D Cube")

# Colours

WHITE, BLACK = (255, 255, 255), (0, 0, 0)

# Cube vertices and edges

vertices = [(-1, -1, -1), (1, -1, -1), (1, 1, -1), (-1, 1, -1),

(-1, -1, 1), (1, -1, 1), (1, 1, 1), (-1, 1, 1)]
edges = [(0, 1), (1, 2), (2, 3), (3, 0),

(4, 5), (5, 6), (6, 7), (7, 4),

(0, 4), (1, 5), (2, 6), (3, 7)]

# Projection function

def project_3d_to_2d(x, y, z, angle_x, angle_y, distance):

x_rot = x * [Link](angle_y) - z * [Link](angle_y)

z_rot = x * [Link](angle_y) + z * [Link](angle_y)

y_rot = y * [Link](angle_x) - z_rot * [Link](angle_x)

z_rot = y * [Link](angle_x) + z_rot * [Link](angle_x)

fov = 200

factor = fov / (z_rot + distance)

return int(x_rot * factor + width // 2), int(y_rot * factor + height // 2)

# Main loop

running, angle_x, angle_y, distance = True, 0, 0, 4

clock = [Link]()

while running:

for event in [Link]():

if [Link] == [Link]:

running = False

[Link](BLACK)

angle_x, angle_y = angle_x + 0.01, angle_y + 0.01

points = [project_3d_to_2d(x, y, z, angle_x, angle_y, distance) for x, y, z

in vertices]

for edge in edges:

[Link](screen, WHITE, points[edge[0]], points[edge[1]], 2)

[Link]()
 [Link](60)

[Link]()

Code Breakdown
 Importing libraries:

pygame handles graphics and input, while math provides trigonometric functions.

 Initialisation:

[Link]() prepares the library, similar to starting an engine before driving.

 Vertices and edges:

The cube is defined by eight vertices (3D coordinates) and twelve edges connecting
them. Each frame, these coordinates are rotated and projected into 2D space.

 Projection function:

This applies rotation matrices around the X and Y axes, followed by perspective
projection to simulate depth. This reflects a simplified version of the rendering
pipeline used in modern 3D engines.

 Main loop:

Handles user input (such as quitting), clears the screen, updates rotation angles,
projects vertices, and redraws the cube. The cube rotates continuously around both
axes, creating an animated wireframe effect.

Reflection

This project illustrates how Pygame can be used to replicate fundamental graphics concepts,
albeit at a much simpler level than professional engines. Writing such code from scratch
reinforces an understanding of how transformations and projections underpin 3D graphics.
While Unity or Unreal automatically manage these processes, implementing them directly in
Python has given me a clearer appreciation of the underlying mathematics.
The exercise also highlighted Pygame’s limitations. While sufficient for lightweight
prototypes, its lack of native 3D support and limited performance scalability make it
unsuitable for larger, more advanced projects. Nonetheless, as an educational tool, it remains
highly valuable, particularly when paired with deliberate code optimisation strategies.