👀 Авто-сортировщик файлов в реальном времени

import time, shutil, pathlib
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

DOWNLOADS = pathlib.Path.home() / "Downloads"
TARGETS = {
    "Images": [".jpg", ".jpeg", ".png", ".gif"],
    "Docs": [".pdf", ".docx", ".txt"],
    "Archives": [".zip", ".rar", ".tar", ".gz"],
    "Music": [".mp3", ".wav"],
}

class SortHandler(FileSystemEventHandler):
    def on_created(self, event):
        if not event.is_directory:
            file = pathlib.Path(event.src_path)
            ext = file.suffix.lower()
            for folder, exts in TARGETS.items():
                if ext in exts:
                    dest = DOWNLOADS / folder
                    dest.mkdir(exist_ok=True)
                    shutil.move(str(file), dest / file.name)
                    print(f"📦 {file.name} → {folder}")
                    break

if __name__ == "__main__":
    observer = Observer()
    observer.schedule(SortHandler(), str(DOWNLOADS), recursive=False)
    observer.start()
    print("👀 Следим за папкой Downloads...")
    try:
        while True: time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()

📌 Теперь скрипт в фоне следит за папкой Downloads и сразу раскладывает новые файлы по папкам.

🛠

pip install watchdog

Подпишись 👉🏻 @KodduuPython 🤖

✨ Анимация «волны»

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()
x = np.linspace(0, 4*np.pi, 400)
line, = ax.plot(x, np.sin(x), lw=2)
ax.set_ylim(-1.2, 1.2)

def update(frame):
    line.set_ydata(np.sin(x + frame/10))
    return line,

ani = animation.FuncAnimation(fig, update, frames=200, interval=30, blit=True)
plt.show()

📌 Простая анимация синусоиды, которая движется как волна

🛠

pip install matplotlib numpy

Подпишись 👉🏻 @KodduuPython 🤖

🕹 ZX Spectrum loading screen

pygame.init()
pygame.mixer.quit()  # сбросим микшер
pygame.mixer.init(frequency=22050, size=-16, channels=1)  # моно

W, H = 600, 400
screen = pygame.display.set_mode((W, H))
clock = pygame.time.Clock()

def beep(freq=800, dur=50):
    sample_rate = 22050
    n = int(sample_rate * dur / 1000)
    arr = (np.sin(2*np.pi*np.arange(n)*freq/sample_rate)*32767).astype(np.int16)
    sound = pygame.sndarray.make_sound(arr)
    sound.play()
    pygame.time.delay(dur)

colors = [(255,0,0),(0,255,0),(0,0,255),(255,255,0),(255,0,255),(0,255,255)]

for _ in range(120):
    for e in pygame.event.get():
        if e.type == pygame.QUIT: sys.exit()
    rect_h = random.randint(5, 30)
    y = random.randint(0, H-rect_h)
    color = random.choice(colors)
    pygame.draw.rect(screen, color, (0, y, W, rect_h))
    pygame.display.flip()
    beep(random.randint(300, 1200), 40)
    time.sleep(0.02)

time.sleep(1)

Подпишись 👉🏻 @KodduuPython 🤖

Хрупкость всех agentic систем

Во всех мультиагентных системах есть одно хрупкое место — это протокол общения между агентами или роутинг между ними.

По сути, можно сделать жёсткий роутинг прямо в коде. Можно сделать условный роутинг тоже в коде. А можно настроить гибкий роутинг во фреймворках AutoGen, LangChain. Но даже в гибких вариантах это определённая договорённость (правила общения).

Хрупкость в том, что агенты используют LLM, которая может вернуть не совсем то, что ожидается, и да, конечно, они должны валидировать то, что им возвращает LLM, а потом передавать данные следующему агенту в строго определённом формате. Любое изменение кода, промтов и прочего может поломать цепочку. Неожиданный ответ LLM может поломать цепочку. Изменения API вендоров могут поломать одного агента и поломать цепочку.

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

Поэтому мир будет двигаться от строго определённых протоколов к гибким и даже к отсутствию протоколов.

Мы провели эксперимент — попробовали загнать множество разных агентов в пространство без протоколов и дали им возможность общаться на человеческом языке, и они отлично справляются. Агенты читают этот общий чат и публикуют свои результаты и наблюдения обратно. В этом, казалось бы, мусоре сообщений возникает чёткое общение и выполнение целей агентов. Без роутинга, без протокола.

Более детально про результаты нашего эксперимента скоро будет статья на habr.

Подпишись 👉🏻 @aigentto 🤖

