def createObjects(self):
from mechanics.Ball import Ball
from mechanics.Level import Level
from mechanics.Player import Player
from tools.Sound import Sound
from tools.Score import Score
from gui.Text import TextPane
self.ball = Ball(size=40)
self.player = Player()
self.effects = []
self.level = Level()
self.level.text.fs = 50
self.level.text.update()
self.score = Score(0)
self.score.fs = 50
self.score.update()
self.sound = Sound()
self.time = default_timer()
Debug.printMessage("LOADING COMPLETE")
#Setting GUI position
self.score.pos = Vec2D(self.size.x - self.score.size.x) + Vec2D(
-10, 10)
self.sound.pos = self.size - self.sound.size - Vec2D(20, 10)
self.sound.fs = 15
self.sound.update()
self.level.text.pos = Vec2D(10, 10)
#Debug features
if Debug.DEBUGGING:
self.fpsCounter = TextPane('0 fps', 15)
self.fpsCounter.pos = Vec2D(
20, self.size.y - 10 - self.fpsCounter.size.y)
def click(self, mousePos=Vec2D(0, 0)):
relPos = Vec2D(0, 0, mousePos) - self.pos
if (relPos > 0 and relPos < self.size):
if (self.action is not None):
self.action()
return True
else:
return False
def moveRand(self):
if self.movement != Vec2D(0, 0):
return False
from random import randint
self.movement = Vec2D(randint(-1, 4), -4)
while self.movement.x == 0:
self.movement.x = randint(-1, 4)
Debug.printMessage("Starting Speed: %s" % self.movement)
return True
def __init__(self, size=None):
if isinstance(size, int) or isinstance(size, float):
Drawable.__init__(self, pos=Vec2D(0, 0), size=Vec2D(size, size))
else:
Drawable.__init__(self,
pos=Vec2D(0, 0),
size=Vec2D(Ball.DEFAULTSIZE, Ball.DEFAULTSIZE))
self.movement = Vec2D(0, 0)
self.speed = 1
Debug.printMessage("Ball created")
def __init__(self, size=None):
from tools.Debug import Debug
if Vec2D.isVec(size):
Drawable.__init__(self, None, size)
else:
Drawable.__init__(self, None, Player.PLAYERSIZE)
self.offsetY = 30
self.speed = 5
self.sizeScale = 1
self.movement = Vec2D(0, 0)
Debug.printMessage("Player created")
def __init__(self, position, size):
import random, pygame
from tools.VecMath import Vec2D
self.imageOverLay = None
#self.effekt = ClassOfEffect("none")
self.pos = Vec2D(0, 0, position)
self.size = Vec2D(0, 0, size)
if len(TEXTUES) != 0:
image = pygame.image.load(random.choice(TEXTUES))
#image = pygame.transform.scale(image, self.size.getTuple())
self.imageOverLay = image
else:
self.imageOverLay = None
def gameOverScreen(self):
from tools.Debug import Debug
playerName = ''
blocked = True
toRender = []
# Creating text panes
gameOverText = TextPane("Game Over", 60)
gameOverText.pos = (self.size - gameOverText.size) / 2
toRender.append(gameOverText)
# The text below
restartText = TextPane("Q to quit or C to play again", 45)
restartText2 = TextPane("H for highscore", 45)
restartText.pos = (self.size - restartText.size) / 2 + Vec2D(0, 50)
restartText2.pos = (self.size - restartText2.size) / 2 + Vec2D(0, 100)
toRender.append(restartText)
toRender.append(restartText2)
# Playername
playerNameText = TextPane(playerName, 90)
playerNameText.pos.y = (self.size - playerNameText.size).y
toRender.append(playerNameText)
# Updating the screen and doing the event loop
while True:
for gameOverEvent in pygame.event.get():
if gameOverEvent.type == pygame.QUIT:
return SceneManager.QUIT
if gameOverEvent.type == pygame.KEYDOWN:
key = gameOverEvent.key
if key == pygame.K_ESCAPE: return SceneManager.QUIT
if key == pygame.K_q and not blocked:
return SceneManager.QUIT
elif key == pygame.K_c and not blocked:
return SceneManager.RESTART
elif 97 <= key <= 122:
playerName += chr(key)
elif key == pygame.K_SPACE:
playerName += ' '
elif key == pygame.K_BACKSPACE:
playerName = playerName[:-1]
elif key == pygame.K_RETURN and blocked:
blocked = False
Debug.printMessage(playerName)
Highscore.saveToFile(playerName, self.score.score,
self.level.levelid)
#Drawing objects
self.screen.fill(SceneManager.BACKGROUND_COLOR)
playerNameText.setText("Enter your name" if playerName ==
'' else playerName)
for obj in toRender:
obj.draw(self.screen)
pygame.display.update()
def update(self):
self.remove_invisible_blocks()
# Generate new platforms
current = self.blocks[-1].get_right_edge().x
end = self.x_offset + self.dimension.x * 1.2
height = 50
while current <= end:
current += self.get_distance_between_blocks()
width = randrange(80, 100)
block = Block(Vec2D(current, self.dimension.y - height),
Vec2D(width, height))
self.blocks.append(block)
current += width
def setSize(self, scale):
if Vec2D.isVec(scale):
scale = scale.getLength()
if isinstance(scale, float) or isinstance(scale, int):
self.size = Player.PLAYERSIZE * scale
else:
self.size = Player.PLAYERSIZE
def constrain(self, boundery):
# Top
if self.pos.y < 0:
self.bounceY()
self.pos = Vec2D(self.pos.x, 0)
return Ball.BOUNCE
# Right
elif (self.pos + self.size).x >= boundery.x:
self.bounceX()
self.pos = Vec2D(boundery.x - (self.size.x + 1), self.pos.y)
return Ball.BOUNCE
# Left
elif self.pos.x < 0:
self.bounceX()
self.pos = Vec2D(0, self.pos.y)
return Ball.BOUNCE
#Down
elif (self.pos + self.size).y > boundery.y:
return Ball.FAIL
return Ball.NONE
def run(self):
while self.running:
self.running = self.catch_events(pygame.event.get())
# Updating positions
self.player.update()
# self.player.constrain(self.window_dimension)
if self.level.collides(self.player):
self.player.bounce()
self.level.update()
# Showing objects on the screen
self.camera.show(self.screen, Vec2D(0, 0))
self.camera.update()
pygame.display.update()
def eventLoop(self, event):
# todo: implement keymap
if event.type == pygame.QUIT:
self.running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
self.player.movement.x = 1
elif event.key == pygame.K_LEFT:
self.player.movement.x = -1
try:
self.keymap[event.key]()
except KeyError:
pass
elif event.type == pygame.KEYUP:
self.player.movement = Vec2D(0, 0)
elif (event.type == pygame.MOUSEBUTTONDOWN) and (event.button == 1):
self.click(pygame.mouse.get_pos())
class Player(Drawable):
PLAYERSPEED = 10
PLAYERSIZE = Vec2D(150, 10)
# Constructor
def __init__(self, size=None):
from tools.Debug import Debug
if Vec2D.isVec(size):
Drawable.__init__(self, None, size)
else:
Drawable.__init__(self, None, Player.PLAYERSIZE)
self.offsetY = 30
self.speed = 5
self.sizeScale = 1
self.movement = Vec2D(0, 0)
Debug.printMessage("Player created")
# Resizing the player
def setSize(self, scale):
if Vec2D.isVec(scale):
scale = scale.getLength()
if isinstance(scale, float) or isinstance(scale, int):
self.size = Player.PLAYERSIZE * scale
else:
self.size = Player.PLAYERSIZE
# Setting speed
def setSpeed(self, x):
self.speed = Player.PLAYERSPEED * x
# Moving the player+checking for collisions
def move(self, screenWidth):
self.pos += self.movement * self.speed
self.pos.x = max(0, self.pos.x)
self.pos.x = min(screenWidth - self.size.x, self.pos.x)
# Puting the player out on the screen
def draw(self, screen):
from pygame.draw import rect
rect(screen, (0, 0, 0), self.getRect())
def menuScreen(self):
from gui.Button import Button
self.screen.fill(SceneManager.BACKGROUND_COLOR)
buttons = [Button("Start", 30), Button("Highscore", 30)]
#Drawing
for button in buttons:
button.size = Vec2D(200, 50)
button.center()
button.bg = (255, 0, 0)
button.draw(self.screen)
pygame.display.update()
while (True):
for menuEvent in pygame.event.get():
if menuEvent.type == pygame.QUIT: self.close()
if menuEvent.type == pygame.KEYDOWN:
key = menuEvent.key
if key == pygame.K_ESCAPE: self.close()
if menuEvent != pygame.MOUSEBUTTONDOWN or event.button != 1:
continue
for button in buttons:
button.click(pygame.mouse.get_pos())
def setup(self):
# Setting the effects
# from mechanics.Effect import Effect
# self.effects.append(Effect("PlayerBooster", 5))
# self.effects.append(Effect("BallSlower", 5))
# Sets the level to 1
self.level.switchLevel(1)
# Centers the player
playerRect = self.player.getRect()
playerRect.center = (self.size.x / 2,
self.size.y - self.player.offsetY)
self.player.pos = Vec2D(playerRect.left, playerRect.top)
# Relocates the ball to the middle of the player
self.ball.movement = Vec2D(0, 0)
self.ball.pos = self.player.pos + self.player.size * Vec2D(
.5, 0) - self.ball.size * Vec2D(.5, 1)
# Moving level Down
self.level.setOffset(
Vec2D(0, self.score.pos.y + self.score.size.y * .75))
# Reset score
self.score.reset()
self.level.pos = Vec2D(0, self.score.pos.y + self.score.size.y)
def __init__(self, size):
self.background = (0, 128, 0)
self.position = Vec2D(0, 0)
self.size = size
self.objects = []
self.center_object = None
def __init__(self, dimension):
self.dimension = dimension
self.blocks = [Block(Vec2D(0, 400), Vec2D(100, 300))]
self.x_offset = 0
def __init__(self, position, size):
self.position = position if Vec2D.isVec(position) else Vec2D(0, 0)
self.size = size if Vec2D.isVec(size) else Vec2D(10, 10)
def __init__(self, size):
pygame.init()
self.size = size if Vec2D.isVec(size) else Vec2D(500, 500)
self.screen = pygame.display.set_mode(self.size.getTuple())
self.clock = pygame.time.Clock()
def update(self):
from pygame.font import Font
self.textRect = Font(None, self.fs).render(self.text, 1, self.fc)
rect = self.textRect.get_rect()
self.size = Vec2D(rect.width, rect.height)
def setOffset(self, offset=None):
from tools.VecMath import Vec2D
if not Vec2D.isVec(offset) or offset is None:
return
for block in self.blocks:
block.pos += offset
def __init__(self):
self.position = Vec2D(100, 200)
self.speed = Vec2D(500, 0) * Game.UPDATE_SPEED
self.acceleration = Vec2D(0, 1) * Game.UPDATE_SPEED
self.radius = 30
def draw(self, surf):
textVec = self.pos
for i, line in enumerate(self.lines):
line.pos = textVec
line.draw(surf)
textVec += Vec2D(0, line.size.y)
def __init__(self, window_dimension=None):
from mechanics.Camera import Camera
from Player import Player
from mechanics.Obstacles import Level
self.window_dimension = window_dimension if window_dimension is not None else Vec2D(
800, 600)
self.screen = pygame.display.set_mode(
self.window_dimension.get_tuple())
self.camera = Camera(self.window_dimension)
self.level = Level(self.window_dimension)
self.player = Player()
self.camera_setup()
self.running = True
self.run()
def setPosition(self, position):
self.pos if Vec2D.isVec(position) else Vec2D(0, 0)
