Текстовый водяной знак LLM: не нужно бояться, нужно знать

## Вотермаркинг в текстовых LLM (например, SynthID): Краткий обзор

**Что это такое?**

Вотермаркинг (водяные знаки) в контексте больших языковых моделей (LLM) — это **незаметный, математически внедренный, но детектуемый паттерн**, вносимый в сгенерированный текст (или другой медиафайл), который свидетельствует о том, что этот контент был создан конкретной, контролируемой моделью (например, вашей компанией).

**Цель SynthID (или аналогичных систем):**

Главная цель — **происхождение контента (Provenance)** и **атрибуция**. В эпоху, когда ИИ может генерировать убедительный "фейк" в любой форме, вотермаркинг помогает ответить на критически важный вопрос: **"Сгенерировал ли этот текст ИИ, и какая именно модель/компания его использовала?"**

**Как это работает (Упрощенно)?**

Процесс внедрения вотермарки осуществляется **на этапе генерации** (или тонкой настройки модели):

1. **Инъекция предвзятости:** Вместо того чтобы просто предсказывать следующее наиболее вероятное слово, разработчики принудительно "направляют" или "подталкивают" модель к выбору определенных, очень слабо выраженных, но статистически предсказуемых паттернов при генерации текста.
2. **Неосознанное встраивание:** Эти паттерны внедряются таким образом, что они **не меняют значительно смысл, поток или качество** текста, делая его полностью понятным для человека.
3. **Детекция:** Когда контент попадает к инструменту детекции (анализатору вотермарков), этот инструмент умеет "читать" эти специфические, математически вшитые отклонения от случайной генерации. Он может затем с высокой степенью уверенности определить:
    * Что текст сгенерирован LLM.
    * И, возможно, какими параметрами или версией этой LLM.

**Отличие от обычного водяного знака:**

Обый водяной знак — это видимый элемент (логотип в изображении). Цифровой вотермарк в LLM — это **статистический, статистико-семантический отпечаток**, скрытый в вероятностной структуре сгенерированного текста.

**Почему это важно сегодня?**

Усилия в этом направлении становятся критически важными из-за роста угроз, связанных с дипфейками и массовой дезинформацией. Он помогает устанавливать ответственность за сгенерированный контент.

## Вотермаркинг в текстовых LLM (например, SynthID): краткий обзор

### Что это такое?

Вотермаркинг (встраивание цифровых водяных знаков) в контексте больших языковых моделей (LLM) - это **незаметный для человека, математически встроенный, но обнаруживаемый статистический паттерн**, который добавляется в генерируемый текст (или другой медиаконтент). Такой паттерн позволяет установить, что контент был создан определенной моделью или системой генерации.

### Цель SynthID и аналогичных систем

Основная задача таких технологий - **установление происхождения контента (Provenance) и его атрибуция**.

В условиях, когда искусственный интеллект способен создавать убедительные поддельные материалы практически любого формата, вотермаркинг помогает ответить на важный вопрос: **"Был ли этот текст сгенерирован ИИ и можно ли установить систему, которая его создала?"**

### Как это работает (упрощенно)?

Встраивание водяного знака обычно происходит **непосредственно на этапе генерации текста**, когда модель выбирает следующие токены.

1. **Корректировка вероятностей.** Вместо стандартного выбора следующего токена система немного изменяет вероятности отдельных вариантов. Это позволяет формировать слабовыраженные, но статистически распознаваемые закономерности в генерируемом тексте.

2. **Незаметное встраивание.** Эти закономерности внедряются так, чтобы **существенно не влиять на смысл, связность и качество текста**. Для обычного читателя результат практически не отличается от текста без водяного знака.

3. **Детекция.** Специальный инструмент анализирует текст и ищет характерные статистические отклонения, соответствующие алгоритму вотермаркинга. При наличии достаточного объема текста он может с определенной степенью уверенности установить:
   - Присутствует ли водяной знак, указывающий на генерацию с помощью ИИ.
   - В некоторых реализациях - какой системой или моделью был создан текст, если механизм предусматривает такую атрибуцию.