🤖 Простой ИИ-агент для чата с OpenAI

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def chat_agent(prompt, model="gpt-3.5-turbo"):
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "system", "content": "Ты полезный помощник."},
                  {"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    while True:
        user_input = input("Вы: ")
        if user_input.lower() in ["выход", "exit", "quit"]:
            break
        answer = chat_agent(user_input)
        print("ИИ:", answer)

📌 Чат-бот, который отвечает на вопросы пользователя через OpenAI API.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

🏨 ИИ-агент для бронирования отелей

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def hotel_booking_agent(user_request, model="gpt-3.5-turbo"):
    system_msg = (
        "Ты агент по бронированию отелей. "
        "Помоги пользователю найти подходящий отель, "
        "уточни город, даты, бюджет и предпочтения, "
        "предложи список вариантов с краткой информацией."
    )
    response = openai.ChatCompletion.create(
        model=model,
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": user_request}
        ]
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    while True:
        request = input("Пользователь: ")
        if request.lower() in ["выход", "exit", "quit"]:
            break
        answer = hotel_booking_agent(request)
        print("ИИ:", answer)

📌 Агент уточняет детали бронирования и предлагает варианты отелей на основе запроса пользователя.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

🤖 ИИ-агент «Помощник программиста»

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def dev_assistant(prompt, model="gpt-3.5-turbo"):
    system_msg = (
        "Ты ИИ-помощник для программиста. "
        "Отвечай кратко, давай готовые примеры кода на Python, "
        "поясняй ошибки и оптимизации."
    )
    response = openai.ChatCompletion.create(
        model=model,
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": prompt}
        ]
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    while True:
        user_input = input("Вы: ")
        if user_input.lower() in ["выход", "exit", "quit"]:
            break
        answer = dev_assistant(user_input)
        print("ИИ:", answer)

📌 Агент отвечает конкретно как помощник программиста: даёт код, исправляет ошибки, даёт оптимизации.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

🌐 ИИ-агент для парсинга сайтов и извлечения данных

import requests
from bs4 import BeautifulSoup
import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def web_parser_agent(url, query, model="gpt-3.5-turbo"):
    res = requests.get(url)
    soup = BeautifulSoup(res.text, "html.parser")
    text = soup.get_text(separator="\n")
    
    prompt = (
        f"Вот текст с сайта:\n{text[:4000]}\n\n"
        f"Извлеки нужную информацию по запросу: {query}"
    )
    
    response = openai.ChatCompletion.create(
        model=model,
        messages=[
            {"role": "system", "content": "Ты агент для извлечения информации с веб-страниц."},
            {"role": "user", "content": prompt}
        ]
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    url = input("URL: ")
    query = input("Что извлечь: ")
    result = web_parser_agent(url, query)
    print("Результат:\n", result)

📌 Агент скачивает страницу, извлекает текст и с помощью ИИ ищет нужную информацию по запросу.

🛠

pip install requests beautifulsoup4 openai

Подпишись 👉🏻 @KodduuPython 🤖

✅ LLM-валидатор ответов через логические гейты

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def validate_response(prompt, validation_rules, model="gpt-3.5-turbo"):
    """
    prompt: запрос к LLM
    validation_rules: список правил, которые ответ должен пройти
    """
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    )
    answer = response.choices[0].message.content

    results = {}
    for rule_name, rule_check in validation_rules.items():
        results[rule_name] = rule_check(answer)

    return answer, results

# Пример правил в виде функций
validation_rules = {
    "contains_number": lambda text: any(c.isdigit() for c in text),
    "mentions_python": lambda text: "python" in text.lower(),
}

if __name__ == "__main__":
    prompt = "Напиши пример кода на Python, который считает сумму чисел от 1 до 10"
    answer, gates = validate_response(prompt, validation_rules)
    print("Ответ LLM:\n", answer)
    print("Результаты валидации:", gates)

📌 Простейшая схема «гейтов» для проверки ответов LLM: каждый гейт — это функция, возвращающая True/False.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

🚦 Многоступенчатая валидация ответа LLM (гейты)

import openai, json

openai.api_key = "YOUR_OPENAI_API_KEY"

def multi_gate_agent(prompt, model="gpt-3.5-turbo"):
    # Сначала получаем ответ от LLM
    answer = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "user", "content": prompt}]
    ).choices[0].message.content

    # Проверяем ответ через "гейты"
    gates = {
        "toxic_check": "Проверь, содержит ли текст оскорбления или токсичность. Ответь JSON {'toxic': true/false}",
        "fact_check": f"Проверь фактическую корректность ответа: {answer}. Верни JSON {{'valid': true/false}}",
        "style_check": "Проверь, написан ли текст в вежливом стиле. Ответь JSON {'polite': true/false}"
    }

    results = {}
    for name, gate_prompt in gates.items():
        resp = openai.ChatCompletion.create(
            model=model,
            messages=[{"role": "system", "content": "Ты валидатор."},
                      {"role": "user", "content": gate_prompt}]
        ).choices[0].message.content
        try:
            results[name] = json.loads(resp)
        except:
            results[name] = {"error": resp}

    return answer, results

