Air Force School: Red Fields, Coimbatore - 18

AIR FORCE SCHOOL
Red fields, Coimbatore – 18
COMPUTER SCIENCE
Project report on
Submitted by UNDER THE GUIDANCE OF

Vignesh Mrs. Janani C
XI B PGT Computer Science Teacher
CERTIFICATE
This is to certify that VIGNESH of Class XII Air Force School Coimbatore has
done his/her project on under the guidance of Mrs. Janani C (PGT Computer
Science) during the academic year 2022-2023 in the partial fulfillment of AISSCE
Practical Examination conducted by CBSE.
Signature of Signature of
Internal Examiner External Examiner
Signature of
Principal
Date: _________________________
DECLARATION
I, VIGNESH, of Class XII Air Force School Coimbatore hereby declare

that the project entitled “SUPER MARIO” submitted to Mrs. Janani C
(PGTComputer Science) during the Academic Year 2022-2023, is a
Bonafide record work done by myself and team for the partial fulfilment
of AISSCE Practical Examination conducted by CBSE.
TEAM MEMBER NAMES

1. ROSHAN
2. SRIRAM
3. SHIVAN
4. KISHORE
Signature of the Candidate

TABLE OF CONTENTS
1. Introduction……………………………………………………………
Developing a game in python……………………………………
2. System requirement………………………………………………..
3. Modules imported…………………………………………………..
Pygame module……………………………………………………….
4. Source code…………………………………………………………….
5. Output……………………………………………………………………
6. Limitations……………………………………………………………..
7. Further study………………………………………………………….
8. Bibliography…………………………………………………………..
INTRODUCTION
DEVELOPING A GAME IN PYTHON

We firstly chose this project because we want to bring the
ancient 90's kids game which ruled all over the world.
We made this through python code and we completed with the
help of pygame.
This works with the help of python codes.
SOFTWARES REQUIREMENT
1) IDLE (Python 3.10 64-bit)

2) Pygame
3) Command prompt
MODULES IMPORTED
Syntax to import pre-defined modules

pip install <module_name>
a) Pygame
Pygame is a Python wrapper for the SDL library, which stands for Simple
Direct Media Layer. SDL provides cross-platform access to your system’s
underlying multimedia hardware components, such as sound, video,
mouse, keyboard, and joystick. pygame started life as a replacement for the
stalled PySDL project. The cross-platform nature of both SDL and pygame
means you can write games and rich multimedia Python programs for
every platform that supports them!
The pygame library is composed of a number of Python constructs, which

include several different modules. These modules provide abstract access
to specific hardware on your system, as well as uniform methods to work
with that hardware. For example, display allows uniform access to your
video display, while joystick allows abstract control of your joystick.
After importing the pygame library in the example above, the first thing
you did was initialize PyGame using pygame.init(). This function calls the
separate in it() functions of all the included pygame modules. Since these
modules are abstractions for specific hardware, this initialization step is
required so that you can work with the same code on Linux, Windows, and
Mac.
SOURCE CODE
import pygame
from pygame.locals import *
pygame.init()
screen_width = 1000
screen_height = 1000
screen = pygame.display.set_mode((screen_width, screen_height))

pygame.display.set_caption('Platformer')
#define game variables

tile_size = 200
#load images
sun_img = pygame.image.load('img/sun.png')
bg_img = pygame.image.load('img/sky.png')
def draw_grid():
for line in range(0, 20):
pygame.draw.line(screen, (255, 255, 255), (0, line * tile_size), (screen_width,
line * tile_size))
pygame.draw.line(screen, (255, 255, 255), (line * tile_size, 0), (line *
tile_size, screen_height))
class World():
def __init__(self, data):
self.tile_list = []
#load images
dirt_img = pygame.image.load('img/dirt.png')
grass_img = pygame.image.load('img/grass.png')
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
img = pygame.transform.scale(dirt_img, (tile_size,
tile_size))
img_rect = img.get_rect()
img_rect.x = col_count * tile_size
img_rect.y = row_count * tile_size
tile = (img, img_rect)
self.tile_list.append(tile)
if tile == 2:
img = pygame.transform.scale(grass_img, (tile_size,
tile_size))
col_count += 1
row_count += 1
def draw(self):
for tile in self.tile_list:
screen.blit(tile[0], tile[1])
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
world = World(world_data)
run = True
while run:
screen.blit(bg_img, (0, 0))