При этом отсутствие обнаруженного водяного знака само по себе не означает, что текст написан человеком.

### Отличие от обычного водяного знака

Традиционный водяной знак - это, как правило, видимый элемент, например логотип на изображении.

Цифровой вотермарк в LLM представляет собой **скрытый статистический отпечаток**, встроенный в вероятностную структуру сгенерированного текста. Он не воспринимается визуально и выявляется только специальными алгоритмами анализа.

### Почему это важно сегодня?

Развитие подобных технологий становится особенно актуальным на фоне распространения дипфейков, автоматически генерируемого контента и массовой дезинформации.

Вотермаркинг позволяет повысить прозрачность происхождения материалов, облегчить проверку их подлинности и создать дополнительные механизмы ответственности за использование генеративного ИИ.

Однако технология не дает абсолютных гарантий: редактирование, перефразирование или перевод текста могут затруднить обнаружение водяного знака либо полностью его удалить.

## Вотермаркинг в текстовых LLM (например, SynthID): Краткий обзор

**Что это такое?**

Вотермаркинг (водяные знаки) в контексте больших языковых моделей (LLM) — это **скрытый, математически внедренный, но опознаваемый след**, вносимый в полученный текст (или иной медиафайл), который доказывает, что этот контент был создан определённой, контролируемой моделью (например, вашей корпорацией).

**Цель SynthID (или аналогичных систем):**

Основная задача — **прослеживаемость контента (Provenance)** и **идентификация источника**. В епоху, когда ИИ способен генерировать убедительную фальсификацию в любом виде, вотермаркинг помогает ответить на ключевой вопрос: **"Создано ли это сообщение ИИ, и какая именно модель/компания его использовала?"**

**Как это работает (Упрощенно)?**

Процесс встраивания вотермарка происходит **на этапе создания** (или донастройки модели):

1. **Внедрение предвзятости:** Вместо того чтобы просто предсказывать следующее наиболее вероятное слово, разработчики настойчиво "направляют" или "подталкивают" модель к выбору определённых, очень слабых, но статистически прогнозируемых закономерностей при создании текста.
2. **Подсознательное встраивание:** Эти закономерности встраиваются таким образом, что они **существенно не меняют значение, повествовательность или качество** текста, оставляя его полностью понятным для человека.
3. **Обнаружение:** Когда контент попадает к инструменту обнаружения (анализатору вотермарков), этот инструмент умеет "считывать" эти особые, математически зашитые смещения от случайной генерации. Он затем способен с высокой уверенностью установить:
    * Что текст создан LLM.
    * И, возможно, какими параметрами или версией этой LLM.

**Отличие от обычного водяного знака:**

Обый водяной знак — это видимое дополнение (эмблема в изображении). Цифровой вотермарк в LLM — это **статистический, семантико-статистический отпечаток**, скрытый в вероятностной структуре сгенерированного текста.

**Почему это важно сегодня?**

Усилия в этом направлении приобретают решающее значение из-за нарастающих угроз, связанных с дипфейками и широким распространением фейков. Он помогает установить подотчетность за сгенерированный контент.

Введение
С развитием больших языковых моделей (LLM, Large Language Models) и стремительным распространением генеративного искусственного интеллекта возникает все более серьезная проблема определения происхождения цифрового контента. Современные нейросети способны создавать тексты, которые по стилю, структуре и содержанию практически неотличимы от написанных человеком. При этом традиционные методы обнаружения автоматически сгенерированного текста, основанные на анализе его лингвистических особенностей, не обеспечивают достаточной надежности, особенно при использовании современных моделей. Это создает риски массового распространения дезинформации, манипулирования общественным мнением, подделки документов и злоупотребления технологиями искусственного интеллекта. Одним из перспективных подходов к решению данной проблемы является технология цифровых водяных знаков, или вотермаркинг (Watermarking), позволяющая встраивать в генерируемый контент специальные признаки, которые впоследствии могут быть обнаружены алгоритмическими методами. В отличие от обычной классификации текстов, пытающейся определить их происхождение по косвенным характеристикам, вотермаркинг предполагает целенаправленное внедрение статистически распознаваемых закономерностей непосредственно в процессе генерации. Особый интерес представляет технология SynthID, разработанная Google DeepMind, которая демонстрирует возможность интеграции подобных механизмов в современные генеративные модели без существенного ухудшения качества создаваемого текста. Рассмотрение принципов работы таких систем позволяет понять не только технические возможности идентификации контента, созданного искусственным интеллектом, но и существующие ограничения, связанные с надежностью обнаружения, устойчивостью к редактированию и необходимостью доверия к разработчикам соответствующих инструментов.

