Geminiに「Pyxelでテトリス作って」とお願いしたら一瞬でできてしまった。ではAI時代の開発者は何をすべきか。

import pyxel
import random

# ブロックの形状
SHAPES = [
    [[1, 1, 1, 1]],  # I
    [[1, 1, 1], [0, 1, 0]],  # T
    [[1, 1, 1], [1, 0, 0]],  # L
    [[1, 1, 1], [0, 0, 1]],  # J
    [[1, 1], [1, 1]],  # O
    [[0, 1, 1], [1, 1, 0]],  # S
    [[1, 1, 0], [0, 1, 1]],  # Z
]

# ブロックの色 (0は空白)
COLORS = [0, 1, 2, 3, 4, 5, 6, 7]

# ゲームボードのサイズ
BOARD_WIDTH = 10
BOARD_HEIGHT = 20

# 落下速度 (フレーム数)
FALL_SPEED = 30

class App:
    def __init__(self):
        pyxel.init(160, 240, title="Tetris")
        self.reset()
        pyxel.run(self.update, self.draw)

    def reset(self):
        self.board = [[0] * BOARD_WIDTH for _ in range(BOARD_HEIGHT)]
        self.current_block = self.new_block()
        self.next_block = self.new_block()
        self.fall_timer = 0
        self.score = 0

    def new_block(self):
        shape = random.choice(SHAPES)
        color = COLORS[SHAPES.index(shape) + 1]
        return {
            "shape": shape,
            "color": color,
            "x": BOARD_WIDTH // 2 - len(shape[0]) // 2,
            "y": -len(shape),
        }

    def update(self):
        if pyxel.btnp(pyxel.KEY_Q):
            pyxel.quit()

        # ブロックの移動
        if pyxel.btnp(pyxel.KEY_LEFT, 10, 1):
            self.move_block(-1, 0)
        if pyxel.btnp(pyxel.KEY_RIGHT, 10, 1):
            self.move_block(1, 0)
        if pyxel.btnp(pyxel.KEY_DOWN, 10, 1):
            self.move_block(0, 1)

        # ブロックの回転
        if pyxel.btnp(pyxel.KEY_UP, 10, 20):
            self.rotate_block()

        # ブロックの落下
        self.fall_timer += 1
        if self.fall_timer >= FALL_SPEED:
            self.fall_timer = 0
            if not self.move_block(0, 1):
                self.place_block()

    def draw(self):
        pyxel.cls(0)
        self.draw_board()
        self.draw_block(self.current_block)
        self.draw_next_block()
        pyxel.text(112, 220, f"Score: {self.score}", 7)

    def draw_board(self):
        for y in range(BOARD_HEIGHT):
            for x in range(BOARD_WIDTH):
                if self.board[y][x]:
                    pyxel.rect(x * 8 + 16, y * 8 + 8, 8, 8, self.board[y][x])

    def draw_block(self, block):
        for y, row in enumerate(block["shape"]):
            for x, cell in enumerate(row):
                if cell:
                    pyxel.rect(
                        (block["x"] + x) * 8 + 16,
                        (block["y"] + y) * 8 + 8,
                        8,
                        8,
                        block["color"],
                    )

    def draw_next_block(self):
        pyxel.text(112, 8, "Next:", 7)
        for y, row in enumerate(self.next_block["shape"]):
            for x, cell in enumerate(row):
                if cell:
                    pyxel.rect(
                        112 + x * 8,
                        24 + y * 8,
                        8,
                        8,
                        self.next_block["color"],
                    )

    def is_valid_move(self, block, x, y, shape=None):
        shape = shape or block["shape"]
        for block_y, row in enumerate(shape):
            for block_x, cell in enumerate(row):
                if cell:
                    board_x, board_y = block["x"] + block_x + x, block["y"] + block_y + y
                    if (
                        board_x < 0
                        or board_x >= BOARD_WIDTH
                        or board_y >= BOARD_HEIGHT
                        or (board_y >= 0 and self.board[board_y][board_x])
                    ):
                        return False
        return True

    def move_block(self, dx, dy):
        if self.is_valid_move(self.current_block, dx, dy):
            self.current_block["x"] += dx
            self.current_block["y"] += dy
            return True
        return False

    def rotate_block(self):
        rotated_shape = [
            [self.current_block["shape"][j][i] for j in range(len(self.current_block["shape"]))]
            for i in range(len(self.current_block["shape"][0]) - 1, -1, -1)
        ]
        if self.is_valid_move(self.current_block, 0, 0, rotated_shape):
            self.current_block["shape"] = rotated_shape

    def place_block(self):
        for y, row in enumerate(self.current_block["shape"]):
            for x, cell in enumerate(row):
                if cell:
                    board_x, board_y = self.current_block["x"] + x, self.current_block["y"] + y
                    if board_y >= 0:
                        self.board[board_y][board_x] = self.current_block["color"]

        # ラインの消去
        lines_cleared = 0
        for y in range(BOARD_HEIGHT):
            if all(self.board[y]):
                del self.board[y]
                self.board.insert(0, [0] * BOARD_WIDTH)
                lines_cleared += 1

        # スコアの加算 (簡略化)
        if lines_cleared > 0:
            self.score += lines_cleared * 100

        self.current_block = self.next_block
        self.next_block = self.new_block()

        # ゲームオーバー判定 (簡略化)
        if not self.is_valid_move(self.current_block, 0, 0):
            self.reset()  # ゲームをリセット

App()