screen.blit(sun_img, (100, 100))
world.draw()
draw_grid()
for event in pygame.event.get():

if event.type == pygame.QUIT:
run = False
pygame.display.update()
pygame.quit()
import pygame
pygame.init()
screen_width = 1000


tile_size = 50
#load images
class Player():
def __init__(self, x, y):
img = pygame.image.load('img/guy1.png')
self.image = pygame.transform.scale(img, (40, 80))
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
def update(self):
dx = 0
dy = 0
#get keypresses
key = pygame.key.get_pressed()
if key[pygame.K_SPACE] and self.jumped == False:
self.vel_y = -15
self.jumped = True
if key[pygame.K_SPACE] == False:
self.jumped = False
if key[pygame.K_LEFT]:
dx -= 5
if key[pygame.K_RIGHT]:
dx += 5
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y
#check for collision
#update player coordinates

self.rect.x += dx
self.rect.y += dy
if self.rect.bottom > screen_height:

self.rect.bottom = screen_height
dy = 0
#draw player onto screen

screen.blit(self.image, self.rect)
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
col_count += 1
row_count += 1
def draw(self):
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
player = Player(100, screen_height - 130)

run = True
while run:

world.draw()
player.update()

run = False
pygame.quit()
import pygame
pygame.init()
clock = pygame.time.Clock()
fps = 60
screen_width = 1000


tile_size = 50
#load images
class Player():
self.images_right = []
self.images_left = []
self.index = 0
self.counter = 0
for num in range(1, 5):
img_right = pygame.image.load(f'img/guy{num}.png')
img_right = pygame.transform.scale(img_right, (40, 80))
img_left = pygame.transform.flip(img_right, True, False)
self.images_right.append(img_right)
self.images_left.append(img_left)
self.image = self.images_right[self.index]
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
def update(self):
dx = 0
dy = 0
walk_cooldown = 5
#get keypresses
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
if key[pygame.K_LEFT] == False and key[pygame.K_RIGHT] == False:
self.counter = 0
self.index = 0
if self.direction == 1:
if self.direction == -1:
self.image = self.images_left[self.index]
#handle animation
if self.counter > walk_cooldown:
self.counter = 0
self.index += 1
if self.index >= len(self.images_right):
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.rect.x += dx
self.rect.y += dy

dy = 0

class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
col_count += 1
row_count += 1
def draw(self):
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]

run = True
while run:
clock.tick(fps)

world.draw()
player.update()

run = False
pygame.quit()
import pygame
pygame.init()
fps = 60
screen_width = 1000


tile_size = 50
#load images
class Player():
self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.width = self.image.get_width()
self.height = self.image.get_height()
self.vel_y = 0
self.jumped = False
self.direction = 0
def update(self):
dx = 0
dy = 0
walk_cooldown = 5
#get keypresses
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

for tile in world.tile_list:
#check for collision in x direction
if tile[1].colliderect(self.rect.x + dx, self.rect.y, self.width, self.height):
dx = 0
#check for collision in y direction
if tile[1].colliderect(self.rect.x, self.rect.y + dy, self.width, self.height):
#check if below the ground i.e. jumping
if self.vel_y < 0:
dy = tile[1].bottom - self.rect.top
self.vel_y = 0
#check if above the ground i.e. falling
elif self.vel_y >= 0:
dy = tile[1].top - self.rect.bottom
self.vel_y = 0

self.rect.x += dx
self.rect.y += dy

dy = 0

pygame.draw.rect(screen, (255, 255, 255), self.rect, 2)
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
col_count += 1
row_count += 1
def draw(self):
pygame.draw.rect(screen, (255, 255, 255), tile[1], 2)
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]

run = True
while run:
clock.tick(fps)

world.draw()
player.update()

run = False
pygame.quit()
import pygame
pygame.init()
fps = 60
screen_width = 1000


