Vortex Breakout

VortexBreakout is an arcade-style game where players control a paddle to bounce a ball and break bricks. Clear all bricks to win, but beware—the ball speeds up as you progress!

1. Initialization and Importing Required Modules

from Engine.Vortex import Vortex
from Engine.Vortex import *

Explanation:

  • Here, we import the Vortex class and other necessary components from the Engine.Vortex module. The Vortex class is the core of the engine, providing methods to create objects, labels, and manage the game.

2. Vortex Initialization

vortex = Vortex(PrivateKey="your_private_key_here")

Explanation:

  • We initialize the Vortex engine by creating an instance of the Vortex class. The PrivateKey is passed as an argument, which might be used for blockchain-related functionalities (depending on the full capabilities of the Vortex engine).

3. Building Walls

ceiling = vortex.Object(model='quad', x=0, y=4, scale=(16, 0.2), collider='box', color=vortex.color("orange"))
left_wall = vortex.Object(model='quad', x=-7.2, y=0, scale=(0.2, 10), collider='box', color=vortex.color("orange"))
right_wall = vortex.Object(model='quad', x=7.2, y=0, scale=(0.2, 10), collider='box', color=vortex.color("orange"))

Explanation:

  • vortex.Object: This method creates a game object. The model parameter specifies the shape (quad is a rectangle).

  • The ceiling, left_wall, and right_wall objects define the boundaries of the game. The ball will bounce off these walls, preventing it from leaving the screen.

  • collider='box': This makes the objects interactable, meaning other objects (like the ball) can collide with them.

  • color=vortex.color("orange"): The color of the walls is set to orange.

4. Creating the Ball

ball = vortex.Object(model='circle', scale=0.2, collider='box', dx=0.05, dy=0.05)
// Some codeball = vortex.Object(model='circle', scale=0.2, collider='box', dx=0.05, dy=0.05)

Explanation:

  • model='circle': The ball is represented as a circle.

  • scale=0.2: This sets the size of the ball.

  • dx and dy: These attributes set the initial velocity of the ball along the x and y axes, respectively.

  • The ball will move and interact with other objects using these velocities.

5. Creating the Paddle

paddle = vortex.Object(model='quad', x=0, y=-3.5, scale=(2, 0.2), collider='box', color=vortex.color("orange"))

Explanation:

  • The paddle is another quad (rectangle) object placed at the bottom of the screen.

  • The player controls the paddle to keep the ball in play.

  • The paddle’s position is initially set at y=-3.5 (near the bottom of the screen), and its color is orange.

6. Laying Out Bricks

bricks = []
for x_pos in range(-65, 75, 10):
    for y_pos in range(3, 7):
        brick = vortex.Object(model='quad', x=x_pos/10, y=y_pos/3, scale=(0.9, 0.3), collider='box', color=vortex.color("red"))
        bricks.append(brick)
// Some code

Explanation:

  • Bricks are created in a grid pattern using nested loops.

  • x_pos and y_pos: These loops define the position of each brick on the screen.

  • bricks list: Each brick is stored in the bricks list for easy reference.

  • color=vortex.color("red"): All bricks are colored red.

7. Initializing Score

score = 0

Explanation:

  • A simple score counter is initialized to zero. The score increases each time the ball hits and destroys a brick.

8. Updating Ball Speed Based on Score

def update_ball_speed():
    global score
    speed_multiplier = 1 + (score / 10) * 0.1  # Adjust the factor as needed
    ball.dx = 0.05 * speed_multiplier if ball.dx > 0 else -0.05 * speed_multiplier
    ball.dy = 0.05 * speed_multiplier if ball.dy > 0 else -0.05 * speed_multiplier
// Some code

Explanation:

  • As the score increases, the ball’s speed increases to make the game progressively more difficult.

  • The speed_multiplier is calculated based on the score and is applied to the ball’s velocity.

9. Main Game Loop (update function)

def update():
    global score
    ball.x += ball.dx
    ball.y += ball.dy
    paddle.x += (held_keys['right arrow'] - held_keys['left arrow']) * time.dt * 5
    
    hit_info = ball.intersects()
    if hit_info.hit:
        if hit_info.entity == left_wall or hit_info.entity == right_wall:
            ball.dx = -ball.dx
        if hit_info.entity == ceiling:
            ball.dy = -ball.dy
        if hit_info.entity in bricks:
            destroy(hit_info.entity)
            bricks.remove(hit_info.entity)
            ball.dy = -ball.dy
            score += 1  # Increment score
            update_ball_speed()  # Update ball speed based on new score
        if hit_info.entity == paddle:
            ball.dy = -ball.dy
            ball.dx = 0.05 * (ball.x - paddle.x)
    
    if ball.y < -5:
        message = vortex.Label(text='You LOST', scale=2, origin=(0, 0), background=True, color=vortex.color("blue"))
        vortex.UpdateBlock()
        print("working..")
        application.pause()
    
    if len(bricks) == 0:
        message = vortex.Label(text='You WON', scale=2, origin=(0, 0), background=True, color=vortex.color("blue"))
        application.pause()
// Some code

Explanation:

  • Ball Movement: The ball’s position is updated by adding its velocity (dx, dy) to its current position.

  • Paddle Movement: The paddle moves left or right based on user input (held_keys for arrow keys).

  • Collision Detection: The intersects() method checks if the ball has collided with any other object.

    • If it hits a wall, the ball’s direction is reversed (ball.dx = -ball.dx).

    • If it hits a brick, the brick is destroyed, and the score is incremented. The ball’s speed is updated accordingly.

    • If the ball hits the paddle, its direction is reversed, and the horizontal velocity (dx) is adjusted based on the collision point.

  • Game Over Conditions:

    • If the ball falls below the paddle (ball.y < -5), the game is paused, and a "You LOST" message is displayed.

    • If all bricks are destroyed, a "You WON" message is displayed, and the game is paused.

10. Running the Game

vortex.run()

Explanation:

  • This method starts the game loop, running all the logic defined in the update function continuously until the game ends.

11. Packaging the Game (Optional)

If you want to create an executable from this Python script, you would typically use a tool like PyInstaller or PyShield. The packaging function package_game in the Vortex engine could be used to automate this process.

PreviousAdditional Resources

Last updated