## Вотермаркинг в текстовых LLM (например, SynthID): Краткий обзор

**Что это такое?**

Вотермаркинг (водяные знаки) в контексте больших языковых моделей (LLM) — это **незаметный, математически внедренный, но детектуемый паттерн**, вносимый в сгенерированный текст (или другой медиафайл), который свидетельствует о том, что этот контент был создан конкретной, контролируемой моделью (например, вашей компанией).

**Цель SynthID (или аналогичных систем):**

Главная цель — **происхождение контента (Provenance)** и **атрибуция**. В эпоху, когда ИИ может генерировать убедительный "фейк" в любой форме, вотермаркинг помогает ответить на критически важный вопрос: **"Сгенерировал ли этот текст ИИ, и какая именно модель/компания его использовала?"**

**Как это работает (Упрощенно)?**

Процесс внедрения вотермарки осуществляется **на этапе генерации** (или тонкой настройки модели):

1. **Инъекция предвзятости:** Вместо того чтобы просто предсказывать следующее наиболее вероятное слово, разработчики принудительно "направляют" или "подталкивают" модель к выбору определенных, очень слабо выраженных, но статистически предсказуемых паттернов при генерации текста.
2. **Неосознанное встраивание:** Эти паттерны внедряются таким образом, что они **не меняют значительно смысл, поток или качество** текста, делая его полностью понятным для человека.
3. **Детекция:** Когда контент попадает к инструменту детекции (анализатору вотермарков), этот инструмент умеет "читать" эти специфические, математически вшитые отклонения от случайной генерации. Он может затем с высокой степенью уверенности определить:
    * Что текст сгенерирован LLM.
    * И, возможно, какими параметрами или версией этой LLM.

**Отличие от обычного водяного знака:**

Обый водяной знак — это видимый элемент (логотип в изображении). Цифровой вотермарк в LLM — это **статистический, статистико-семантический отпечаток**, скрытый в вероятностной структуре сгенерированного текста.

**Почему это важно сегодня?**

Усилия в этом направлении становятся критически важными из-за роста угроз, связанных с дипфейками и массовой дезинформацией. Он помогает устанавливать ответственность за сгенерированный контент.
Заключение
Таким образом, вотермаркинг текстов, генерируемых большими языковыми моделями, представляет собой важное технологическое направление, ориентированное на повышение прозрачности и контролируемости применения генеративного искусственного интеллекта. Его принципиальное преимущество заключается в возможности внедрения специальных статистических признаков непосредственно в процесс формирования текста, без необходимости добавления видимых маркеров или существенного изменения содержания. Такие решения, как SynthID, показывают, что идентификация машинного происхождения текста может осуществляться на основе математического анализа распределения выбранных моделью токенов, а не только путем поиска характерных стилистических особенностей. Вместе с тем важно учитывать, что наличие цифрового водяного знака не гарантирует абсолютной достоверности определения происхождения контента. Перефразирование, перевод, значительное редактирование, сокращение текста или повторная генерация с использованием другой модели способны ослабить либо полностью уничтожить внедренный статистический сигнал. Кроме того, отсутствие обнаруживаемого водяного знака само по себе не означает, что текст был написан человеком, поскольку далеко не все языковые модели поддерживают соответствующие механизмы. Также детектор не обязательно способен установить конкретную версию модели или организацию, создавшую текст: такие возможности зависят от архитектуры системы и используемого метода маркировки. Поэтому вотермаркинг целесообразно рассматривать не как универсальный инструмент доказательства авторства, а как один из компонентов комплексной системы проверки происхождения цифровой информации. В перспективе сочетание цифровых водяных знаков с криптографической подписью, регистрацией происхождения контента и независимыми механизмами верификации может сформировать более надежную инфраструктуру доверия к материалам, создаваемым искусственным интеллектом. При этом эффективность подобных решений будет определяться не только совершенством алгоритмов, но и масштабами их внедрения, совместимостью между различными платформами и устойчивостью к преднамеренным попыткам обхода механизмов обнаружения.