tile_size = 50
#load images
class Player():
self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
def update(self):
dx = 0
dy = 0
walk_cooldown = 5
#get keypresses
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

if tile[1].colliderect(self.rect.x + dx, self.rect.y, self.width, self.height):
dx = 0
if tile[1].colliderect(self.rect.x, self.rect.y + dy, self.width, self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0

self.rect.x += dx
self.rect.y += dy

dy = 0

class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
blob = Enemy(col_count * tile_size, row_count *
tile_size + 15)
blob_group.add(blob)
col_count += 1
row_count += 1
def draw(self):
class Enemy(pygame.sprite.Sprite):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load('img/blob.png')
self.rect.x = x
self.rect.y = y
self.move_direction = 1
self.move_counter = 0
def update(self):
self.rect.x += self.move_direction
self.move_counter += 1
if abs(self.move_counter) > 50:
self.move_direction *= -1
self.move_counter *= -1
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
blob_group = pygame.sprite.Group()
run = True
while run:
clock.tick(fps)

world.draw()
blob_group.update()
blob_group.draw(screen)
player.update()

run = False
pygame.quit()
import pygame
pygame.init()
fps = 60
screen_width = 1000

tile_size = 50
game_over = 0
#load images
class Player():
self.index = 0
self.counter = 0
self.dead_image = pygame.image.load('img/ghost.png')
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
def update(self, game_over):

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
if key[pygame.K_LEFT] == False and key[pygame.K_RIGHT] ==
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

if tile[1].colliderect(self.rect.x + dx, self.rect.y, self.width,
self.height):
dx = 0
if tile[1].colliderect(self.rect.x, self.rect.y + dy, self.width,
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
#check for collision with enemies

if pygame.sprite.spritecollide(self, blob_group, False):
game_over = -1
#check for collision with lava
if pygame.sprite.spritecollide(self, lava_group, False):
game_over = -1

self.rect.x += dx
self.rect.y += dy
elif game_over == -1:

self.image = self.dead_image
if self.rect.y > 200:
self.rect.y -= 5

return game_over
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 6:
lava = Lava(col_count * tile_size, row_count *
tile_size + (tile_size // 2))
lava_group.add(lava)
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
class Lava(pygame.sprite.Sprite):
img = pygame.image.load('img/lava.png')
self.image = pygame.transform.scale(img, (tile_size, tile_size // 2))
self.rect.x = x
self.rect.y = y
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
lava_group = pygame.sprite.Group()
run = True
while run:
clock.tick(fps)

world.draw()
if game_over == 0:
blob_group.update()
lava_group.draw(screen)
game_over = player.update(game_over)

run = False
pygame.quit()
import pygame
pygame.init()
fps = 60
screen_width = 1000


tile_size = 50
game_over = 0
#load images
restart_img = pygame.image.load('img/restart_btn.png')
class Button():
def __init__(self, x, y, image):
self.image = image
self.rect.x = x
self.rect.y = y
self.clicked = False
def draw(self):
action = False
#get mouse position

pos = pygame.mouse.get_pos()
#check mouseover and clicked conditions

if self.rect.collidepoint(pos):
if pygame.mouse.get_pressed()[0] == 1 and self.clicked == False:
action = True
self.clicked = True
if pygame.mouse.get_pressed()[0] == 0:
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
if key[pygame.K_SPACE] and self.jumped == False and self.in_air
== False:
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1

game_over = -1

self.rect.x += dx
self.rect.y += dy

self.rect.y -= 5

return game_over
def reset(self, x, y):

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 6:
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
self.rect.x = x
self.rect.y = y
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
#create buttons
restart_button = Button(screen_width // 2 - 50, screen_height // 2 + 100, restart_img)
run = True
while run:
clock.tick(fps)

world.draw()
if game_over == 0:
blob_group.update()
#if player has died

if game_over == -1:
if restart_button.draw():
player.reset(100, screen_height - 130)
game_over = 0

run = False
pygame.quit()
import pygame
pygame.init()
fps = 60
screen_width = 1000


tile_size = 50
game_over = 0
main_menu = True
#load images
start_img = pygame.image.load('img/start_btn.png')
exit_img = pygame.image.load('img/exit_btn.png')
class Button():
self.image = image
self.rect.x = x
self.rect.y = y
def draw(self):
action = False
#get mouse position


action = True
self.clicked = True
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
== False:
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1

game_over = -1

self.rect.x += dx
self.rect.y += dy

self.rect.y -= 5
return game_over

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 6:
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
self.rect.x = x
self.rect.y = y
world_data = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1],
[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 7, 0, 5, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1],
[1, 7, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 7, 0, 0, 0, 0, 1],
[1, 0, 2, 0, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 2, 0, 0, 4, 0, 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 7, 0, 0, 0, 0, 2, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2, 2, 2, 2, 1],
[1, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]
#create buttons
start_button = Button(screen_width // 2 - 350, screen_height // 2, start_img)
exit_button = Button(screen_width // 2 + 150, screen_height // 2, exit_img)
run = True
while run:
clock.tick(fps)

if main_menu == True:
if exit_button.draw():
run = False
if start_button.draw():
main_menu = False
else:
world.draw()
if game_over == 0:
blob_group.update()
#if player has died

if game_over == -1:
game_over = 0

run = False
pygame.quit()
import pygame
import pickle
from os import path
pygame.init()
fps = 60
screen_width = 1000


tile_size = 50
game_over = 0
main_menu = True
level = 0
max_levels = 7
#load images
#function to reset level

def reset_level(level):
blob_group.empty()
lava_group.empty()
exit_group.empty()
#load in level data and create world

if path.exists(f'level{level}_data'):
pickle_in = open(f'level{level}_data', 'rb')
world_data = pickle.load(pickle_in)
return world
class Button():
self.image = image
self.rect.x = x
self.rect.y = y
def draw(self):
action = False
#get mouse position


action = True
self.clicked = True
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
== False:
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y
self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1

game_over = -1
#check for collision with exit

if pygame.sprite.spritecollide(self, exit_group, False):
game_over = 1

self.rect.x += dx
self.rect.y += dy

self.rect.y -= 5

return game_over

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 6:
if tile == 8:
exit = Exit(col_count * tile_size, row_count *
tile_size - (tile_size // 2))
exit_group.add(exit)
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
self.rect.x = x
self.rect.y = y
class Exit(pygame.sprite.Sprite):
img = pygame.image.load('img/exit.png')
self.image = pygame.transform.scale(img, (tile_size, int(tile_size * 1.5)))
self.rect.x = x
self.rect.y = y
exit_group = pygame.sprite.Group()

#create buttons
run = True
while run:
clock.tick(fps)

run = False
main_menu = False
else:
world.draw()
if game_over == 0:
blob_group.update()
exit_group.draw(screen)
#if player has died
if game_over == -1:
world_data = []
world = reset_level(level)
game_over = 0
#if player has completed the level

if game_over == 1:
#reset game and go to next level
level += 1
if level <= max_levels:
#reset level
world_data = []
game_over = 0
else:
level = 1
#reset level
world_data = []
game_over = 0

run = False
pygame.quit()
import pygame
import pickle
from os import path
pygame.init()
fps = 60
screen_width = 1000

#define font
font = pygame.font.SysFont('Bauhaus 93', 70)
font_score = pygame.font.SysFont('Bauhaus 93', 30)
tile_size = 50
game_over = 0
main_menu = True
level = 0
max_levels = 7
score = 0
#define colours
white = (255, 255, 255)
blue = (0, 0, 255)
#load images
def draw_text(text, font, text_col, x, y):

img = font.render(text, True, text_col)
screen.blit(img, (x, y))

blob_group.empty()
lava_group.empty()
exit_group.empty()

return world
class Button():
self.image = image
self.rect.x = x
self.rect.y = y
def draw(self):
action = False
#get mouse position


action = True
self.clicked = True
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
== False:
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1

game_over = -1
game_over = 1

self.rect.x += dx
self.rect.y += dy

draw_text('GAME OVER!', font, blue, (screen_width // 2) - 200,
screen_height // 2)
self.rect.y -= 5

return game_over

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 6:
if tile == 7:
coin = Coin(col_count * tile_size + (tile_size // 2),
row_count * tile_size + (tile_size // 2))
coin_group.add(coin)
if tile == 8:
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
self.rect.x = x
self.rect.y = y
class Coin(pygame.sprite.Sprite):
img = pygame.image.load('img/coin.png')
self.image = pygame.transform.scale(img, (tile_size // 2, tile_size // 2))
self.rect.center = (x, y)
self.rect.x = x
self.rect.y = y
coin_group = pygame.sprite.Group()
#create dummy coin for showing the score
score_coin = Coin(tile_size // 2, tile_size // 2)
coin_group.add(score_coin)

#create buttons
run = True
while run:
clock.tick(fps)

run = False
main_menu = False
else:
world.draw()
if game_over == 0:
blob_group.update()
#update score
#check if a coin has been collected
if pygame.sprite.spritecollide(player, coin_group, True):
score += 1
draw_text('X ' + str(score), font_score, white, tile_size - 10, 10)
coin_group.draw(screen)
#if player has died

if game_over == -1:
world_data = []
game_over = 0
score = 0

if game_over == 1:
level += 1
#reset level
world_data = []
game_over = 0
else:
draw_text('YOU WIN!', font, blue, (screen_width // 2) - 140,
screen_height // 2)
level = 1
#reset level
world_data = []
game_over = 0
score = 0

run = False
pygame.quit()
import pygame
from pygame import mixer
import pickle
from os import path
pygame.mixer.pre_init(44100, -16, 2, 512)

mixer.init()
pygame.init()
fps = 60
screen_width = 1000

#define font

tile_size = 50
game_over = 0
main_menu = True
level = 0
max_levels = 7
score = 0
#define colours
white = (255, 255, 255)
blue = (0, 0, 255)
#load images
#load sounds
pygame.mixer.music.load('img/music.wav')
pygame.mixer.music.play(-1, 0.0, 5000)
coin_fx = pygame.mixer.Sound('img/coin.wav')
coin_fx.set_volume(0.5)
jump_fx = pygame.mixer.Sound('img/jump.wav')
jump_fx.set_volume(0.5)
game_over_fx = pygame.mixer.Sound('img/game_over.wav')
game_over_fx.set_volume(0.5)


blob_group.empty()
lava_group.empty()
exit_group.empty()

return world
class Button():
self.image = image
self.rect.x = x
self.rect.y = y
def draw(self):
action = False
#get mouse position


action = True
self.clicked = True
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
== False:
jump_fx.play()
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1
game_over_fx.play()

game_over = -1
game_over_fx.play()

game_over = 1

self.rect.x += dx
self.rect.y += dy

screen_height // 2)
self.rect.y -= 5

return game_over

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 6:
if tile == 7:
if tile == 8:
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
self.rect.x = x
self.rect.y = y
self.rect.x = x
self.rect.y = y


#create buttons
run = True
while run:
clock.tick(fps)

run = False
main_menu = False
else:
world.draw()
if game_over == 0:
blob_group.update()
#update score
score += 1
coin_fx.play()
#if player has died

if game_over == -1:
world_data = []
game_over = 0
score = 0

if game_over == 1:
level += 1
#reset level
world_data = []
game_over = 0
else:
screen_height // 2)
level = 1
#reset level
world_data = []
game_over = 0
score = 0

run = False
pygame.quit()
import pygame
import pickle
from os import path

mixer.init()
pygame.init()
fps = 60
screen_width = 1000

#define font

tile_size = 50
game_over = 0
main_menu = True
level = 3
max_levels = 7
score = 0
#define colours
white = (255, 255, 255)
blue = (0, 0, 255)
#load images
#load sounds
#pygame.mixer.music.load('img/music.wav')
#pygame.mixer.music.play(-1, 0.0, 5000)

blob_group.empty()
lava_group.empty()
exit_group.empty()

return world
class Button():
self.image = image
self.rect.x = x
self.rect.y = y
def draw(self):
action = False
#get mouse position


action = True
self.clicked = True
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
if game_over == 0:
#get keypresses
== False:
jump_fx.play()
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1
game_over_fx.play()

game_over = -1
game_over_fx.play()

game_over = 1

self.rect.x += dx
self.rect.y += dy

screen_height // 2)
self.rect.y -= 5

return game_over

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 4:
platform = Platform(col_count * tile_size,
row_count * tile_size, 1, 0)
platform_group.add(platform)
if tile == 5:
if tile == 6:
if tile == 7:
if tile == 8:
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
class Platform(pygame.sprite.Sprite):
def __init__(self, x, y, move_x, move_y):
img = pygame.image.load('img/platform.png')
self.rect.x = x
self.rect.y = y
self.move_x = move_x
self.move_y = move_y
def update(self):
self.rect.x += self.move_direction * self.move_x
self.rect.y += self.move_direction * self.move_y
self.rect.x = x
self.rect.y = y
self.rect.x = x
self.rect.y = y
platform_group = pygame.sprite.Group()


#create buttons
run = True
while run:
clock.tick(fps)

run = False
main_menu = False
else:
world.draw()
if game_over == 0:
blob_group.update()
platform_group.update()
#update score
score += 1
coin_fx.play()
platform_group.draw(screen)
#if player has died

if game_over == -1:
world_data = []
game_over = 0
score = 0

if game_over == 1:
level += 1
#reset level
world_data = []
game_over = 0
else:
screen_height // 2)
level = 1
#reset level
world_data = []
game_over = 0
score = 0

run = False
pygame.quit()
import pygame
import pickle
from os import path

mixer.init()
pygame.init()
fps = 60
screen_width = 1000

#define font

tile_size = 50
game_over = 0
main_menu = True
level = 3
max_levels = 7
score = 0
#define colours
white = (255, 255, 255)
blue = (0, 0, 255)
#load images
#load sounds
pygame.mixer.music.load('img/music.wav')
pygame.mixer.music.play(-1, 0.0, 5000)

blob_group.empty()
platform_group.empty()
coin_group.empty()
lava_group.empty()
exit_group.empty()

return world
class Button():
self.image = image
self.rect.x = x
self.rect.y = y
def draw(self):
action = False
#get mouse position


action = True
self.clicked = True
#draw button
return action
class Player():
self.reset(x, y)

dx = 0
dy = 0
walk_cooldown = 5
col_thresh = 20
if game_over == 0:
#get keypresses
== False:
jump_fx.play()
self.vel_y = -15
self.jumped = True
self.jumped = False
dx -= 5
self.counter += 1
self.direction = -1
dx += 5
self.counter += 1
self.direction = 1
False:
self.counter = 0
self.index = 0
#handle animation
self.counter = 0
self.index += 1
self.index = 0
#add gravity
self.vel_y += 1
if self.vel_y > 10:
self.vel_y = 10
dy += self.vel_y

self.in_air = True
self.height):
dx = 0
self.height):
if self.vel_y < 0:
self.vel_y = 0
self.vel_y = 0
self.in_air = False

game_over = -1
game_over_fx.play()

game_over = -1
game_over_fx.play()

game_over = 1
#check for collision with platforms

for platform in platform_group:
#collision in the x direction
if platform.rect.colliderect(self.rect.x + dx, self.rect.y,
self.width, self.height):
dx = 0
#collision in the y direction
if platform.rect.colliderect(self.rect.x, self.rect.y + dy,
self.width, self.height):
#check if below platform
if abs((self.rect.top + dy) - platform.rect.bottom) <
col_thresh:
self.vel_y = 0
dy = platform.rect.bottom - self.rect.top
#check if above platform
elif abs((self.rect.bottom + dy) - platform.rect.top) <
col_thresh:
self.rect.bottom = platform.rect.top - 1
self.in_air = False
dy = 0
#move sideways with the platform
if platform.move_x != 0:
self.rect.x += platform.move_direction

self.rect.x += dx
self.rect.y += dy

screen_height // 2)
self.rect.y -= 5

return game_over

self.index = 0
self.counter = 0
self.rect.x = x
self.rect.y = y
self.vel_y = 0
self.jumped = False
self.direction = 0
self.in_air = True
class World():
self.tile_list = []
#load images
row_count = 0
for row in data:
col_count = 0
for tile in row:
if tile == 1:
tile_size))
if tile == 2:
tile_size))
if tile == 3:
tile_size + 15)
if tile == 4:
if tile == 5:
if tile == 6:
if tile == 7:
if tile == 8:
col_count += 1
row_count += 1
def draw(self):
self.rect.x = x
self.rect.y = y
def update(self):
class Platform(pygame.sprite.Sprite):
def __init__(self, x, y, move_x, move_y):
img = pygame.image.load('img/platform.png')
self.rect.x = x
self.rect.y = y
self.move_x = move_x
self.move_y = move_y
def update(self):
self.rect.x += self.move_direction * self.move_x
self.rect.y += self.move_direction * self.move_y
self.rect.x = x
self.rect.y = y
self.rect.x = x
self.rect.y = y
platform_group = pygame.sprite.Group()


#create buttons
run = True
while run:
clock.tick(fps)

run = False
main_menu = False
else:
world.draw()
if game_over == 0:
blob_group.update()
platform_group.update()
#update score
score += 1
coin_fx.play()
platform_group.draw(screen)
#if player has died

if game_over == -1:
world_data = []
game_over = 0
score = 0

if game_over == 1:
level += 1
#reset level
world_data = []
game_over = 0
else:
screen_height // 2)
level = 1
#reset level
world_data = []
game_over = 0
score = 0

run = False
pygame.quit()
OUTPUT
LIMITATIONS
We made this game in such a way that it's very much

tough to complete the first level. This is a limitation for
the players.
Only 7 levels may be it ends soon.
It is bit lagging.
FURTHER STUDY
We need to develop this game with

o More levels.
o Exciting events.
o Different locations.
o Different challenges.
Customizing Mario according to the consumer wish.
BIBLIOGRAPHY
1. http://codingwithruss.com/gamepage/Platformer
2. https://github.com/russs123/Platformer

Air Force School: Red Fields, Coimbatore - 18

Uploaded by

Copyright:

Available Formats

Air Force School: Red Fields, Coimbatore - 18

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Air Force School: Red Fields, Coimbatore - 18

Uploaded by

Copyright:

Available Formats

AIR FORCE SCHOOL

Red fields, Coimbatore – 18

Submitted by UNDER THE GUIDANCE OF

I, VIGNESH, of Class XII Air Force School Coimbatore hereby declare

TEAM MEMBER NAMES

Signature of the Candidate

DEVELOPING A GAME IN PYTHON

1) IDLE (Python 3.10 64-bit)

Syntax to import pre-defined modules

The pygame library is composed of a number of Python constructs, which

screen = pygame.display.set_mode((screen_width, screen_height))

#define game variables

screen.blit(bg_img, (0, 0))

for event in pygame.event.get():

screen = pygame.display.set_mode((screen_width, screen_height))

#define game variables

#check for collision

#update player coordinates

if self.rect.bottom > screen_height:

#draw player onto screen

player = Player(100, screen_height - 130)

screen.blit(bg_img, (0, 0))

for event in pygame.event.get():

screen = pygame.display.set_mode((screen_width, screen_height))

#define game variables

#check for collision

#update player coordinates

if self.rect.bottom > screen_height:

#draw player onto screen

player = Player(100, screen_height - 130)

screen.blit(bg_img, (0, 0))

for event in pygame.event.get():

screen = pygame.display.set_mode((screen_width, screen_height))

#define game variables

#check for collision

#update player coordinates

if self.rect.bottom > screen_height:

#draw player onto screen

player = Player(100, screen_height - 130)

screen.blit(bg_img, (0, 0))

for event in pygame.event.get():

screen = pygame.display.set_mode((screen_width, screen_height))

#define game variables

#check for collision

#update player coordinates

if self.rect.bottom > screen_height:

#draw player onto screen

player = Player(100, screen_height - 130)

screen.blit(bg_img, (0, 0))

for event in pygame.event.get():

screen = pygame.display.set_mode((screen_width, screen_height))

def update(self, game_over):

#check for collision

#check for collision with enemies

#update player coordinates

elif game_over == -1:

#draw player onto screen

player = Player(100, screen_height - 130)