Твоя задача: Максимально оптимизировать код, сделать максимально реалистичное поведение звуковых волн.
```python
import pygame
import sys
import math
import time

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

# Настройка экрана
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Эхолокация в 2D игре с отражениями")

# Инициализация микшера
pygame.mixer.init()

# Загрузка звуков
# Убедитесь, что файлы move.wav и attack.wav находятся в рабочей директории
try:
    move_sound = pygame.mixer.Sound("move.wav")
    attack_sound = pygame.mixer.Sound("attack.wav")
except pygame.error:
    print("Не удалось загрузить звуковые файлы. Убедитесь, что move.wav и attack.wav присутствуют.")
    sys.exit()

# Настройка громкости
move_sound.set_volume(0.5)
attack_sound.set_volume(0.7)

# Персонаж
player_pos = pygame.Vector2(WIDTH // 2, HEIGHT // 2)
player_speed = 200  # пикселей в секунду
step_distance = 100  # пикселей соответствуют одному шагу
accumulated_distance = 0  # накопленная дистанция для шагов

# Класс для представления звуковых волн
class Wave:
    def __init__(self, position, creation_time, max_radius, speed, attenuation, walls, reflections_left=2):
        self.origin = pygame.Vector2(position)
        self.creation_time = creation_time
        self.max_radius = max_radius
        self.speed = speed  # пикселей в секунду
        self.attenuation = attenuation  # коэффициент затухания
        self.walls = walls
        self.reflections_left = reflections_left  # количество оставшихся отражений
        self.current_radius = 0
        self.reflection_points = []  # точки отражения

    def update(self, current_time):
        elapsed = current_time - self.creation_time
        self.current_radius = self.speed * elapsed
        if self.current_radius > self.max_radius:
            return False  # Волна вышла за пределы максимального радиуса

        # Проверка столкновений со стенами
        collision_points = self.check_collisions()
        for point, normal in collision_points:
            if self.reflections_left > 0:
                # Создаем новую волну, отраженную от стены
                reflected_position = point + pygame.Vector2(normal) * 1  # Смещение немного вдоль нормали
                reflected_speed = self.speed * 0.9  # Можно снизить скорость после отражения
                reflected_attenuation = self.attenuation * 1.2  # Можно изменить коэффициент затухания
                new_wave = Wave(
                    position=reflected_position,
                    creation_time=current_time,
                    max_radius=self.max_radius,
                    speed=reflected_speed,
                    attenuation=reflected_attenuation,
                    walls=self.walls,
                    reflections_left=self.reflections_left - 1
                )
                sound_waves.append(new_wave)
            # Добавляем точку отражения, чтобы избежать повторного отражения
            self.reflection_points.append(point)

        return True

    def check_collisions(self):
        collision_points = []
        for wall in self.walls:
            hit, point, normal = self.circle_rect_collision(self.origin, self.current_radius, wall)
            if hit:
                # Проверка, была ли уже отражена в этой точке
                already_reflected = False
                for p in self.reflection_points:
                    if (p - point).length_squared() < 1:  # близкие точки считаем одинаковыми
                        already_reflected = True
                        break
                if not already_reflected:
                    collision_points.append((point, normal))
        return collision_points

    def circle_rect_collision(self, circle_center, radius, rect):
        # Найти ближайшую точку на прямоугольнике к центру круга
        closest_x = max(rect.left, min(circle_center.x, rect.right))
        closest_y = max(rect.top, min(circle_center.y, rect.bottom))

        # Вычислить расстояние между ближайшей точкой и центром круга
        distance_x = circle_center.x - closest_x
        distance_y = circle_center.y - closest_y
        distance_sq = distance_x ** 2 + distance_y ** 2

        if distance_sq <= radius ** 2:
            distance = math.sqrt(distance_sq)
            if distance == 0:
                # Круг полностью пересекает прямоугольник
                # Определяем нормаль по умолчанию (верх)
                normal = pygame.Vector2(0, -1)
                return True, pygame.Vector2(closest_x, closest_y), normal
            else:
                # Нормаль направлена от стены к центру круга
                normal = pygame.Vector2(distance_x / distance, distance_y / distance)
                return True, pygame.Vector2(closest_x, closest_y), normal
        return False, None, None

    def draw(self, surface):
        alpha = max(255 - (self.current_radius * self.attenuation), 0)
        if alpha <= 0:
            return

        # Создаем поверхность для прозрачности
        wave_surface = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        color = (0, 0, 255, int(alpha))

        # Рисуем круг
        pygame.draw.circle(wave_surface, color, (int(self.origin.x), int(self.origin.y)), int(self.current_radius), 2)
        surface.blit(wave_surface, (0, 0))

# Список активных звуковых волн
sound_waves = []

# Добавим простые стены в виде прямоугольников
walls = [
    pygame.Rect(100, 100, 600, 20),  # верхняя стена
    pygame.Rect(100, 480, 600, 20),  # нижняя стена
    pygame.Rect(100, 120, 20, 360),  # левая стена
    pygame.Rect(680, 120, 20, 360),  # правая стена
    # Добавьте дополнительные стены по необходимости
]

# Функция для отрисовки стен
def draw_walls(surface):
    for wall in walls:
        pygame.draw.rect(surface, (200, 200, 200), wall)

# Функция для обработки действий персонажа с шагами
def handle_player_actions(keys_pressed, dt, current_time):
    global accumulated_distance, player_pos, sound_waves  # Объявляем переменные как глобальные

    movement = pygame.Vector2(0, 0)
    if keys_pressed[pygame.K_LEFT]:
        movement.x -= 1
    if keys_pressed[pygame.K_RIGHT]:
        movement.x += 1
    if keys_pressed[pygame.K_UP]:
        movement.y -= 1
    if keys_pressed[pygame.K_DOWN]:
        movement.y += 1

    if movement.length() > 0:
        movement = movement.normalize() * player_speed * dt
        player_pos_prev = player_pos.copy()
        player_pos += movement
        delta_distance = movement.length()
        accumulated_distance += delta_distance

        # Генерация волны при прохождении дальности шага
        while accumulated_distance >= step_distance:
            accumulated_distance -= step_distance
            move_sound.play()
            wave = Wave(
                position=player_pos,
                creation_time=current_time,
                max_radius=300,
                speed=200,  # пикселей в секунду
                attenuation=0.5,
                walls=walls,
                reflections_left=2  # Максимум 2 отражения
            )
            sound_waves.append(wave)

    if keys_pressed[pygame.K_SPACE]:
        # Чтобы атаку воспроизводить только один раз при нажатии, лучше использовать событие
        pass  # Реализуем ниже

    # Ограничение позиции персонажа внутри экрана
    player_pos.x = max(0, min(WIDTH, player_pos.x))
    player_pos.y = max(0, min(HEIGHT, player_pos.y))

# Главный цикл игры
clock = pygame.time.Clock()
running = True
while running:
    dt = clock.tick(60) / 1000  # время между кадрами в секундах
    current_time = time.time()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE:
                attack_sound.play()
                wave = Wave(
                    position=player_pos,
                    creation_time=current_time,
                    max_radius=300,
                    speed=300,  # быстрее для атаки
                    attenuation=0.7,
                    walls=walls,
                    reflections_left=2
                )
                sound_waves.append(wave)

    keys_pressed = pygame.key.get_pressed()
    handle_player_actions(keys_pressed, dt, current_time)

    # Обновление волн
    sound_waves = [wave for wave in sound_waves if wave.update(current_time)]

    # Рендеринг
    screen.fill((30, 30, 30))
    draw_walls(screen)
    pygame.draw.circle(screen, (0, 255, 0), (int(player_pos.x), int(player_pos.y)), 15)

    for wave in sound_waves:
        wave.draw(screen)

    pygame.display.flip()

pygame.quit()
sys.exit()
```