Вотермаркинг в текстовых LLM (например, SynthID): Краткий обзор

Что это такое

Вотермаркинг (водяные знаки) в контексте больших языковых моделей (БЯМ, LLM) — это незаметный, статистически внедренный, но детектуемый паттерн, вносимый в сгенерированный текст, который свидетельствует о том, что этот контент был создан конкретной, контролируемой моделью ИИ (например, вашей компанией).

Цель SynthID:

Главная цель — происхождение контента и атрибуция. В эпоху, когда ИИ может генерировать убедительный “фейк” в любой форме, вотермаркинг помогает ответить на важный вопрос: “Сгенерировал ли этот текст ИИ, и какая именно модель/компания его использовала?”

Как это работает (Упрощенно)

Процесс внедрения вотермарки осуществляется на этапе генерации (семплирования):

1. Инъекция предвзятости: Вместо того чтобы просто семплировать следующее вероятное слово (токен) из распределения, разработчики принудительно “направляют” или “подталкивают” модель к выбору определенных, очень слабо выраженных, но статистически предсказуемых паттернов при генерации текста.

2. Смысл: Эти паттерны внедряются таким образом, что они не меняют значительно смысл, поток или качество текста, оставляя его полностью понятным для человека.

3. Детекция: Когда контент попадает в инструмент детекции (анализатору вотермарков), этот инструмент умеет выделять эти специфические, математически вшитые отклонения от случайности. Он может затем с высокой степенью уверенности определить:

   • Что текст сгенерирован LLM с данным алгоритмом вотермарки.

   • И, возможно, какими параметрами или версией этой LLM (если используются разные ключи).

Отличие от обычного водяного знака:

Обычный водяной знак на рисунке — это видимый элемент (логотип в изображении). Цифровой вотермарк в текстовых LLM — это статистический отпечаток, скрытый в вероятностной структуре сгенерированного текста.

Почему это важно

Усилия в этом направлении становятся критически важными из-за роста угроз, связанных с дипфейками и дезинформацией. Он помогает устанавливать ответственность за сгенерированный контент.

import pygame
import sys
import random

# --- Инициализация Pygame ---
pygame.init()

# --- Константы ---
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
FPS = 60

# Цвета
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)

# Размеры объектов
PADDLE_WIDTH = 100
PADDLE_HEIGHT = 15
BALL_SIZE = 12
BRICK_WIDTH = 70
BRICK_HEIGHT = 30
BRICK_ROWS = 6
BRICK_COLS = 8

# Скорость
PADDLE_SPEED = 8
BALL_INITIAL_SPEED = 7

# --- Настройка экрана ---
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Арканоид")
clock = pygame.time.Clock()

# --- Игровые объекты ---

# 1. Падл (Игрок)
paddle = pygame.Rect(
    (SCREEN_WIDTH - PADDLE_WIDTH) // 2, 
    SCREEN_HEIGHT - 40 - PADDLE_HEIGHT, 
    PADDLE_WIDTH, 
    PADDLE_HEIGHT
)

# 2. Мяч
ball = pygame.Rect(
    SCREEN_WIDTH // 2 - BALL_SIZE // 2, 
    SCREEN_HEIGHT // 2 - BALL_SIZE // 2, 
    BALL_SIZE, 
    BALL_SIZE
)

# Направление движения мяча (dx, dy)
ball_dx = BALL_INITIAL_SPEED * random.choice([-1, 1])
ball_dy = -BALL_INITIAL_SPEED

