Build a Simple AI‑Powered Tetris Game with Python

Preface

Use a simple algorithm to create an AI‑enabled Tetris mini‑game.

Demo

Development Tools

Python version 3.6.4, PyQt5 module, and standard Python libraries.

Environment Setup

Install Python, add it to the system PATH, then use pip to install the required modules.

Principle Overview

AI source code implementation

The algorithm enumerates all possible placements of the current and next tetromino, evaluates each resulting board, and selects the action with the highest score.

# Simple AI algorithm
for d_now in current_direction_range:
    x_now_min, x_now_max, y_now_min, y_now_max = self.inner_board.current_tetris.getRelativeBoundary(d_now)
    for x_now in range(-x_now_min, self.inner_board.width - x_now_max):
        board = self.getFinalBoardData(d_now, x_now)
        for d_next in next_direction_range:
            x_next_min, x_next_max, y_next_min, y_next_max = self.inner_board.next_tetris.getRelativeBoundary(d_next)
            distances = self.getDropDistances(board, d_next, range(-x_next_min, self.inner_board.width-x_next_max))
            for x_next in range(-x_next_min, self.inner_board.width-x_next_max):
                score = self.calcScore(copy.deepcopy(board), d_next, x_next, distances)
                if not action or action[2] < score:
                    action = [d_now, x_now, score]
return action

The evaluation considers cleared lines, holes, block count, highest column, height variance, first‑order differences, and the range between highest and lowest points.

# Hole statistics
hole_statistic_0 = [0] * width
hole_statistic_1 = [0] * width
# Block count
num_blocks = 0
# Hole count
num_holes = 0
# Highest point per column
roof_y = [0] * width
for y in range(height-1, -1, -1):
    has_hole = False
    has_block = False
    for x in range(width):
        if board[x + y * width] == tetrisShape().shape_empty:
            has_hole = True
            hole_statistic_0[x] += 1
        else:
            has_block = True
            roof_y[x] = height - y
            if hole_statistic_0[x] > 0:
                hole_statistic_1[x] += hole_statistic_0[x]
                hole_statistic_0[x] = 0
            if hole_statistic_1[x] > 0:
                num_blocks += 1
    if not has_block:
        break
    if not has_hole and has_block:
        removed_lines += 1
num_holes = sum([i ** .7 for i in hole_statistic_1])
max_height = max(roof_y) - removed_lines
roof_dy = [roof_y[i]-roof_y[i+1] for i in range(len(roof_y)-1)]
if len(roof_y) <= 0:
    roof_y_std = 0
else:
    roof_y_std = math.sqrt(sum([y**2 for y in roof_y]) / len(roof_y) - (sum(roof_y) / len(roof_y)) ** 2)
if len(roof_dy) <= 0:
    roof_dy_std = 0
else:
    roof_dy_std = math.sqrt(sum([dy**2 for dy in roof_dy]) / len(roof_dy) - (sum(roof_dy) / len(roof_dy)) ** 2)
abs_dy = sum([abs(dy) for dy in roof_dy])
max_dy = max(roof_y) - min(roof_y)
score = removed_lines * 1.8 - num_holes * 1.0 - num_blocks * 0.5 - max_height ** 1.5 * 0.02 - roof_y_std * 1e-5 - roof_dy_std * 0.01 - abs_dy * 0.2 - max_dy * 0.3
return score