Inheritance diagram for mxvk_wrap.examples.tetris.main.TetrisGame:

Public Member Functions
None	__init__ (self)
	A playable 2D Tetris window using `mxvk_wrap` graphics.
None	draw (self)
None	on_event (self, event)
None	reset (self)

Public Attributes
str	asset_dir = Path(__file__).resolve().parent / "data"
	Load Tetris images, create the board, and start the first piece.
	background = mx.Sprite(self, self.asset_dir / "psychedelic_background.png", vertex_shader=str(self.asset_dir / "sprite.vert.spv"), fragment_shader=str(self.asset_dir / "background.frag.spv"))
	background_start_time = time.monotonic()
list	blocks = [mx.Sprite(self, self.asset_dir / path) for path in BLOCK_FILES]
tuple	cells = ()
	Select and spawn a random tetromino at the top of the board.
	clear_block = mx.Sprite(self, self.asset_dir / "block_gray.png")
float	clear_started = 0.0
	Start a fresh game with an empty board and score.
tuple	clearing_rows = ()
	Start a fresh game with an empty board and score.
float	fall_elapsed = 0.0
	Start a fresh game with an empty board and score.
	font = None
float	frame_accumulator = 0.0
	Start a fresh game with an empty board and score.
bool	game_over = False
	Start a fresh game with an empty board and score.
list	grid = []
	Start a fresh game with an empty board and score.
	last_frame_time = time.monotonic()
	Start a fresh game with an empty board and score.
int	level = 1
	Start a fresh game with an empty board and score.
int	lines = 0
	Start a fresh game with an empty board and score.
bool	mouse_pressed = False
	Handle game controls from MXVK keyboard events.
float	mouse_x = 0.0
	Handle game controls from MXVK keyboard events.
float	mouse_y = 0.0
	Handle game controls from MXVK keyboard events.
int	next_color = 0
	Start a fresh game with an empty board and score.
int	piece_color = 0
	Select and spawn a random tetromino at the top of the board.
int	piece_x = 0
	Select and spawn a random tetromino at the top of the board.
int	piece_y = 0
	Select and spawn a random tetromino at the top of the board.
int	score = 0
	Start a fresh game with an empty board and score.
float	simulation_time = 0.0
	Start a fresh game with an empty board and score.

Protected Member Functions
bool	_clear_flash_visible (self)
bool	_collides (self, int x, int y, tuple[tuple[int, int],...] cells)
None	_draw_cell (self, int color, int board_x, int board_y, int left, int top, int cell_size)
float	_fall_interval (self)
None	_finish_line_clear (self)
Path	_font_path (self)
None	_hard_drop (self)
None	_lock_piece (self)
bool	_move (self, int offset_x, int offset_y)
None	_new_piece (self)
None	_rotate (self)
None	_simulate_step (self)
None	_update (self)

Detailed Description

Definition at line 50 of file main.py.

Constructor & Destructor Documentation

◆ init()

None mxvk_wrap.examples.tetris.main.TetrisGame.__init__ ( self )

A playable 2D Tetris window using mxvk_wrap graphics.

Definition at line 53 of file main.py.

    def __init__(self) -> None:
        ## @brief Load Tetris images, create the board, and start the first piece.
        self.asset_dir = Path(__file__).resolve().parent / "data"
        super().__init__("MXVK Wrap 2D Tetris", 960, 720, vsync=True)
        self.font = None
        try:
            self.font = mx.Font(self._font_path(), 24)
            self.background = mx.Sprite(self, self.asset_dir / "psychedelic_background.png", vertex_shader=str(self.asset_dir / "sprite.vert.spv"), fragment_shader=str(self.asset_dir / "background.frag.spv"))
            self.background.enable_extended_uniforms()
            self.blocks = [mx.Sprite(self, self.asset_dir / path) for path in BLOCK_FILES]
            self.clear_block = mx.Sprite(self, self.asset_dir / "block_gray.png")
        except Exception:
            if self.font is not None:
                self.font.close()
            self.close()
            raise
        self.grid: list[list[int]] = []
        self.cells: tuple[tuple[int, int], ...] = ()
        self.piece_color = 0
        self.next_color = 0
        self.piece_x = 0
        self.piece_y = 0
        self.score = 0
        self.lines = 0
        self.level = 1
        self.game_over = False
        self.clearing_rows: tuple[int, ...] = ()
        self.clear_started = 0.0
        self.background_start_time = time.monotonic()
        self.mouse_x = 0.0
        self.mouse_y = 0.0
        self.mouse_pressed = False
        self.simulation_time = 0.0
        self.fall_elapsed = 0.0
        self.frame_accumulator = 0.0
        self.last_frame_time = time.monotonic()
        self.reset()
 