# 3. Блоки (Кирпичи)
def create_blocks():
    bricks = []
    start_x = (SCREEN_WIDTH - (BRICK_COLS * BRICK_WIDTH)) // 2
    start_y = 50
    
    for row in range(BRICK_ROWS):
        for col in range(BRICK_COLS):
            brick_x = start_x + col * (BRICK_WIDTH + 5) # Добавляем небольшой зазор
            brick_y = start_y + row * (BRICK_HEIGHT + 5)
            
            # Создаем прямоугольник для каждого кирпича
            brick = pygame.Rect(brick_x, brick_y, BRICK_WIDTH, BRICK_HEIGHT)
            bricks.append(brick)
    return bricks

bricks = create_blocks()
score = 0
font = pygame.font.Font(None, 74)
small_font = pygame.font.Font(None, 36)

# --- Игровые переменные ---
running = True
game_over = False
paused = False

# --- Функции ---

def reset_game():
    global ball_dx, ball_dy, paddle, ball, bricks, score, game_over
    
    # Сброс позиции
    paddle.x = (SCREEN_WIDTH - PADDLE_WIDTH) // 2
    ball.x = SCREEN_WIDTH // 2 - BALL_SIZE // 2
    ball.y = SCREEN_HEIGHT // 2 - BALL_SIZE // 2
    
    # Сброс скорости
    ball_dx = BALL_INITIAL_SPEED * random.choice([-1, 1])
    ball_dy = -BALL_INITIAL_SPEED
    
    # Пересоздание кирпичей
    bricks = create_blocks()
    score = 0
    game_over = False
    not paused

def handle_input():
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and paddle.left - 5 > 0:
        paddle.x -= PADDLE_SPEED
    if keys[pygame.K_RIGHT] and paddle.right + 5 < SCREEN_WIDTH:
        paddle.x += PADDLE_SPEED

def move_objects():
    global ball_dx, ball_dy, ball, paddle, bricks, game_over
    
    # 1. Движение мяча
    ball.x += ball_dx
    ball.y += ball_dy
    
    # 2. Проверка стен
    if ball.left <= 0 or ball.right >= SCREEN_WIDTH or ball.top <= 0 or ball.bottom >= SCREEN_HEIGHT:
        # Отскок от боковых стен
        if ball.left <= 0 or ball.right >= SCREEN_WIDTH:
            ball_dx *= -1
        # Проигрыш (падение на дно)
        elif ball.bottom >= SCREEN_HEIGHT:
            game_over = True

    # 3. Удар о падл
    if ball.bottom >= paddle.top and ball.bottom < paddle.top + ball_dy + 5 and \
       ball.left < paddle.right and ball.right > paddle.left:
        
        # Корректируем позицию мяча сразу к падлу, чтобы избежать застревания
        ball.bottom = paddle.top
        
        # Инвертируем вертикальную скорость (Y)
        ball_dy *= -1
        
        # Небольшое изменение по горизонтали в зависимости от того, куда попал мяч
        center_check = (ball.left + ball.right) / 2
        paddle_center = paddle.x + PADDLE_WIDTH / 2
        
        # Если мяч ударился ближе к правому краю падла -> уходим вправо
        if center_check > paddle_center:
            ball_dx += 0.5
        # Если мяч ударился ближе к левому краю падла -> уходим влево
        elif center_check < paddle_center:
            ball_dx -= 0.5
            
    # 4. Столкновение с кирпичами
    global bricks, score
    brick_hit_index = -1
    for i, brick in enumerate(bricks):
        if ball.colliderect(brick):
            # Устанавливаем, какой кирпич был разбит
            brick_hit_index = i
            
            # Разрушаем кирпич
            bricks.pop(i)
            score += 10
            
            # Инвертируем направление Y (стандартный отскок)
            ball_dy *= -1
            # Переназначаем новые скорости, если они были изменены в цикле
            ball_dx += 0.5 
            break # Выходим из цикла, так как мяч ударился о один кирпич
            
    if brick_hit_index!= -1:
        # Обновление всех глобальных переменных, если это необходимо
        pass 

    # 5. Проверка победы
    if not bricks:
        print("Поздравляем! Вы выиграли!")
        game_over = True # Завершаем текущую сессию, чтобы показать победный экран