if __name__ == "__main__":
    user_q = "Напиши что-нибудь про Марс"
    ans, validation = multi_gate_agent(user_q)
    print("Ответ LLM:\n", ans)
    print("\nРезультаты валидации:\n", validation)

📌 Агент проходит через несколько «гейтов»: токсичность, факты, стиль. Каждый возвращает JSON.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

📧 ИИ-агент для сортировки писем по категориям

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def mail_sorting_agent(email_text, model="gpt-3.5-turbo"):
    system_msg = (
        "Ты агент для классификации писем. "
        "Категории: ['Работа', 'Финансы', 'Реклама', 'Личное', 'Другое']. "
        "Верни JSON с ключами: {'category': '...', 'reason': '...'}."
    )
    response = openai.ChatCompletion.create(
        model=model,
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": email_text}
        ]
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    sample_email = "Здравствуйте, пришлите, пожалуйста, счёт за услуги за август."
    result = mail_sorting_agent(sample_email)
    print("Результат классификации:\n", result)

📌 Агент автоматически раскладывает письма по папкам: «Работа», «Финансы», «Реклама» и т.д.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

📄 ИИ-агент для анализа резюме кандидатов

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def resume_analysis_agent(resume_text, model="gpt-3.5-turbo"):
    system_msg = (
        "Ты HR-агент. Твоя задача — проанализировать резюме кандидата. "
        "Выдели ключевые навыки, опыт, уровень английского и дай краткий вывод. "
        "Верни JSON с ключами: {'skills': [...], 'experience': '...', 'english': '...', 'summary': '...'}"
    )
    response = openai.ChatCompletion.create(
        model=model,
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": resume_text}
        ]
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    sample_resume = """
    Иван Иванов, Python-разработчик.
    Опыт: 5 лет. Django, FastAPI, PostgreSQL, Docker, AWS.
    Английский — Upper-Intermediate.
    Работал над highload-системами.
    """
    result = resume_analysis_agent(sample_resume)
    print("Результат анализа:\n", result)

📌 Агент автоматически извлекает навыки, опыт и делает краткий HR-вывод по резюме.

🛠

pip install openai

Подпишись 👉🏻 @KodduuPython 🤖

LLM спасет локальный debug

Раньше, когда я писал на C/C++, я всегда делал локальный пошаговый debug с отсмотром всех переменных для понимания, где может быть проблема. Сейчас почти никто так не делает, тем более что это все усложняется необходимостью написания большого числа заглушек для такого дебага.

Это был очень мощный инструмент, НО сейчас есть LLM, и простое скармливание кода с просьбой дебагинга находит 90% потенциальных проблем 👏

Подпишись 👉🏻 @aigentto 🤖

Возьмём асинхронный веб-краулер с очередью задач, который собирает заголовки страниц с сайта.

import asyncio
import aiohttp
from aiohttp import ClientTimeout
from bs4 import BeautifulSoup

class AsyncCrawler:
    def __init__(self, urls, concurrency=5):
        self.urls = asyncio.Queue()
        for u in urls:
            self.urls.put_nowait(u)
        self.concurrency = concurrency

    async def fetch(self, session, url):
        try:
            async with session.get(url, timeout=ClientTimeout(total=10)) as resp:
                html = await resp.text()
                soup = BeautifulSoup(html, "html.parser")
                title = soup.title.string.strip() if soup.title else "Нет заголовка"
                print(f"{url} → {title}")
        except Exception as e:
            print(f"{url} ошибка: {e}")

    async def worker(self):
        async with aiohttp.ClientSession() as session:
            while not self.urls.empty():
                url = await self.urls.get()
                await self.fetch(session, url)
                self.urls.task_done()

    async def run(self):
        tasks = [asyncio.create_task(self.worker()) for _ in range(self.concurrency)]
        await self.urls.join()
        for t in tasks:
            t.cancel()

if __name__ == "__main__":
    urls = [
        "https://www.python.org",
        "https://www.djangoproject.com",
        "https://fastapi.tiangolo.com",
        "https://pypi.org"
    ]
    crawler = AsyncCrawler(urls, concurrency=3)
    asyncio.run(crawler.run())