Member Function Documentation

◆ _clear_flash_visible()

bool mxvk_wrap.examples.tetris.main.TetrisGame._clear_flash_visible ( self )

protected

Definition at line 189 of file main.py.

    def _clear_flash_visible(self) -> bool:
        ## @brief Return whether completed rows should show the flash texture.
        return int((self.simulation_time - self.clear_started) / CLEAR_FLASH_INTERVAL) % 2 == 0
 

◆ _collides()

bool mxvk_wrap.examples.tetris.main.TetrisGame._collides	(		self,
		int	x,
		int	y,
		tuple[tuple[int, int], ...]	cells )

protected

Definition at line 125 of file main.py.

    def _collides(self, x: int, y: int, cells: tuple[tuple[int, int], ...]) -> bool:
        ## @brief Return whether a piece position overlaps a wall, floor, or block.
        ## @param x Candidate board X coordinate.
        ## @param y Candidate board Y coordinate.
        ## @param cells Tetromino cells relative to @p x and @p y.
        ## @return True when the placement is invalid.
        for cell_x, cell_y in cells:
            board_x = x + cell_x
            board_y = y + cell_y
            if board_x < 0 or board_x >= BOARD_WIDTH or board_y >= BOARD_HEIGHT:
                return True
            if board_y >= 0 and self.grid[board_y][board_x] != EMPTY:
                return True
        return False
 

◆ _draw_cell()

None mxvk_wrap.examples.tetris.main.TetrisGame._draw_cell	(		self,
		int	color,
		int	board_x,
		int	board_y,
		int	left,
		int	top,
		int	cell_size )

protected

Definition at line 268 of file main.py.

    def _draw_cell(self, color: int, board_x: int, board_y: int, left: int, top: int, cell_size: int) -> None:
        ## @brief Queue one block sprite at a board location.
        ## @param color Index into the loaded block sprites.
        ## @param board_x Board column.
        ## @param board_y Board row.
        ## @param left Board left screen coordinate.
        ## @param top Board top screen coordinate.
        ## @param cell_size Block width and height in pixels.
        self.blocks[color].draw(left + board_x * cell_size, top + board_y * cell_size, width=cell_size, height=cell_size)
 

◆ _fall_interval()

float mxvk_wrap.examples.tetris.main.TetrisGame._fall_interval ( self )

protected

Definition at line 203 of file main.py.

    def _fall_interval(self) -> float:
        ## @brief Return the current automatic drop interval in seconds.
        return max(0.08, 0.75 - (self.level - 1) * 0.06)
 

◆ _finish_line_clear()

None mxvk_wrap.examples.tetris.main.TetrisGame._finish_line_clear ( self )

protected

Definition at line 177 of file main.py.

    def _finish_line_clear(self) -> None:
        ## @brief Collapse flashing rows, award points, and spawn the next piece.
        cleared = len(self.clearing_rows)
        cleared_rows = set(self.clearing_rows)
        self.grid = [[EMPTY for _ in range(BOARD_WIDTH)] for _ in range(cleared)] + [row for index, row in enumerate(self.grid) if index not in cleared_rows]
        self.lines += cleared
        self.score += (0, 100, 300, 500, 800)[cleared] * self.level
        self.level = self.lines // 10 + 1
        self.clearing_rows = ()
        self.clear_started = 0.0
        self._new_piece()
 

◆ _font_path()

Path mxvk_wrap.examples.tetris.main.TetrisGame._font_path ( self )

protected