def draw_objects():
    # Заливаем фон
    screen.fill(BLACK)
    
    # Рисуем кирпичи
    for brick in bricks:
        pygame.draw.rect(screen, GREEN, brick)
        # Можно добавить текст или градиент для красоты, но пока простой прямоугольник
        pygame.draw.rect(screen, (0, 150, 0), brick, 2) # Контур
        
    # Рисуем падл
    pygame.draw.rect(screen, BLUE, paddle)
    
    # Рисуем мяч
    pygame.draw.circle(screen, WHITE, (ball.centerx, ball.centery), BALL_SIZE // 2)
    
    # Отображение счета
    score_text = small_font.render(f"Счет: {score}", True, WHITE)
    screen.blit(score_text, (10, 10))

    # Состояние игры
    if game_over:
        if not bricks:
            text = "ПОБЕДА! Нажмите R для перезапуска"
            text_color = GREEN
        else:
            text = "ПОРАЖЕНИЕ! Нажмите R для перезапуска"
            text_color = RED
        
        text_surface = font.render(text, True, text_color)
        text_rect = text_surface.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
        screen.blit(text_surface, text_rect)
        
    elif paused:
        pause_text = font.render("ПАУЗА (ESC)", True, WHITE)
        text_rect = pause_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
        screen.blit(pause_text, text_rect)


# --- Главный Игровой Цикл ---
while running:
    # 1. Обработка событий
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE and not game_over:
                if not paused:
                    paused = True
                else:
                    # Если был пауза (нажали Пробел), то возобновляем игру
                    paused = False
            elif event.key == pygame.K_ESCAPE:
                paused = False # Выход из паузы, если нажали ESC
                if game_over:
                    reset_game()
            elif event.key == pygame.K_r and game_over:
                reset_game()
            elif event.key == pygame.K_p:
                paused = not paused

    if not game_over:
        # Ввод, если игра не окончена
        handle_input()

    if not paused:
        # Обновление состояний
        move_objects()

    # 2. Отрисовка
    draw_objects()

    # Обновление экрана
    pygame.display.flip()
    
    # Установка FPS
    clock.tick(FPS)

pygame.quit()
sys.exit()

```python
import pygame
import sys

pygame.init()

display_width = 800
display_height = 600
screen = pygame.display.set_mode((display_width, display_height))
pygame.display.set_caption("Arcade")

clock = pygame.time.Clock()
font = pygame.font.Font(None, 74)

paddle_width = 100
paddle_height = 15
paddle_x = (display_width - paddle_width) // 2
paddle_y = display_height - 30
paddle_speed = 10

ball_radius = 10
ball_x = display_width // 2
ball_y = display_height // 2
ball_dx = 5
ball_dy = -5

brick_rows = 5
brick_cols = 8
brick_width = 60
brick_height = 20
brick_spacing = 5
bricks_offset_x = (display_width - brick_cols * (brick_width + brick_spacing)) // 2
bricks = []
for row in range(brick_rows):
    for col in range(brick_cols):
        brick_x = bricks_offset_x + col * (brick_width + brick_spacing)
        brick_y = 30 + row * (brick_height + brick_spacing)
        bricks.append((brick_x, brick_y, brick_width, brick_height))

score = 0
game_over = False
game_won = False

def reset_game():
    global game_over, game_won, score, ball_x, ball_y, brick_x_start, brick_y_start, bricks
    game_over = False
    game_won = False
    score = 0
    ball_x = display_width // 2
    ball_y = display_height // 2
    ball_dx = 5
    ball_dy = -5
    for row in range(brick_rows):
        for col in range(brick_cols):
            brick_x = bricks_offset_x + col * (brick_width + brick_spacing)
            brick_y = 30 + row * (brick_height + brick_spacing)
            bricks.append((brick_x, brick_y, brick_width, brick_height))

reset_game()

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN and game_over:
            if event.key == pygame.K_SPACE:
                reset_game()
        if event.type == pygame.KEYDOWN and game_won:
            if event.key == pygame.K_SPACE:
                reset_game()

    if not game_over:
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT] and paddle_x > 0:
            paddle_x -= paddle_speed
        if keys[pygame.K_RIGHT] and paddle_x < display_width - paddle_width:
            paddle_x += paddle_speed

        ball_x += ball_dx
        ball_y += ball_dy
        ball_dx = ball_dx if ball_dx > 0 else -ball_dx
        ball_dy = ball_dy if ball_dy > 0 else -ball_dy

        # Ball collision with walls
        if ball_x - ball_radius < 0 or ball_x + ball_radius > display_width:
            ball_dx *= -1
        if ball_y - ball_radius < 0:
            ball_dy *= -1
        if ball_y + ball_radius > display_height - 30 and ball_x > paddle_x and ball_x < paddle_x + paddle_width:
            ball_y = display_height - 30 - ball_radius
            ball_dy *= -1
        elif ball_y + ball_radius > display_height:
            game_over = True

        # Ball collision with brick
        brick_hit = False
        for i in range(len(bricks)):
            b_x, b_y, b_w, b_h = bricks[i]
            if b_x < ball_x + ball_radius and b_x > ball_x - ball_radius and \
               b_y < ball_y + ball_radius and b_y > ball_y - ball_radius:
                
                if not brick_hit:
                    ball_dy *= -1
                    brick_hit = True
                    bricks.pop(i)
                    score += 1
                    break

        # Bricks collision check needs recalculation if popped in loop
        # Simple fix for indices: iterate over a copy or use a flag
        if brick_hit == False:
            for i in range(len(bricks)):
                b_x, b_y, b_w, b_h = bricks[i]
                if b_x < ball_x + ball_radius and b_x > ball_x - ball_radius and \
                   b_y < ball_y + ball_radius and b_y > ball_y - ball_radius:
                    
                    ball_dy *= -1
                    bricks.pop(i)
                    score += 1
                    break

        # Check for win condition
        if not bricks:
            game_won = True

        # Update positions
        ball_x += ball_dx
        ball_y += ball_dy
        
    if game_over:
        pass
    elif game_won:
        pass
    else:
        # Update positions (if not handled above, which they are)
        pass


    # Drawing
    screen.fill(pygame.color.SYSTMAGENTA) 

    # Draw bricks
    for b_x, b_y, b_w, b_h in bricks:
        pygame.draw.rect(screen, pygame.color.BLUE, (b_x, b_y, b_w, b_h))

    # Draw paddle
    pygame.draw.rect(screen, pygame.color.YELLOW, (paddle_x, paddle_y, paddle_width, paddle_height))

    # Draw ball
    pygame.draw.circle(screen, pygame.color.RED, (int(ball_x), int(ball_y)), ball_radius)

    # Draw score
    text = font.render(str(score), True, (255, 255, 255))
    screen.blit(text, (10, 10))

    # Game State Text
    if game_over:
        text_go = font.render("GAME OVER", True, (255, 0, 0))
        text_go_rect = text_go.get_rect(center=(display_width // 2, display_height // 2))
        screen.blit(text_go, text_go_rect)
        text_restart = pygame.font.Font(None, 40).render("Press SPACE to Restart", True, (255, 255, 255))
        text_restart_rect = text_restart.get_rect(center=(display_width // 2, display_height // 2 + 50))
        screen.blit(text_restart, text_restart_rect)
    elif game_won:
        text_win = font.render("YOU WIN", True, (0, 255, 0))
        text_win_rect = text_win.get_rect(center=(display_width // 2, display_height // 2))
        screen.blit(text_win, text_win_rect)
        text_restart = pygame.font.Font(None, 40).render("Press SPACE to Play Again", True, (255, 255, 255))
        text_restart_rect = text_restart.get_rect(center=(display_width // 2, display_height // 2 + 50))
        screen.blit(text_restart, text_restart_rect)


    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()