class Game:
def __init__(self):
self.gameName = "Dungeons & Pythons"
self._image_library = {}
self.screen = pygame.display.set_mode((900, 750))
self.gameOver = False
self.clock = pygame.time.Clock()
self.roundNumber = 0
self.player = Player(100, "Hero", 25, 50, 125, "assets/player/player.png")
self.boss = Enemy(100, "The BOSS: Dragon", 20, 550, 100, "assets/monsters/boss.png", 300, 200)
self.enemies = [Enemy(50, "Cloud ashes", 10, 550, 100, "assets/monsters/ashesSnake.png", 50, 10),
Enemy(50, "Yaretzi", 15, 550, 100, "assets/monsters/aztecaSnake.png", 50, 15),
Enemy(40, "Konoha", 7, 550, 100, "assets/monsters/fireFairy.png", 40, 10),
Enemy(35, "Fire spliter", 10, 550, 100, "assets/monsters/fireLizard.png", 35, 10),
Enemy(40, "Duchy", 7, 550, 100, "assets/monsters/groundFairy.png", 40, 10),
Enemy(45, "Medusa's daughter", 13, 550, 100, "assets/monsters/groundSnake.png", 45, 13),
Enemy(40, "Imperial", 12, 550, 100, "assets/monsters/imperialBird.png", 40, 12),
Enemy(35, "Scissors", 9, 550, 100, "assets/monsters/scorpio.png", 35, 10),
Enemy(20, "Awesome bats", 8, 550, 100, "assets/monsters/triBats.png", 20, 10),
Enemy(45, "Hydra", 14, 550, 100, "assets/monsters/triHead.png", 45, 14),
Enemy(25, "The python brothers", 5, 550, 100, "assets/monsters/triSnakes.png", 25, 10),
Enemy(40, "Amega", 7, 550, 100, "assets/monsters/waterFairy.png", 40, 7)]
self.currentEnemy = self.getRandomRegularEnemy()
self.actionSelected = False
self.arrowMenuPosition = Position.TOPLEFT
def run(self):
pygame.init()
pygame.display.set_caption(self.gameName)
while not self.gameOver:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.gameOver = True
self.keyEvents(event)
self.screen.fill((0, 0, 0))
self.buildGUI(self.screen)
pygame.display.flip()
self.clock.tick(60)
pygame.quit()
def keyEvents(self, event):
if event.type == 3:
#key down
if event.key == 274:
if self.arrowMenuPosition == Position.TOPLEFT:
self.arrowMenuPosition = Position.BOTTOMLEFT
elif self.arrowMenuPosition == Position.TOPRIGHT:
self.arrowMenuPosition = Position.BOTTOMRIGHT
#key up
elif event.key == 273:
if self.arrowMenuPosition == Position.BOTTOMLEFT:
self.arrowMenuPosition = Position.TOPLEFT
elif self.arrowMenuPosition == Position.BOTTOMRIGHT:
self.arrowMenuPosition = Position.TOPRIGHT
#key left
elif event.key == 276:
if self.arrowMenuPosition == Position.TOPRIGHT:
self.arrowMenuPosition = Position.TOPLEFT
elif self.arrowMenuPosition == Position.BOTTOMRIGHT:
self.arrowMenuPosition = Position.BOTTOMLEFT
#key right
elif event.key == 275:
if self.arrowMenuPosition == Position.TOPLEFT:
self.arrowMenuPosition = Position.TOPRIGHT
elif self.arrowMenuPosition == Position.BOTTOMLEFT:
self.arrowMenuPosition = Position.BOTTOMRIGHT
#key enter
elif event.key == 13:
self.playAction()
def buildGUI(self, view):
#background
displayImage(view, 'assets/recources/bg.png', 0, 0)
#bottom panel
displayImage(view, 'assets/recources/panel.png', 0, 475)
#palyer
self.player.draw(view)
#enemy
self.currentEnemy.draw(view)
#buttons
self.drawButtons(view)
#player information
self.drawPlayerInfo(view)
#menu arrow
self.drawArrowMenu(view)
#armor
self.drawArmor(view)
#enemy info
self.drawEnemyLife(view)
def playAction(self):
if self.arrowMenuPosition == Position.TOPLEFT:
self.attackAction()
elif self.arrowMenuPosition == Position.TOPRIGHT:
self.healAction()
elif self.arrowMenuPosition == Position.BOTTOMLEFT:
self.armorAction()
elif self.arrowMenuPosition == Position.BOTTOMRIGHT:
self.exitGame()
def exitGame(self):
self.gameOver = True
def attackAction(self):
self.player.attack(self.currentEnemy)
if self.currentEnemy.isDead():
self.nextRound()
else:
self.currentEnemy.attack(self.player)
if self.player.isDead():
self.exitGame()
def healAction(self):
self.player.heal()
def armorAction(self):
self.player.addArmor()
def drawButtons(self, view):
#attack button
self.drawButton(view,'ATTACK', 65, 533, 'assets/ui/button.png')
#heal button
self.drawHealButton(view)
#armor button
self.drawArmorButton(view)
#exit button
self.drawButton(view,'EXIT', 450, 618, 'assets/ui/button.png')
def drawButton(self, view, text, x, y, buttonSprite, textColor = (255, 255, 255)):
displayImage(view, buttonSprite, x, y)
displayTextCentered(view, text, x, y, textColor)
def drawHealButton(self, view):
textColor = (255, 255, 255) if self.player.canHeal() else (149, 129, 115)
buttonSprite = 'assets/ui/button.png' if self.player.canHeal() else 'assets/ui/button_disable.png'
self.drawButton(view, 'HEAL(20C)', 450, 533, buttonSprite, textColor)
def drawArmorButton(self, view):
textColor = (255, 255, 255) if self.player.canAddArmor() else (149, 129, 115)
buttonSprite = 'assets/ui/button.png' if self.player.canAddArmor() else 'assets/ui/button_disable.png'
armorCost = self.player.getArmorCost()
buttonText = 'ARMOR('+str(armorCost)+'C)' if self.player.armor < self.player.MAX_ARMOR else 'MAX ARMOR'
self.drawButton(view, buttonText, 65, 618, buttonSprite, textColor)
def drawPlayerInfo(self, view):
#heal Poins
lifePercent = self.getPercentPoints(self.player.health, self.player.healthMax, 460)
pygame.draw.rect(view, (255,0,0), (50, 405, lifePercent, 49))
#heal GUI
displayImage(view, 'assets/ui/hp_bar.png', 30, 405)
#experience points
expPercent = self.getPercentPoints(self.player.level.experience, self.player.level.experienceNextLevel, 336)
pygame.draw.rect(view, (255,192,0), (65, 30, expPercent, 10))
#experience GUI
displayImage(view, 'assets/ui/experience.png', 10, 10)
#level
displayTextCentered(view, str(self.player.level.level), 22, 22, width=25, height=25, fontSize=30)
#money
moneyStrSizes = get_text(str(self.player.money), (255, 255, 255), 45).get_rect()
displayText(view, str(self.player.money), (900 - moneyStrSizes.width - 20), 20)
displayImage(view, 'assets/ui/coin.png', (900 - moneyStrSizes.width - 78), 15)
#round
roundStrSizes = get_text(str(self.roundNumber), (255, 255, 255), 45).get_rect()
displayText(view, str(self.roundNumber), (900 - roundStrSizes.width - 20), 80)
displayImage(view, 'assets/ui/kills.png', (900 - roundStrSizes.width - 78), 75)
def drawEnemyLife(self, view):
lifePercent = self.getPercentPoints(self.currentEnemy.health, self.currentEnemy.healthMax, 138)
pygame.draw.rect(view, (255,0,0), (603, 400, lifePercent, 15))
displayImage(view, 'assets/ui/enemy_hp_bar.png', 600, 400)
def drawArrowMenu(self, view):
if self.arrowMenuPosition == Position.TOPLEFT:
displayImage(view, 'assets/ui/menu_arrow.png', 42, 540)
elif self.arrowMenuPosition == Position.TOPRIGHT:
displayImage(view, 'assets/ui/menu_arrow.png', 430, 540)
elif self.arrowMenuPosition == Position.BOTTOMLEFT:
displayImage(view, 'assets/ui/menu_arrow.png', 42, 628)
elif self.arrowMenuPosition == Position.BOTTOMRIGHT:
displayImage(view, 'assets/ui/menu_arrow.png', 430, 628)
def drawArmor(self, view):
if self.player.armor > 0:
displayImage(view, 'assets/ui/armor.png', 480, 350)
if self.player.armor > 1:
displayImage(view, 'assets/ui/armor.png', 428, 350)
if self.player.armor > 2:
displayImage(view, 'assets/ui/armor.png', 376, 350)
if self.player.armor > 3:
displayImage(view, 'assets/ui/armor.png', 324, 350)
if self.player.armor > 4:
displayImage(view, 'assets/ui/armor.png', 272, 350)
def getPercentPoints(self, points, maxPoints, maxPercent):
if points <= 0:
return 0
else:
points = (points*maxPercent)/maxPoints
return int(points)
def nextRound(self):
self.roundNumber += 1
self.player.money += self.currentEnemy.moneyWhenDying
self.player.level.addExperience(self.currentEnemy.experienceWhenDying)
self.setCurrentEnemy()
def setCurrentEnemy(self):
if self.roundNumber % 10 == 0:
self.currentEnemy = self.getBossEnemy()
else:
self.currentEnemy = self.getRandomRegularEnemy()
self.currentEnemy.upgradeStatsAcordingLevel(self.roundNumber)
def getRandomRegularEnemy(self):
randomIndex = random.randint(0, len(self.enemies)-1)
enemy = self.enemies[randomIndex]
return enemy
def getBossEnemy(self):
enemy = self.boss
return enemy
player.experience == 0 # Experience is per level
player.skill += 5
player.maxHealthAndArmor()
print("!! You have leveled up to level", player.level, "!!")
game = Game()
game.start()
player = Player("Juha")
while game.isRunning:
enemy = game.generateOpponent(player)
pick = input("Do you wish to attack? Y/N")
if pick == "Y":
while enemy.health >= 1:
player.attack(enemy)
if enemy.health >= 1:
enemy.attack(player)
else:
experience = enemy.damage * 2
print(enemy.name, "is defeated! You have earned", experience, "XP!")
player.experience += experience
if player.experience >= player.level * 10:
game.playerLevelUp(player)
player.showStatistics()
if player.health <= 0:
print(player.name, "has died! Game over, man!")
game.isRunning = False
break
else:
continue
class Game(object):
window = None
game = None
background = None
game_is_running = True
player = None
stance_event = None
sprites = None
clock = None
health_bar = None
monster = None
def init(self):
"""
Initializes the game
:return:
"""
self.game = pygame
self.game.init()
# Game setup
self.window = self.game.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
self.game.display.set_caption(WINDOW_TITLE)
# Draw the image background
self.background = self.game.image.load(DEFAULT_BACKGROUND)
self.window.blit(self.background, (DEFAULT_BACKGROUND_X, DEFAULT_BACKGROUND_Y))
self.game.display.update()
# Initialize the player class
self.player = Player()
#Initialize the monster class
self.monster = Monster()
# Initialize user events
self.stance_event = self.game.USEREVENT + 1
self.attacking_event = self.game.USEREVENT + 2
self.game.time.set_timer(self.stance_event, CHARACTER_STANCE_EVENT_INTERVAL)
self.sprites = pygame.sprite.Group()
self.sprites.add(self.player)
self.sprites.draw(self.window)
# Define a health bar
# Define a clock
self.clock = self.game.time.Clock()
# Start game loop
self.loop()
def update(self):
# Step 1, update the player
self.sprites.update()
self.window.blit(self.background, (DEFAULT_BACKGROUND_X, DEFAULT_BACKGROUND_Y))
self.sprites.draw(self.window)
pygame.draw.rect(self.window, (0, 0, 0), pygame.Rect(self.player.rect.x - 15, self.player.rect.y - 15, 100, 7))
pygame.draw.rect(self.window, (255, 0, 0), pygame.Rect(self.player.rect.x - 15, self.player.rect.y - 15, self.player.health, 7))
self.game.display.flip()
self.clock.tick(30)
def loop(self):
while self.game_is_running:
threading.Timer(6.7, Monster.random_movement)
self.game.mixer.init()
self.game.mixer.load('muscic.mp3')
self.game.mixer.music.play(-1, 0.0)
# Close event
for event in self.game.event.get():
if event.type == self.game.QUIT:
self.game_is_running = False
if event.type == self.stance_event:
self.player.movement()
if event.type == self.game.KEYDOWN:
self.player.hit(5)
# Check left right
if (event.key == self.game.K_LEFT):
self.player.move_left()
elif (event.key == self.game.K_RIGHT):
self.player.move_right()
keys_pressed = self.game.key.get_pressed()
if keys_pressed[self.game.K_LEFT]:
self.player.move_left()
if keys_pressed[self.game.K_RIGHT]:
self.player.move_right()
if keys_pressed[self.game.K_LCTRL]:
self.player.attack()
if keys_pressed[self.game.K_SPACE]:
self.player.jump()
self.update()
class Controller():
# X position that player starts level at
player_x = PLAYER_X_VAL
def __init__(self, game_display, game_screen, screen_dims, colour,
clock_delay):
# Run game - used to exit game loop
self.run = True
# Load game settings
with open('json/settings.JSON') as settings:
self.settings = json.load(settings)
# Add important game features to self
self.game_display = game_display
self.game_screen = game_screen
self.screen_dims = screen_dims
self.colour = colour
self.clock_delay = clock_delay
# Setup score and level displays
self.score = Score(game_screen)
self.level = Level(game_screen)
# Setup key distances
self.spawn_area = (2 * self.player_x, screen_dims[0])
self.map_width = self.game_screen.get_width()
self.mid_width = self.map_width // 2
self.mid_height = self.game_screen.get_height() // 2
self.weapon_types = list(WEAPON_TYPES.keys())
# Setup level complete variables
self.level_complete = False
self.level_complete_text_1 = Text(self.game_screen,
(self.mid_width, self.mid_height - 40),
30,
'Level Complete'
)
continue_string = f'Press {self.settings["next_level"]} to continue'
self.level_complete_text_2 = Text(self.game_screen,
(self.mid_width, self.mid_height),
30,
continue_string
)
# Setup first level
self.firstLevel()
# Setup god mode capability - used for debugging
self.god_mode = False
self.cheats = 0
# Play game music
self.playMusic()
self.projectiles = pygame.sprite.Group()
def playMusic(self):
### Setting up game music
# - Music code inspired by code here:
# https://riptutorial.com/pygame/example/24563/example-to-add-
# music-in-pygame
track = TRACKS[self.settings['music']]
if track == 'Mute':
pygame.mixer.music.stop()
else:
level_music = MUSIC_LOCATIONS[track]
pygame.mixer.music.set_volume(level_music[1])
pygame.mixer.music.load(level_music[0])
pygame.mixer.music.play(-1)
def setupCameraMap(self):
'''
Sets up camera and map for a given level
'''
self.camera = Camera(self.game_screen)
self.background = Background(self.game_display)
self.game_map = Map(self.game_display, self.screen_dims, 32)
def setupPlayer(self):
''' Sets up player for the first level
'''
self.player = Player(self.game_display, self.game_map,
self.player_x, - 100)
self.player_group = pygame.sprite.Group()
self.player_group.add(self.player)
self.characters = pygame.sprite.Group()
self.characters.add(self.player)
def addCameraTracking(self):
'''
Method to add all blitted objects to camera
'''
self.camera.addBack(self.background)
self.camera.addMap(self.game_map)
self.camera.addPlayer(self.player)
for enemy in self.enemy_group:
self.camera.add(enemy)
def decideEnemyType(self):
'''
Randomly returns an enemy from the enemies list
Consulted docs below to check how to use randint vs randrange
https://docs.python.org/3/library/random.html
'''
idx = random.randrange(len(ENEMIES))
return ENEMIES[idx]
def decideRandomArm(self):
'''
Randomly determine which arms to give an enemy
'''
idx = random.randrange(len(self.weapon_types))
return self.weapon_types[idx]
def generateLevel(self):
'''
This function generates a new level, and enemies to fight
'''
# Setup enemy group for level
self.enemy_group = pygame.sprite.Group()
self.dropped_weapons = pygame.sprite.Group()
# Set up enemies for level. Level number represents number of
# enemies
for n in range(self.level.val):
enemy_type = self.decideEnemyType()
position = random.randrange(self.spawn_area[0], self.spawn_area[1])
enemy = NPC(self.game_display, self.game_map, position, -100,
enemy_type, self.decideRandomArm())
enemy.addTarget(self.player_group)
self.enemy_group.add(enemy)
self.characters.add(enemy)
# Tell player about enemies
self.player.addTarget(self.enemy_group)
# Setup tracking
self.addCameraTracking()
def resetPlayer(self):
''' Resets player to start point for new level
'''
self.player.changeMap(self.game_map)
self.player.center = self.player_x, -100
self.player.updateState('idle', self.player.state[1])
self.player.x_y_moving = False
self.player.max_health += 10
self.player.health = self.player.max_health
def firstLevel(self):
''' Sets up first level
'''
introScreen(self.game_screen, self)
self.setupCameraMap()
self.setupPlayer()
self.generateLevel()
def newLevel(self):
''' Function to start a new level
Increments the level counter, and adjusts player health
'''
self.level.val += 1
self.level_complete = False
self.setupCameraMap()
self.resetPlayer()
self.generateLevel()
def keyboardInput(self, event):
''' keyboardInput
Called by game loop, and checking events from keyboard, and
calling respective functions.
Includes functionality to activate 'god mode'.
The intention of god mode is for debugging without dying.
We initially used the syntax:
if event.key == pygame.K_w:
self.player.startMove("u")
However by browing through the documentation, we discovered that
with pygame 2.0.0 there was a new feature:
pygame.key.key_code().
We can pass in the string of the key eg "space" for space, or
"w" for "w".
This allows us to easily produce a human readable JSON
containing the keybindings so that the user can change the
keybindings to those of their choice.
We load this JSON each time we instantiate this class, as the
intention is that if we have time between now and submission, we
will produce a settings screen to allow the user to graphically
change the keybindings to their preference.
'''
if event.type == pygame.KEYDOWN:
# WASD for up/right/left, q for attack
if event.key == pygame.key.key_code(self.settings['up']):
self.player.startMove("u")
elif event.key == pygame.key.key_code(self.settings['right']):
self.player.startMove("r")
elif event.key == pygame.key.key_code(self.settings['left']):
self.player.startMove("l")
elif event.key == pygame.key.key_code(self.settings['attack']):
self.player.attack()
# When level complete, space to move to next level
elif (event.key == pygame.key.key_code(self.settings['next_level']))\
and self.level_complete:
self.newLevel()
# Escape to pause game
elif event.key == pygame.K_ESCAPE:
self.player.updateState('idle', self.player.state[1])
self.player.x_y_moving = False
pauseScreen(self.game_screen, self)
# Enter cheat code to enter god mode
elif event.key == pygame.K_RSHIFT:
self.cheats = 1
elif (event.key == pygame.K_1) and (self.cheats == 1):
self.cheats += 1
elif (event.key == pygame.K_2) and (self.cheats == 2):
self.cheats += 1
elif (event.key == pygame.K_3) and (self.cheats == 3):
self.cheats += 1
elif event.type == pygame.KEYUP:
# Toggle right/left moving
if event.key == pygame.key.key_code(self.settings['right']):
self.player.stopMoveX("right")
elif event.key == pygame.key.key_code(self.settings['left']):
self.player.stopMoveX("left")
# Lift right shift to submit code for god mode
elif event.key == pygame.K_RSHIFT:
if self.cheats == 4:
self.initGodMode()
self.cheats = 0
else:
self.cheats = 0
def initGodMode(self):
''' God Mode
This is here to debug the game without dying, and without having
to edit the code.
'''
self.god_mode = True
self.player.max_health = 1000000000000000000000000000
self.player.health = self.player.max_health
self.gt = Text(self.game_screen,
(110, self.game_screen.get_height() - 20),
20, 'god mode activated')
self.player.arms.strength *= 10000
def update(self):
''' Update function - Used to update positions of characters on
screen.
This was initially encapsulated in the display function,
however this caused issues when the map functions were
tracking characters. This was due to the fact that some
changes to the characters position (such as due to gravity
and recoil) were being applied after the map had updated.
To avoid this, update functions were added to characters.
These are called before we blit to the screen.
'''
# Updating character positions
for character in self.characters:
character.update()
for projectile in character.thrown_projectiles:
# Get any new projectiles and add to camera
if not self.projectiles.has(projectile):
self.projectiles.add(projectile)
self.camera.addWeapon(projectile)
# update tracked projectiles
for projectile in self.projectiles:
# If projectile off screen, remove from sprite groups
if (projectile.rect.centerx < 0) or \
(projectile.rect.centerx > self.map_width):
projectile.kill()
projectile.update()
for weapon in self.dropped_weapons:
weapon.update()
# Check if player is alive
if self.player.alive == False:
# End game
self.run = False
gameOver(self.game_screen, self.player.score, self.clock_delay)
for enemy in self.enemy_group:
if enemy.rect.bottom > self.screen_dims[1]:
enemy.kill()
if enemy.alive == False:
self.camera.addWeapon(enemy.arms)
self.dropped_weapons.add(enemy.arms)
enemy.arms.addCharacterGroup(self.characters)
enemy.kill()
if len(self.enemy_group) == 0:
self.level_complete = True
#self.score_string.text = f'Score = {self.player.score}'
self.score.val = self.player.score
# Update camera position
self.camera.scroll()
def display(self):
''' Display
This displays all our objects to the screen in order. This
takes place each frame.
'''
# Colour screen purple
self.game_display.fill(self.colour['purple'])
# Display background and map
self.background.displayQ()
self.game_map.display()
# Display characters
for enemy in self.enemy_group:
enemy.display()
self.player.display()
for weapon in self.dropped_weapons:
weapon.display()
#print(self.projectiles)
for projectile in self.projectiles:
projectile.display()
# scales the game_display to game_screen. Allows us to scale
# images
scaled_surf = pygame.transform.scale(self.game_display,
self.screen_dims)
self.game_screen.blit(scaled_surf, (0, 0))
self.score.display()
self.level.display()
# If in god mode, display text
if self.god_mode:
self.gt.display()
# If waiting to change level, display text
if self.level_complete:
self.level_complete_text_1.display()
self.level_complete_text_2.display()
