def start_game(self):
playfieldSize = self.playfield.size
#bricks
brick_spacing = 4
top_space = self.playfield.top + (self.playfield.size.y /
16) + brick_spacing / 2
left_space = self.playfield.left + brick_spacing / 2
brick_width = (playfieldSize.x / self.bricks_per_row) - brick_spacing
brick_height = 10
def kill_brick(brick: Brick, ball: Ball):
self.brick_collision(brick, ball)
for i in range(0, self.rows):
for j in range(0, self.bricks_per_row):
brick = Brick(
Vector2(left_space + (j * (brick_width + brick_spacing)),
top_space + (i * (brick_height + brick_spacing))),
Vector2(brick_width, brick_height), (255, 255, 255),
kill_brick)
self.add_game_object(brick)
self.bricks.append(brick)
self.paddle = Paddle(Vector2(80, 10), self.playfield)
self.paddle.drawable.pos = Vector2(
self.playfield.horizontal_center - self.paddle.drawable.size.x / 2,
self.playfield.bottom - self.paddle.drawable.size.y)
self.add_game_object(self.paddle)
self.spawn_ball(self.playfield.size.clone() * 0.5, Vector2(10, 10))
def __init__(self, screen_size: Vector2, bricks_per_row: int, rows: int):
super(Breakton, self).__init__("Breakton", screen_size,
[0b0110, 0b1001])
self.paddleMaxAngleDeflection = math.radians(60)
playfieldSize = screen_size * Vector2(0.95, 0.9)
playfieldPos = Vector2((screen_size.x - playfieldSize.x) / 2,
screen_size.y - playfieldSize.y)
self.playfield = Rect(playfieldPos, playfieldSize)
self.bricks = []
self.balls = []
self.paddle = None
self.bricks_per_row = bricks_per_row
self.rows = rows
#screen corners
border_color = (40, 40, 40)
left_edge = Rectangle(self.playfield.pos.x, screen_size.y,
border_color)
top_edge = Rectangle(screen_size.x,
screen_size.y - self.playfield.size.y,
border_color)
right_edge = Rectangle(self.playfield.pos.x, screen_size.y,
border_color)
right_edge.pos = Vector2(self.playfield.right, 0)
self.add_drawable(left_edge)
self.add_drawable(top_edge)
self.add_drawable(right_edge)
self.start_game()
def __init__(self, drawable: Drawable, playfield: Rect):
super(Ball, self).__init__(drawable, 1)
self.drawable = drawable
self.velocity = Vector2(200.0, 100.0)
self.initialPos = drawable.pos.clone()
self.initialVelocity = self.velocity.clone()
self.playfield = playfield
def spawn_ball_copy(self, original: Ball, angle_delta: float):
ball = self.spawn_ball(original.drawable.pos.clone(),
original.drawable.size.clone())
velocity = original.velocity.clone()
angle = velocity.angle
magnitude = velocity.magnitude
ball.velocity = Vector2.from_angle_magnitude(angle + angle_delta,
magnitude)
def __init__(self, brick: Brick, color, playfield: Rect,
on_paddle_collision: Callable[[PowerUpToken, Paddle], None]):
super(PowerUpToken, self).__init__(
Rectangle(brick.drawable.size.x, brick.drawable.size.y, color), 3)
self.drawable.pos = brick.drawable.pos.clone()
self.velocity = Vector2(0, 50)
self.playfield = playfield
self.on_paddle_collision = on_paddle_collision
def __init__(self, screen_size: Vector2):
super(Pong, self).__init__("Pong2", screen_size, [0b10])
self.backgroundColor = (0, 0, 0)
self.paddleColor = (255, 255, 255)
self.ballColor = (255, 255, 255)
self.clock = pygame.time.Clock()
self.playfield = Rect(Vector2(0, 0), screen_size)
paddlesize = Vector2(10, 100)
paddlewalldistance = 30
player1drawable = Rectangle(paddlesize.x, paddlesize.y, self.paddleColor)
player1drawable.pos = Vector2(0 + paddlewalldistance, 0)
self.player1 = Paddle(player1drawable, pygame.K_w, pygame.K_s, self.playfield, 1)
self.add_game_object(self.player1)
self.player1Score = PlayerUI(Vector2(200, 0))
self.add_drawable(self.player1Score)
player2drawable = Rectangle(paddlesize.x, paddlesize.y, self.paddleColor)
player2drawable.pos = Vector2(self.playfield.size.x - paddlesize.x - paddlewalldistance, 0)
self.player2 = Paddle(player2drawable, pygame.K_UP, pygame.K_DOWN, self.playfield, -1)
self.add_game_object(self.player2)
self.player2Score = PlayerUI(Vector2(self.playfield.size.x - 200, 0))
self.add_drawable(self.player2Score)
balldrawable = Rectangle(10, 10, self.ballColor)
#balldrawable = Sprite("drevil-icon.png", 10, 10)
balldrawable.pos = Vector2(100, 300)
self.ball = Ball(balldrawable, self.playfield)
self.add_game_object(self.ball)
def power_up_token_collision(self, token: PowerUpToken, paddle: Paddle):
if isinstance(token, MultiBallPowerUpToken):
ball = self.balls[0]
# shoot main ball straight down
ball.velocity = Vector2.from_angle_magnitude(
math.pi / 2, ball.velocity.magnitude)
self.spawn_ball_copy(ball, 2 * math.pi / 3)
self.spawn_ball_copy(ball, -2 * math.pi / 3)
self.remove_game_object(token)
def __init__(self, pos: Vector2, size: Vector2, playfield: Rect,
paddleMaxAngleDeflection: float, on_death: Callable[[Ball],
None]):
super(Ball, self).__init__(Rectangle(size.x, size.y, (255, 255, 255)),
0)
self.drawable.pos = pos
self.velocity = Vector2(300.0, 200.0)
self.initialPos = self.drawable.pos.clone()
self.lastPos = self.initialPos
self.initialVelocity = self.velocity.clone()
self.playfield = playfield
self.paddleMaxAngleDeflection = paddleMaxAngleDeflection
self.on_death = on_death
def deflect(self, ball: Ball, direction: int):
ballrect = ball.drawable.get_rect()
paddlerect = self.drawable.get_rect()
ballcenter = ballrect.vertical_center
paddlecenter = paddlerect.vertical_center
distance = ballcenter - paddlecenter
distancenorm = max(min(distance / (paddlecenter - paddlerect.top), 1), -1) # clamp at (-1, 1) just in case - collision can cause us to be above the paddle's bounds
magnitude = ball.velocity.magnitude
straightangle = (direction - 1) * 0.5 * math.pi
angle = distancenorm * self.paddleMaxAngleDeflection * direction + straightangle
ball.velocity = Vector2.from_angle_magnitude(angle, magnitude)
def spawn_initial_ball(self):
self.spawn_ball(self.playfield.size.clone() * 0.5, Vector2(10, 10))
def spawn_ball_copy(self, original: Ball, angle_delta: float):
ball = self.spawn_ball(original.drawable.pos.clone(),
original.drawable.size.clone())
velocity = original.velocity.clone()
angle = velocity.angle
magnitude = velocity.magnitude
ball.velocity = Vector2.from_angle_magnitude(angle + angle_delta,
magnitude)
def ball_death(self, ball: Ball):
self.balls.remove(ball)
self.remove_game_object(ball)
if len(self.balls) == 0:
self.spawn_initial_ball()
def early_update(self, elapsedtime: float, keys: dict):
pass
def late_update(self, elapsedtime: float, keys: dict):
pass
def draw(self):
pass
if __name__ == "__main__":
game = Breakton(Vector2(800, 600), 16, 5)
game.run()
player2drawable = Rectangle(paddlesize.x, paddlesize.y, self.paddleColor)
player2drawable.pos = Vector2(self.playfield.size.x - paddlesize.x - paddlewalldistance, 0)
self.player2 = Paddle(player2drawable, pygame.K_UP, pygame.K_DOWN, self.playfield, -1)
self.add_game_object(self.player2)
self.player2Score = PlayerUI(Vector2(self.playfield.size.x - 200, 0))
self.add_drawable(self.player2Score)
balldrawable = Rectangle(10, 10, self.ballColor)
#balldrawable = Sprite("drevil-icon.png", 10, 10)
balldrawable.pos = Vector2(100, 300)
self.ball = Ball(balldrawable, self.playfield)
self.add_game_object(self.ball)
def late_update(self, elapsedtime: float, keys: dict):
if self.ball.drawable.get_rect().left < self.playfield.left:
self.player2Score.increment_score()
self.ball.reset()
if self.ball.drawable.get_rect().right > self.playfield.right:
self.player1Score.increment_score()
self.ball.reset()
def draw(self):
pass
if __name__ == "__main__":
game = Pong(Vector2(800, 600))
game.run()