Definition at line 91 of file main.py.

    def _font_path(self) -> Path:
        ## @brief Return the supplied Tetris font path.
        ## @return The TrueType font stored beside the Tetris block artwork.
        path = self.asset_dir / "font.ttf"
        if not path.is_file():
            raise FileNotFoundError(f"missing Tetris font: {path}")
        return path
 

◆ _hard_drop()

None mxvk_wrap.examples.tetris.main.TetrisGame._hard_drop ( self )

protected

Definition at line 193 of file main.py.

    def _hard_drop(self) -> None:
        ## @brief Drop the active piece to its lowest valid row and lock it.
        if self.game_over:
            return
        distance = 0
        while self._move(0, 1):
            distance += 1
        self.score += distance * 2
        self._lock_piece()
 

◆ _lock_piece()

None mxvk_wrap.examples.tetris.main.TetrisGame._lock_piece ( self )

protected

Definition at line 165 of file main.py.

    def _lock_piece(self) -> None:
        ## @brief Merge the active piece into the board and clear completed lines.
        for cell_x, cell_y in self.cells:
            board_y = self.piece_y + cell_y
            if board_y >= 0:
                self.grid[board_y][self.piece_x + cell_x] = self.piece_color
        self.clearing_rows = tuple(index for index, row in enumerate(self.grid) if EMPTY not in row)
        if self.clearing_rows:
            self.clear_started = self.simulation_time
            return
        self._new_piece()
 

◆ _move()

bool mxvk_wrap.examples.tetris.main.TetrisGame._move	(		self,
		int	offset_x,
		int	offset_y )

protected

Definition at line 140 of file main.py.

    def _move(self, offset_x: int, offset_y: int) -> bool:
        ## @brief Move the active piece when its target placement is valid.
        ## @param offset_x Horizontal cell offset.
        ## @param offset_y Vertical cell offset.
        ## @return True when the piece moved.
        if self.game_over or self._collides(self.piece_x + offset_x, self.piece_y + offset_y, self.cells):
            return False
        self.piece_x += offset_x
        self.piece_y += offset_y
        return True
 

◆ _new_piece()

None mxvk_wrap.examples.tetris.main.TetrisGame._new_piece ( self )

protected

Definition at line 115 of file main.py.

    def _new_piece(self) -> None:
        ## @brief Select and spawn a random tetromino at the top of the board.
        self.piece_color = self.next_color
        self.next_color = random.randrange(len(PIECES))
        self.cells = PIECES[self.piece_color]
        self.piece_x = 3
        self.piece_y = 0
        if self._collides(self.piece_x, self.piece_y, self.cells):
            self.game_over = True
 

◆ _rotate()

None mxvk_wrap.examples.tetris.main.TetrisGame._rotate ( self )

protected

Definition at line 151 of file main.py.

    def _rotate(self) -> None:
        ## @brief Rotate the active piece clockwise, with simple wall kicks.
        if self.game_over or self.piece_color == 3:
            return
        rotated = tuple((-cell_y, cell_x) for cell_x, cell_y in self.cells)
        minimum_x = min(cell_x for cell_x, _ in rotated)
        minimum_y = min(cell_y for _, cell_y in rotated)
        rotated = tuple((cell_x - minimum_x, cell_y - minimum_y) for cell_x, cell_y in rotated)
        for kick in (0, -1, 1, -2, 2):
            if not self._collides(self.piece_x + kick, self.piece_y, rotated):
                self.cells = rotated
                self.piece_x += kick
                return
 

◆ _simulate_step()

None mxvk_wrap.examples.tetris.main.TetrisGame._simulate_step ( self )

protected

Definition at line 207 of file main.py.

    def _simulate_step(self) -> None:
        ## @brief Advance one fixed-rate simulation step independent of rendering.
        if self.clearing_rows:
            if self.simulation_time - self.clear_started >= CLEAR_FLASH_DURATION:
                self._finish_line_clear()
            return
        if self.game_over:
            return
        self.fall_elapsed += SIMULATION_STEP
        while self.fall_elapsed >= self._fall_interval():
            self.fall_elapsed -= self._fall_interval()
            if not self._move(0, 1):
                self._lock_piece()
                return
 