📌 Этот асинхронный краулер умеет:

* работать с очередью asyncio.Queue
* ограничивать количество конкурентных воркеров
* парсить HTML и доставать <title>
* обрабатывать таймауты и ошибки

🛠

pip install aiohttp beautifulsoup4

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Асинхронный TCP-сервер с пулом клиентов (боевой пример)

import asyncio

class EchoServer:
    def __init__(self, host="127.0.0.1", port=8888):
        self.host, self.port = host, port
        self.clients = set()

    async def handle_client(self, reader, writer):
        addr = writer.get_extra_info("peername")
        self.clients.add(writer)
        print(f"[+] Подключен {addr}")

        try:
            while data := await reader.readline():
                msg = data.decode().strip()
                if msg.lower() == "quit":
                    break
                # отправляем сообщение всем клиентам
                for client in self.clients:
                    if client != writer:
                        client.write(f"{addr}: {msg}\n".encode())
                        await client.drain()
        except Exception as e:
            print(f"[!] Ошибка {addr}: {e}")
        finally:
            print(f"[-] Отключен {addr}")
            self.clients.remove(writer)
            writer.close()
            await writer.wait_closed()

    async def run(self):
        server = await asyncio.start_server(self.handle_client, self.host, self.port)
        addr = ", ".join(str(s.getsockname()) for s in server.sockets)
        print(f"Сервер слушает: {addr}")
        async with server:
            await server.serve_forever()

if __name__ == "__main__":
    asyncio.run(EchoServer().run())

📌 Что делает:

* асинхронный TCP-чат-сервер
* поддерживает множество клиентов
* каждое сообщение рассылается всем подключённым
* команда quit закрывает соединение

🛠 работает сразу, без зависимостей (чистый Python 3.9+)

Подпишись 👉🏻 @KodduuPython 🤖

До 30 сентября 🔥🔥🔥 Python: самый быстрый курс 👉 2240 руб 🔥🔥🔥

Подпишись 👉🏻 @KodduuPython 🤖

🎮 Мини-игра на Pygame: «Падающие блоки»

import pygame, random, sys
pygame.init()

W, H = 400, 600
screen = pygame.display.set_mode((W, H))
clock = pygame.time.Clock()

