Welcome back to this new pygame project. In this chapter we will win and get to the next level of the game, if we lose then we will return to the beginning of that level. In the previous chapter, we have passed the game manager object to the boy sprite object so that boy sprite object can use that game manager to reset the game when it is game over or to increase the game level when that player had won the game. In this chapter, we will use the level manager object to replace the game manager object so the boy sprite object will directly call the level manager to reset the game or to increase the level of the game accordingly. In order to use this system, we will need to edit a few files. The first one is the game manager class where we will pass in the level manager to the boy sprite object.
from EnemyManager import EnemyManager
from Overlap import Overlap
from ExplosionManager import ExplosionManager
from Score import Score
from StartScene import StartScene
from pygame.locals import *
from LevelManager import LevelManager
import pygame
import webbrowser
from Scene import Scene
from BackGroundSprite import BackGroundSprite
from BoySprite import BoySprite
from ManaManager import ManaManager
class GameManager(object):
def __init__(self, scene):
self.scene = scene
self.load_music()
self.play_music()
self.overlap_manager = Overlap()
self.level_manager = LevelManager(self)
self.level_manager.set_level()
self.setup(self.level_manager.get_level())
self.start_scene = StartScene(scene, self.level_manager)
self.pause = False # flag to pause the game
self.game_scene = Scene(self.scene)
#game state
self.LOAD = 0
self.GAME = 1
self.OVER = 2
self.NEXT = 3
self.WIN = 4
self.ABOUT = 5
self.MANUAL = 6
self.PAUSE = 7
self.SCORE = 8
self.SCENE = 9
self.state = self.LOAD
def setup(self, game_level):
self.game_level = game_level
self.score_manager = Score(self.scene, self.level_manager)
self.background = BackGroundSprite(game_level, self.scene)
self.enemy_manager = EnemyManager(self.scene, game_level)
self.mana_manager = ManaManager(self.scene, game_level)
self.boy_sprite = BoySprite(self.scene, game_level, self.enemy_manager, self.mana_manager, self.level_manager)
self.explosion_manager = ExplosionManager(self.scene)
def loop(self):
if(self.state == self.LOAD):
self.start_scene.draw(self.state)
elif(self.state == self.OVER or self.state == self.NEXT or self.state == self.WIN or self.state == self.ABOUT or self.state == self.MANUAL or self.state == self.SCORE):
self.start_scene.draw(self.state)
elif(self.state == self.SCENE):
self.game_scene.draw()
elif(self.state == self.GAME):
self.update()
self.draw()
elif(self.state == self.PAUSE):
self.start_scene.draw(self.state)
def isAreaClick(self, x, y):
if (self.state == self.LOAD or self.state == self.OVER or self.state == self.NEXT or self.state == self.WIN or self.state == self.ABOUT or self.state == self.SCORE or self.state == self.SCENE or self.state == self.MANUAL or self.state == self.PAUSE):
self.rect = Rect(177, 274, 306, 112) # the position of the play button on the scene
self.rect_play = Rect(229, 200, 200, 53) # the position of the play button on the home scene
self.rect_about = Rect(229, 263, 200, 53) # the position of the about button on the home scene
#self.rect_exit = Rect(229, 456, 200, 53) # the position of the exit button on the home scene
self.rect_pause_home = Rect(229, 263, 200, 53) # the position of the home button on pause scene
self.rect_score = Rect(229, 328, 200, 53) # the position of the score button on the home scene
self.rect_manual = Rect(229, 393, 200, 53) # the position of the manual button on the home scene
self.rect_scene = Rect(229, 519, 200, 53) # the position of the manual button on the home scene
self.rect_back = Rect(10, 620, 40, 30) # the position of the back button on the home scene
self.rect_sound = Rect(10, 600, 30, 30) # the position of the sound button on the home scene
self.rect_scene_next = Rect(610, 330, 30, 30) # the position of the next scene button on scene
self.rect_scene_previous = Rect(50, 330, 30, 30) # the position of the previous scene button on scene
if(self.rect.collidepoint(x, y) and (self.state == self.OVER or self.state == self.NEXT or self.state == self.WIN)):
self.state = self.GAME
elif(self.rect_play.collidepoint(x,y) and self.state == self.LOAD):
self.state = self.GAME
elif (self.rect_play.collidepoint(x, y) and self.state == self.PAUSE):
self.state = self.GAME
elif (self.rect_about.collidepoint(x, y) and self.state == self.LOAD):
self.state = self.ABOUT
elif (self.rect_score.collidepoint(x, y) and self.state == self.LOAD):
self.state = self.SCORE
elif (self.rect_scene.collidepoint(x, y) and self.state == self.LOAD):
self.state = self.SCENE
elif (self.rect_back.collidepoint(x, y) and self.state == self.SCENE):
self.state = self.LOAD
elif (self.rect_scene_next.collidepoint(x, y) and self.state == self.SCENE):
self.game_scene.set_next_image()
elif (self.rect_scene_previous.collidepoint(x, y) and self.state == self.SCENE):
self.game_scene.set_previous_image()
elif (self.rect_pause_home.collidepoint(x, y) and self.state == self.PAUSE):
self.state = self.LOAD
self.setup(self.level_manager.get_level())
self.save_level()
elif (self.rect_manual.collidepoint(x, y) and self.state == self.LOAD):
webbrowser.open_new('http://gamingdirectional.com/blog/2018/12/25/air-strike//')
elif (self.rect_back.collidepoint(x, y) and (self.state == self.ABOUT or self.state == self.MANUAL or self.state == self.SCORE)):
self.state = self.LOAD
elif (self.rect_sound.collidepoint(x, y) and self.state == self.LOAD):
if(self.start_scene.soundon == True):
self.start_scene.soundon = False
pygame.mixer_music.pause()
else:
self.start_scene.soundon = True
pygame.mixer_music.unpause()
def save_level(self):
self.level_manager.save_level()
def set_pause(self, pause):
self.pause = pause
if(self.pause == True):
self.state = self.PAUSE
def load_music(self):
pygame.mixer_music.load('Music/winternight.ogg')
def play_music(self):
pygame.mixer_music.play(-1) #play the music infinite time
def set_player_x(self, _x):
if (self.state == self.GAME):
self.boy_sprite.setX(_x)
def save_scene(self):
self.game_scene.take_screen()
def set_player_y(self, _y):
if (self.state == self.GAME):
self.boy_sprite.setY(_y)
def update(self):
self.enemy_manager.update()
self.mana_manager.update()
self.boy_sprite.update()
def draw(self):
if(self.state == self.GAME):
self.background.draw()
#self.score_manager.draw()
self.boy_sprite.draw()
self.enemy_manager.draw()
self.mana_manager.draw()
pygame.display.flip()
The next few files we are going to edit are the boy object, mana object, background object and the enemy object class where we will include the level 2 location data and the items data to each of them. In this example, we will use back the level 1 data just to demonstrate the level up process!
class BoyObject(object):
def __init__(self):
self.list_1 = [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
self.ladder_boundary_1 = [[9 * 64, 8 * 64],
[9 * 64, 7 * 64],
[5 * 64, 6 * 64],
[5 * 64, 5 * 64],
[2 * 64, 3 * 64],
[2 * 64, 4 * 64],
[0 * 64, 1 * 64],
[0 * 64, 2 * 64],
] # the boundary of the ladder
self.boundary_bottom_1 = [[9 * 64, 9 * 64],
[5 * 64, 7 * 64],
[2 * 64, 5 * 64],
[0 * 64, 3 * 64]] # the bottom boundary of the ladder
self.boundary_side_1 = [[4 * 64, 6 * 64],
[1 * 64, 4 * 64],
[6 * 64, 2 * 64], ] # the side boundary of the player
self.boundary_door_1 = [[9 * 64, 0]]
self.initial_1 = [0, 8 * 64]
self.list_2 = [
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
self.ladder_boundary_2 = [[9 * 64, 8 * 64],
[9 * 64, 7 * 64],
[5 * 64, 6 * 64],
[5 * 64, 5 * 64],
[2 * 64, 3 * 64],
[2 * 64, 4 * 64],
[0 * 64, 1 * 64],
[0 * 64, 2 * 64],
] # the boundary of the ladder
self.boundary_bottom_2 = [[9 * 64, 9 * 64],
[5 * 64, 7 * 64],
[2 * 64, 5 * 64],
[0 * 64, 3 * 64]] # the bottom boundary of the ladder
self.boundary_side_2 = [[4 * 64, 6 * 64],
[1 * 64, 4 * 64],
[6 * 64, 2 * 64], ] # the side boundary of the player
self.boundary_door_2 = [[9 * 64, 0]]
self.initial_2 = [0, 8 * 64]
def get_original_position(self, level):
if (level == 1):
return self.initial_1
elif (level == 2):
return self.initial_2
def get_object_list(self, level):
if(level == 1):
return self.list_1
elif (level == 2):
return self.list_2
def get_object_boundary(self, level):
if (level == 1):
return self.ladder_boundary_1
elif (level == 2):
return self.ladder_boundary_2
def get_object_bottom_boundary(self, level):
if (level == 1):
return self.boundary_bottom_1
elif (level == 2):
return self.boundary_bottom_2
def get_object_side_boundary(self, level):
if (level == 1):
return self.boundary_side_1
elif (level == 2):
return self.boundary_side_2
def get_object_door_boundary(self, level):
if(level == 1):
return self.boundary_door_1
elif (level == 2):
return self.boundary_door_2
class BgObject(object):
def __init__(self):
self.list_1 = [
[3, 3, 3, 3, 3, 3, 3, 3, 3, 2],
[4, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[4, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[0, 0, 4, 0, 0, 0, 3, 3, 3, 3],
[3, 3, 4, 3, 3, 3, 3, 3, 3, 3],
[0, 0, 0, 0, 1, 4, 1, 0, 0, 1],
[3, 3, 3, 3, 3, 4, 3, 3, 3, 3],
[3, 3, 3, 3, 3, 1, 1, 0, 0, 4],
[3, 3, 3, 3, 3, 3, 3, 3, 3, 4],
[0, 1, 0, 0, 1, 1, 0, 1, 1, 0]
]
self.list_2 = [
[3, 3, 3, 3, 3, 3, 3, 3, 3, 2],
[4, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[4, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[0, 0, 4, 0, 0, 0, 3, 3, 3, 3],
[3, 3, 4, 3, 3, 3, 3, 3, 3, 3],
[0, 0, 0, 0, 1, 4, 1, 0, 0, 1],
[3, 3, 3, 3, 3, 4, 3, 3, 3, 3],
[3, 3, 3, 3, 3, 1, 1, 0, 0, 4],
[3, 3, 3, 3, 3, 3, 3, 3, 3, 4],
[0, 1, 0, 0, 1, 1, 0, 1, 1, 0]
]
def get_object_list(self, level):
if(level == 1):
return self.list_1
elif(level == 2):
return self.list_2
class EnemyObject(object):
def __init__(self):
self.list_1 = [
[0, 1, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
self.boundary_1 = [
[[0, 0], [8 * 64, 0]],
[[0, 0], [8 * 64, 0]],
[[2 * 64, 4 * 64], [8 * 64, 4 * 64]],
[[2 * 64, 4 * 64], [8 * 64, 4 * 64]],
[[5 * 64, 6 * 64], [8 * 64, 6 * 64]]
]
self.initial_1 = [[64, 0], [5 * 64, 0],[4 * 64, 4 * 64], [8 * 64, 4 * 64],[6 * 64, 6 * 64]]
self.list_2 = [
[0, 1, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
self.boundary_2 = [
[[0, 0], [8 * 64, 0]],
[[0, 0], [8 * 64, 0]],
[[2 * 64, 4 * 64], [8 * 64, 4 * 64]],
[[2 * 64, 4 * 64], [8 * 64, 4 * 64]],
[[5 * 64, 6 * 64], [8 * 64, 6 * 64]]
]
self.initial_2 = [[64, 0], [5 * 64, 0], [4 * 64, 4 * 64], [8 * 64, 4 * 64], [6 * 64, 6 * 64]]
def get_original_position(self, level):
if (level == 1):
return self.initial_1
elif (level == 2):
return self.initial_2
def get_object_list(self, level):
if(level == 1):
return self.list_1
elif (level == 2):
return self.list_2
def get_object_boundary(self, level):
if (level == 1):
return self.boundary_1
elif (level == 2):
return self.boundary_2
class ManaObject(object):
def __init__(self):
self.list_1 = [
[1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
self.initial_1 = [[3 * 64, 8 * 64], [6 * 64, 6 * 64],[0 * 64, 0 * 64], [1 * 64, 0 * 64]]
self.list_2 = [
[1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
]
self.initial_2 = [[3 * 64, 8 * 64], [6 * 64, 6 * 64], [0 * 64, 0 * 64], [1 * 64, 0 * 64]]
def get_original_position(self, level):
if (level == 1):
return self.initial_1
elif (level == 2):
return self.initial_2
def get_object_list(self, level):
if(level == 1):
return self.list_1
elif (level == 2):
return self.list_2
Anther three files we need to edit are the boy sprite class, enemy sprite class and the mana sprite class. In the boy sprite class, we will either reset the game if it is game over or increase the level if the player had won the game. In both the mana and the enemy sprite class we will create the object list for the level 2 stage.
from BoyObject import BoyObject
from pygame import math as mt
from pygame.locals import *
from GameSprite import GameSprite
class BoySprite(object):
def __init__(self, scene, level, enemy_manager, mana_manager, level_manager):
self.row = 10
self.column = 10
self.scene = scene # game scene instance
self.space = 64 # image width and height
self.level = level # current game level
self.enemy_manager = enemy_manager # the reference of enemy manager
self.mana_manager = mana_manager # the reference of mana manager
self.WIDTH = 640
self.level_manager = level_manager
self.prepare_boy(self.level)
def prepare_boy(self, level):
self.boy_object = BoyObject()
self.boy_object_list = self.boy_object.get_object_list(level)
self.boy_original_position = self.boy_object.get_original_position(level)
self.x = self.boy_original_position[0]
self.y = self.boy_original_position[1]
self.speed = 2
self.boy_image_sprite_right = 'Asset/bright.png'
self.boy_image_sprite_left = 'Asset/bleft.png'
self.boy_sprite = self.boy_image_sprite_right
self.frame = 3
self.up = False
self.ladder = False
self.left = False
self.boy_rect = Rect(self.frame * 64, 0, 64, 64)
self.sprite_boy = GameSprite(self.boy_sprite, self.boy_rect)
self.boy_surface = self.sprite_boy.getImage()
self.boy_ladder_list = self.boy_object.get_object_boundary(level)
self.boy_bottom_boundary_list = self.boy_object.get_object_bottom_boundary(level)
self.boy_side_boundary_list = self.boy_object.get_object_side_boundary(level)
self.boy_door_boundary_list = self.boy_object.get_object_door_boundary(level)
self.enemy_list = self.enemy_manager.get_enemy_list()
self.mana_list = self.mana_manager.get_mana_list()
self.life = 1
self.initialize()
# set the x and the y direction for the player object
def setX(self, x):
if(self.ladder == True):
return
self.x += x
if (self.up == True and x < 0):
self.frame = 1
self.up = False
elif(self.up == True and x > 0):
self.frame = 0
self.up = False
if(x < 0):
self.left = True
self.frame += 1
if (self.frame > 5):
self.frame = 1
self.boy_sprite = self.boy_image_sprite_left
elif(x > 0):
self.frame += 1
self.left = False
if (self.frame > 4):
self.frame = 0
self.boy_sprite = self.boy_image_sprite_right
elif(x == 0):
if(self.left == True):
self.frame = 2
self.boy_sprite = self.boy_image_sprite_left
elif(self.left == False):
self.frame = 3
self.boy_sprite = self.boy_image_sprite_right
self.boy_rect = Rect(self.frame * 64, 0, 64, 64)
self.sprite_boy = GameSprite(self.boy_sprite, self.boy_rect)
self.boy_surface = self.sprite_boy.getImage()
def setY(self, y):
self.boy_rect = Rect(self.x, self.y+y, 64, 64)
if(self.isUpDown(self.boy_rect, y) == True):
self.y += y
if(y == 0):
self.frame = 9
elif(self.up == False):
self.frame = 6
self.up = True
else:
if(y < 0):
self.frame -= 1
elif(y > 0):
self.frame += 1
if(self.frame > 10):
self.frame = 6
elif(self.frame < 6):
self.frame += 2
self.boy_sprite = self.boy_image_sprite_right
self.boy_rect = Rect(self.frame * 64, 0, 64, 64)
self.sprite_boy = GameSprite(self.boy_sprite, self.boy_rect)
self.boy_surface = self.sprite_boy.getImage()
def checkboundary(self):
if(self.x < 0):
self.x = 0
elif(self.x > self.WIDTH - self.space):
self.x = self.WIDTH - self.space
else:
self.isLeftRight()
def isUpDown(self, rect, y):
for boundary in self.boy_ladder_list:
boundary_rect = Rect(boundary[0], boundary[1], 64, 64)
if ((boundary_rect.collidepoint(self.x, self.y+y) == True or boundary_rect.collidepoint(self.x, self.y+self.space+y) == True) and (self.x % self.space == 0)):
for boundary_bottom in self.boy_bottom_boundary_list:
boundary_rect = Rect(boundary_bottom[0], boundary_bottom[1], 64, 64)
if (boundary_rect.colliderect(rect) == True):
self.ladder = False
return False
self.ladder = True
return True
self.ladder = False
return False
def isLeftRight(self):
for boundary in self.boy_side_boundary_list:
boundary_rect = Rect(boundary[0], boundary[1], 64, 64)
boy_rect = Rect(self.x, self.y, 64, 64)
if (boundary_rect.colliderect(boy_rect) == True):
if(self.left == True):
self.x += self.speed
else:
self.x -= self.speed
def update(self):
self.checkboundary()
self.check_mana_collide()
self.check_collide()
self.check_win()
self.move_boy()
def check_win(self):
for door in self.boy_door_boundary_list:
if(door[0] == self.x and door[1] == self.y):
self.level_manager.increase_level()
def check_collide(self):
for enemy in self.enemy_list:
enemy_rect = Rect(enemy.x, enemy.y, 64, 64)
boy_rect = Rect(self.x, self.y, 64, 64)
if (enemy_rect.colliderect(boy_rect) == True and enemy.alive == True):
if(self.life <= 0):
self.level_manager.reset_level()
return
else:
self.life -= 1
enemy.alive = False
def check_mana_collide(self):
for mana in self.mana_list:
mana_rect = Rect(mana.x, mana.y, 64, 64)
if (mana_rect.collidepoint(self.x, self.y) == True):
self.life += 1
mana.alive = False
return
def move_boy(self):
self.draw_pos = mt.Vector2(self.x, self.y) # the position of the image on game scene
def initialize(self):
for row in range(self.row):
for column in range(self.column):
if(self.boy_object_list[row][column] == 1):
self.draw_pos = mt.Vector2(self.x, self.y) # the vector position of the image on game scene
self.scene.blit(self.boy_surface, self.draw_pos) # draw enemy frame
def draw(self):
self.scene.blit(self.boy_surface, self.draw_pos) # draw boy frame
from EnemyObject import EnemyObject
from pygame import math as mt
from Enemy import Enemy
class EnemySprite(object):
def __init__(self, level, scene):
self.row = 10
self.column = 10
self.scene = scene # game scene instance
self.space = 64 # image width and height
self.level = level # current game level
self.total_enemy_list = []
self.enemy_object = EnemyObject()
self.create_enemy(level)
def create_enemy(self, level):
self.enemy_boundary_list = self.enemy_object.get_object_boundary(level)
self.enemy_original_position = self.enemy_object.get_original_position(level)
i = 0
if(level == 1):
while(i < 5):
self.total_enemy_list.append(Enemy(self.enemy_boundary_list[i], self.enemy_original_position[i]))
i += 1
elif (level == 2):
while (i < 5):
self.total_enemy_list.append(Enemy(self.enemy_boundary_list[i], self.enemy_original_position[i]))
i += 1
def update(self):
for enemy in self.total_enemy_list:
if (enemy.alive == True):
enemy.update()
def draw(self):
self.counter = 0
for row in range(self.row):
for column in range(self.column):
if(self.enemy_list[row][column] == 1):
self.enemy = self.total_enemy_list[self.counter]
if(self.enemy.alive == True):
self.draw_pos = mt.Vector2(self.enemy.x, self.enemy.y) # the position of the image on game scene
self.scene.blit(self.enemy.get_enemy_surface(), self.draw_pos) # draw enemy frame
self.counter += 1
def get_level(self, level):
self.enemy_list = self.enemy_object.get_object_list(level)
def get_enemy_list(self):
return self.total_enemy_list
from pygame import math as mt
from Mana import Mana
from ManaObject import ManaObject
class ManaSprite(object):
def __init__(self, level, scene):
self.row = 10
self.column = 10
self.scene = scene # game scene instance
self.space = 64 # image width and height
self.level = level # current game level
self.total_mana_list = []
self.mana_object = ManaObject()
self.create_mana(level)
def create_mana(self, level):
self.mana_original_position = self.mana_object.get_original_position(level)
i = 0
if(level == 1):
while(i < 4):
self.total_mana_list.append(Mana(self.mana_original_position[i]))
i += 1
elif (level == 2):
while (i < 4):
self.total_mana_list.append(Mana(self.mana_original_position[i]))
i += 1
def update(self):
for mana in self.total_mana_list:
mana.update()
def draw(self):
self.counter = 0
for row in range(self.row):
for column in range(self.column):
if(self.mana_list[row][column] == 1):
self.mana = self.total_mana_list[self.counter]
if(self.mana.alive == True):
self.draw_pos = mt.Vector2(self.mana.x - self.mana.get_width()/7, self.mana.y - self.mana.get_height()/7) # the position of the image on game scene
self.scene.blit(self.mana.get_mana_surface(), self.draw_pos) # draw mana object
self.counter += 1
def get_level(self, level):
self.mana_list = self.mana_object.get_object_list(level)
def get_mana_list(self):
return self.total_mana_list
The last file we need to edit is the level manager class which is also the engine to move this entire game.
import pickle
class LevelManager(object):
def __init__(self, gm):
self.game_manager = gm
self.delete_line = False
self.MAX_LEVEL = 2
self.level = 1
self.level_list = []
def set_level(self):
try:
f = open("level.pickle", "rb")
self.level_list = pickle.load(f)
self.level = self.level_list[len(self.level_list) - 1]
if (len(self.level_list) > 5):
self.level_list.pop(0)
except EOFError:
self.level = 1
self.level_list.append(self.level)
def save_level(self):
try:
self.level_list.append(self.level)
if(len(self.level_list) > 5):
self.level_list.pop(0)
f = open("level.pickle", "wb")
pickle.dump(self.level_list, f)
f.close()
except IOError:
print('cannot open a file')
def increase_level(self):
self.level += 1
if(self.level > self.MAX_LEVEL):
#self.game_manager.state = self.game_manager.WIN
self.level = 1
self.game_manager.setup(self.level)
else:
#self.game_manager.state = self.game_manager.NEXT
self.game_manager.setup(self.level)
def get_level(self):
return self.level
def reset_level(self):
self.game_manager.setup(self.level)
def get_list(self):
return self.level_list
I am not sure yet whether if we create a new level in such a manner will it leads to more CPU consumption or not, so do leave your comment below this post if you have a better idea.
Like, share or follow me on twitter. If you would like to support the continued development of this project do consider to donate to this website through the donation form located on the sidebar of this website.
I have been a little bit lazy lately but hopefully in the future I will work harder and write more articles per week just to please you all.
Bitcoin
Ethereum
Bitcoin cash
Litecoin
Stellar