◆ _update()

None mxvk_wrap.examples.tetris.main.TetrisGame._update ( self )

protected

Definition at line 222 of file main.py.

    def _update(self) -> None:
        ## @brief Run fixed 60 Hz simulation steps to keep game timing frame-rate independent.
        now = time.monotonic()
        elapsed = min(now - self.last_frame_time, MAX_FRAME_DELTA)
        self.last_frame_time = now
        self.frame_accumulator += max(0.0, elapsed)
        while self.frame_accumulator >= SIMULATION_STEP:
            self.frame_accumulator -= SIMULATION_STEP
            self.simulation_time += SIMULATION_STEP
            self._simulate_step()
 

◆ draw()

None mxvk_wrap.examples.tetris.main.TetrisGame.draw ( self )

Definition at line 278 of file main.py.

    def draw(self) -> None:
        ## @brief Draw the background, playfield, active piece, and HUD each frame.
        self._update()
        width, height = self.swapchain_extent
        if width <= 0 or height <= 0:
            return
        self.background.set_mouse(self.mouse_x, self.mouse_y, self.mouse_pressed)
        self.background.set_uniform(0, 0.0, 0.0, float(width), float(height))
        self.background.set_uniform(2, 0.0, time.monotonic() - self.background_start_time, 0.0, 0.0)
        self.background.draw(0, 0, width=width, height=height)
        cell_size = max(16, min((height - 100) // (BOARD_HEIGHT + 1), (width - 260) // (BOARD_WIDTH + 2)))
        board_width = BOARD_WIDTH * cell_size
        board_height = BOARD_HEIGHT * cell_size
        left = max(24, (width - board_width) // 2 - 100)
        top = max(50, (height - board_height) // 2)
        for board_y, row in enumerate(self.grid):
            for board_x, color in enumerate(row):
                if color != EMPTY:
                    if board_y in self.clearing_rows and self._clear_flash_visible():
                        self.clear_block.draw(left + board_x * cell_size, top + board_y * cell_size, width=cell_size, height=cell_size)
                    else:
                        self._draw_cell(color, board_x, board_y, left, top, cell_size)
        if not self.game_over and not self.clearing_rows:
            for cell_x, cell_y in self.cells:
                self._draw_cell(self.piece_color, self.piece_x + cell_x, self.piece_y + cell_y, left, top, cell_size)
        panel_x = left + board_width + 28
        self.draw_text("2D TETRIS", panel_x, top, self.font, mx.Color(255, 245, 180))
        self.draw_text(f"Score  {self.score}", panel_x, top + 54, self.font)
        self.draw_text(f"Lines  {self.lines}", panel_x, top + 88, self.font, mx.Color(180, 225, 255))
        self.draw_text(f"Level  {self.level}", panel_x, top + 122, self.font, mx.Color(180, 255, 190))
        self.draw_text("Next", panel_x, top + 182, self.font, mx.Color(255, 245, 180))
        preview_cell = max(12, cell_size * 3 // 5)
        preview_cells = PIECES[self.next_color]
        preview_min_x = min(cell_x for cell_x, _ in preview_cells)
        preview_min_y = min(cell_y for _, cell_y in preview_cells)
        for cell_x, cell_y in preview_cells:
            self.blocks[self.next_color].draw(panel_x + (cell_x - preview_min_x) * preview_cell, top + 220 + (cell_y - preview_min_y) * preview_cell, width=preview_cell, height=preview_cell)
        self.draw_text("Arrows: move / rotate", panel_x, top + 340, self.font)
        self.draw_text("Space: hard drop", panel_x, top + 374, self.font)
        if self.game_over:
            self.draw_text("GAME OVER", left + cell_size, top + board_height // 2 - 24, self.font, mx.Color(255, 100, 100))
            self.draw_text("Press R to restart", left + cell_size, top + board_height // 2 + 14, self.font, mx.Color(255, 255, 255))
 
 

◆ on_event()

None mxvk_wrap.examples.tetris.main.TetrisGame.on_event	(		self,
			event )

Definition at line 233 of file main.py.

    def on_event(self, event) -> None:
        ## @brief Handle game controls from MXVK keyboard events.
        ## @param event MXVK event received by @c App.
        if event.mouse_motion:
            self.mouse_x = event.x
            self.mouse_y = event.y
            return
        if event.mouse_button_down or event.mouse_button_up:
            self.mouse_x = event.x
            self.mouse_y = event.y
            self.mouse_pressed = event.mouse_button_down
            return
        if not event.key_down:
            return
        if event.key == mx.KEY_ESCAPE:
            self.quit()
        elif self.clearing_rows:
            return
        elif self.game_over:
            if event.key == mx.KEY_R:
                self.reset()
        elif event.key == mx.KEY_LEFT:
            self._move(-1, 0)
        elif event.key == mx.KEY_RIGHT:
            self._move(1, 0)
        elif event.key == mx.KEY_DOWN:
            if self._move(0, 1):
                self.score += 1
            else:
                self._lock_piece()
        elif event.key == mx.KEY_UP:
            self._rotate()
        elif event.key == mx.KEY_SPACE:
            self._hard_drop()
 

◆ reset()

None mxvk_wrap.examples.tetris.main.TetrisGame.reset ( self )

Definition at line 99 of file main.py.

    def reset(self) -> None:
        ## @brief Start a fresh game with an empty board and score.
        self.grid = [[EMPTY for _ in range(BOARD_WIDTH)] for _ in range(BOARD_HEIGHT)]
        self.score = 0
        self.lines = 0
        self.level = 1
        self.game_over = False
        self.clearing_rows = ()
        self.clear_started = 0.0
        self.simulation_time = 0.0
        self.fall_elapsed = 0.0
        self.frame_accumulator = 0.0
        self.last_frame_time = time.monotonic()
        self.next_color = random.randrange(len(PIECES))
        self._new_piece()
 

Member Data Documentation

◆ asset_dir

str mxvk_wrap.examples.tetris.main.TetrisGame.asset_dir = Path(__file__).resolve().parent / "data"

Load Tetris images, create the board, and start the first piece.

Definition at line 55 of file main.py.

◆ background

mxvk_wrap.examples.tetris.main.TetrisGame.background = mx.Sprite(self, self.asset_dir / "psychedelic_background.png", vertex_shader=str(self.asset_dir / "sprite.vert.spv"), fragment_shader=str(self.asset_dir / "background.frag.spv"))

Definition at line 60 of file main.py.

◆ background_start_time

mxvk_wrap.examples.tetris.main.TetrisGame.background_start_time = time.monotonic()

Definition at line 81 of file main.py.

◆ blocks

list mxvk_wrap.examples.tetris.main.TetrisGame.blocks = [mx.Sprite(self, self.asset_dir / path) for path in BLOCK_FILES]

Definition at line 62 of file main.py.

◆ cells

mxvk_wrap.examples.tetris.main.TetrisGame.cells = ()

Select and spawn a random tetromino at the top of the board.

Move the active piece when its target placement is valid.

Parameters

offset_x	Horizontal cell offset.
offset_y	Vertical cell offset.

Returns: True when the piece moved.

Definition at line 70 of file main.py.

◆ clear_block

mxvk_wrap.examples.tetris.main.TetrisGame.clear_block = mx.Sprite(self, self.asset_dir / "block_gray.png")

Definition at line 63 of file main.py.

◆ clear_started

mxvk_wrap.examples.tetris.main.TetrisGame.clear_started = 0.0

Start a fresh game with an empty board and score.

Return whether completed rows should show the flash texture.

Definition at line 80 of file main.py.

◆ clearing_rows

tuple mxvk_wrap.examples.tetris.main.TetrisGame.clearing_rows = ()

Start a fresh game with an empty board and score.

Definition at line 79 of file main.py.

◆ fall_elapsed

float mxvk_wrap.examples.tetris.main.TetrisGame.fall_elapsed = 0.0

Start a fresh game with an empty board and score.

Definition at line 86 of file main.py.

◆ font

mxvk_wrap.examples.tetris.main.TetrisGame.font = None

Definition at line 57 of file main.py.

◆ frame_accumulator

float mxvk_wrap.examples.tetris.main.TetrisGame.frame_accumulator = 0.0

Start a fresh game with an empty board and score.

Definition at line 87 of file main.py.

◆ game_over

bool mxvk_wrap.examples.tetris.main.TetrisGame.game_over = False

Start a fresh game with an empty board and score.

Definition at line 78 of file main.py.

◆ grid

mxvk_wrap.examples.tetris.main.TetrisGame.grid = []

Start a fresh game with an empty board and score.

Definition at line 69 of file main.py.

◆ last_frame_time

mxvk_wrap.examples.tetris.main.TetrisGame.last_frame_time = time.monotonic()

Start a fresh game with an empty board and score.

Definition at line 88 of file main.py.

◆ level

int mxvk_wrap.examples.tetris.main.TetrisGame.level = 1

Start a fresh game with an empty board and score.

Definition at line 77 of file main.py.

◆ lines

int mxvk_wrap.examples.tetris.main.TetrisGame.lines = 0

Start a fresh game with an empty board and score.

Definition at line 76 of file main.py.

◆ mouse_pressed

mxvk_wrap.examples.tetris.main.TetrisGame.mouse_pressed = False

Handle game controls from MXVK keyboard events.

Parameters

event MXVK event received by App.

Definition at line 84 of file main.py.

◆ mouse_x

mxvk_wrap.examples.tetris.main.TetrisGame.mouse_x = 0.0

Handle game controls from MXVK keyboard events.

Parameters

event MXVK event received by App.

Definition at line 82 of file main.py.

◆ mouse_y

mxvk_wrap.examples.tetris.main.TetrisGame.mouse_y = 0.0

Handle game controls from MXVK keyboard events.

Parameters

event MXVK event received by App.

Definition at line 83 of file main.py.

◆ next_color

int mxvk_wrap.examples.tetris.main.TetrisGame.next_color = 0

Start a fresh game with an empty board and score.

Definition at line 72 of file main.py.

◆ piece_color

mxvk_wrap.examples.tetris.main.TetrisGame.piece_color = 0

Select and spawn a random tetromino at the top of the board.

Definition at line 71 of file main.py.

◆ piece_x

mxvk_wrap.examples.tetris.main.TetrisGame.piece_x = 0

Select and spawn a random tetromino at the top of the board.

Definition at line 73 of file main.py.

◆ piece_y

mxvk_wrap.examples.tetris.main.TetrisGame.piece_y = 0

Select and spawn a random tetromino at the top of the board.

Definition at line 74 of file main.py.

◆ score

int mxvk_wrap.examples.tetris.main.TetrisGame.score = 0

Start a fresh game with an empty board and score.

Definition at line 75 of file main.py.

◆ simulation_time

float mxvk_wrap.examples.tetris.main.TetrisGame.simulation_time = 0.0

Start a fresh game with an empty board and score.

Definition at line 85 of file main.py.

The documentation for this class was generated from the following file:

python-examples/mxvk_wrap/examples/tetris/main.py

MXVK Vulkan Framework 0.35.0 C++20 Vulkan rendering framework for practical 2D and 3D application development with SDL3.

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _clear_flash_visible()

◆ _collides()

◆ _draw_cell()

◆ _fall_interval()

◆ _finish_line_clear()

◆ _font_path()

◆ _hard_drop()

◆ _lock_piece()

◆ _move()

◆ _new_piece()

◆ _rotate()

◆ _simulate_step()

◆ _update()

◆ draw()

◆ on_event()

◆ reset()

Member Data Documentation

◆ asset_dir

◆ background

◆ background_start_time

◆ blocks

◆ cells

◆ clear_block

◆ clear_started

◆ clearing_rows

◆ fall_elapsed

◆ font

◆ frame_accumulator

◆ game_over

◆ grid

◆ last_frame_time

◆ level

◆ lines

◆ mouse_pressed

◆ mouse_x

◆ mouse_y

◆ next_color

◆ piece_color

◆ piece_x

◆ piece_y

◆ score

◆ simulation_time

◆ init()