player = pygame.Rect(W//2-25, H-50, 50, 30)
blocks, speed, score = [], 5, 0
font = pygame.font.SysFont(None, 36)

while True:
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            pygame.quit(); sys.exit()

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player.left > 0: player.move_ip(-7, 0)
    if keys[pygame.K_RIGHT] and player.right < W: player.move_ip(7, 0)

    if random.randint(1, 20) == 1:
        blocks.append(pygame.Rect(random.randint(0, W-30), -30, 30, 30))

    screen.fill((30, 30, 30))
    pygame.draw.rect(screen, (0, 200, 0), player)

    for b in blocks[:]:
        b.move_ip(0, speed)
        pygame.draw.rect(screen, (200, 50, 50), b)
        if b.colliderect(player):
            pygame.quit(); sys.exit()
        if b.top > H:
            blocks.remove(b)
            score += 1

    txt = font.render(f"Score: {score}", True, (255, 255, 255))
    screen.blit(txt, (10, 10))
    pygame.display.flip()
    clock.tick(60)

📌 Игрок управляет прямоугольником внизу экрана, уворачиваясь от падающих блоков. Каждый пропущенный блок даёт +1 очко.
🛠

pip install pygame

Подпишись 👉🏻 @KodduuPython 🤖

Вот рабочая минималистичная версия «3D-like шутера» 👇

import pygame, random, sys, math
pygame.init()

W, H = 640, 480
sc = pygame.display.set_mode((W, H))
clk = pygame.time.Clock()

player_x = 0
bullets = []   # [(x, z)]
enemies = []   # [(x, z)]
SPAWN = 30

while True:
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            pygame.quit(); sys.exit()
        if e.type == pygame.MOUSEBUTTONDOWN:
            mx, _ = pygame.mouse.get_pos()
            bullets.append(((mx - W//2) / (W//2), 1.2))

    keys = pygame.key.get_pressed()
    player_x += (keys[pygame.K_RIGHT] - keys[pygame.K_LEFT]) * 0.02

    if random.randint(1, SPAWN) == 1:
        enemies.append([random.uniform(-1, 1), 1.5])

    sc.fill((10, 10, 30))

    # обновляем врагов
    new_enemies = []
    for x, z in enemies:
        z -= 0.01
        if z <= 0.05:  # достиг экрана
            continue
        scale = 1 / (z + 0.2)
        sx = int(W//2 + x * scale * W//2)
        sy = int(H - scale * H)
        r = max(2, int(24 * scale))
        pygame.draw.circle(sc, (200, 50, 50), (sx, sy), r)
        new_enemies.append([x, z])
    enemies = new_enemies

    # обновляем пули
    new_bullets = []
    for x, z in bullets:
        z -= 0.06
        if z <= 0:  # улетела
            continue
        scale = 1 / (z + 0.2)
        sx = int(W//2 + x * scale * W//2)
        sy = int(H - scale * H)
        pygame.draw.circle(sc, (255, 255, 0), (sx, sy), max(1, int(6 * scale)))

        hit = False
        for ex, ez in enemies:
            escale = 1 / (ez + 0.2)
            exs = int(W//2 + ex * escale * W//2)
            eys = int(H - escale * H)
            if math.hypot(sx - exs, sy - eys) < (6*scale + 12*escale):
                enemies.remove([ex, ez])
                hit = True
                break
        if not hit:
            new_bullets.append([x, z])
    bullets = new_bullets

    # рисуем игрока (пушка)
    px = int(W//2 + player_x * W//2)
    pygame.draw.polygon(sc, (100, 200, 250), [(px, H-10), (px-10, H-30), (px+10, H-30)])

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

🕹 Управление:

* стрелки ← / → — смещают игрока
* клики мышкой — стреляют

Подпишись 👉🏻 @KodduuPython 🤖

До 30 сентября 🔥 Python: самый быстрый курс 👉 2240 руб 🔥

Подпишись 👉🏻 @KodduuPython 🤖

Минималистичный Raycasting движок в стиле Wolfenstein 3D (без оружия, просто ходьба по лабиринту). Это самый базовый, но реально рабочий 3D-эффект в pygame.

import pygame, math, sys
pygame.init()

W, H = 640, 480
HALF_H = H // 2
TILE = 64
FOV = math.pi / 3
NUM_RAYS = 120
MAX_DEPTH = 800
DELTA_ANGLE = FOV / NUM_RAYS
DIST = NUM_RAYS / (2 * math.tan(FOV/2))
PROJ_COEFF = 3 * DIST * TILE
SCALE = W // NUM_RAYS

screen = pygame.display.set_mode((W, H))
clock = pygame.time.Clock()

# карта: 1 = стена
game_map = {
    (1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),
    (1,2),(1,3),(1,4),(1,5),(1,6),
    (7,2),(7,3),(7,4),(7,5),(7,6),
    (2,6),(3,6),(4,6),(5,6),(6,6)
}

px, py = W//4, H//4
angle = 0

def mapping(a,b): return (a//TILE)*TILE, (b//TILE)*TILE

while True:
    for e in pygame.event.get():
        if e.type == pygame.QUIT: pygame.quit(); sys.exit()

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]: angle -= 0.04
    if keys[pygame.K_RIGHT]: angle += 0.04
    dx, dy = math.cos(angle)*2, math.sin(angle)*2
    if keys[pygame.K_w]: px += dx; py += dy
    if keys[pygame.K_s]: px -= dx; py -= dy

    screen.fill((30,30,30))
    pygame.draw.rect(screen, (100,100,100), (0,0,W,HALF_H))   # потолок
    pygame.draw.rect(screen, (50,50,50), (0,HALF_H,W,HALF_H)) # пол

    cur_angle = angle - FOV/2
    for ray in range(NUM_RAYS):
        sin_a, cos_a = math.sin(cur_angle), math.cos(cur_angle)
        for depth in range(MAX_DEPTH):
            x, y = px + depth*cos_a, py + depth*sin_a
            if (x//TILE, y//TILE) in game_map:
                depth *= math.cos(angle - cur_angle)  # удаление "fish-eye"
                proj_height = PROJ_COEFF / (depth+0.0001)
                c = 255 / (1 + depth*depth*0.0001)
                color = (c, c//2, c//3)
                pygame.draw.rect(screen, color,
                    (ray*SCALE, HALF_H - proj_height//2, SCALE, proj_height))
                break
        cur_angle += DELTA_ANGLE

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

📌 Что умеет:

* простой raycasting-рендеринг
* лабиринт-карта задана как сетка (`game_map`)
* управление:

* ← / → — поворот
* W / S — движение вперёд/назад

🛠

pip install pygame

Подпишись 👉🏻 @KodduuPython 🤖

Демо 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