✅ 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 🤖

🚀 Минималистичный 3D-движок с каркасным рендерингом (Wireframe)

import pygame, sys, math
pygame.init()

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

# Куб в 3D
vertices = [
    [-1, -1, -1], [1, -1, -1],
    [1,  1, -1], [-1, 1, -1],
    [-1, -1,  1], [1, -1,  1],
    [1,  1,  1], [-1, 1,  1]
]
edges = [
    (0,1),(1,2),(2,3),(3,0),
    (4,5),(5,6),(6,7),(7,4),
    (0,4),(1,5),(2,6),(3,7)
]

def project(x, y, z, angle_x, angle_y, angle_z):
    # вращение
    cx, sx = math.cos(angle_x), math.sin(angle_x)
    cy, sy = math.cos(angle_y), math.sin(angle_y)
    cz, sz = math.cos(angle_z), math.sin(angle_z)

    # поворот по X
    y, z = y*cx - z*sx, y*sx + z*cx
    # по Y
    x, z = x*cy + z*sy, -x*sy + z*cy
    # по Z
    x, y = x*cz - y*sz, x*sz + y*cz

    # проекция в 2D
    fov, dist = 400, 5
    factor = fov / (z + dist)
    px, py = x * factor + W//2, -y * factor + H//2
    return int(px), int(py)

angle_x = angle_y = angle_z = 0

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

    screen.fill((10, 10, 30))
    angle_x += 0.02
    angle_y += 0.03
    angle_z += 0.01

    # проекция вершин
    projected = [project(x,y,z, angle_x, angle_y, angle_z) for x,y,z in vertices]

    # рендер рёбер
    for a,b in edges:
        pygame.draw.line(screen, (0,200,255), projected[a], projected[b], 2)

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

📌 Что делает:

* рендерит 3D-куб по принципу wireframe (каркас)
* есть вращение по всем осям
* 3D → 2D проекция через простую перспективу

🛠

pip install pygame

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

Демо 👆👆👆

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

🎮 Самая минималистичная полная версия игры с бесконечным кол-вом уровней 🚀

import pygame,sys,random,math
pygame.init()
W,H=640,480
sc=pygame.display.set_mode((W,H))
clk=pygame.time.Clock()
font=pygame.font.SysFont(None,36)

level = 1
MIN_DIST = 150

def new_level(level):
    player = pygame.Rect(50,50,30,30)
    walls=[]
    for _ in range(10):
        w=pygame.Rect(random.randint(0,W-100),random.randint(0,H-100),
                      random.randint(50,150),random.randint(20,50))
        if w.colliderect(player): continue
        walls.append(w)
    door = pygame.Rect(W-60,H-80,40,60)
    keys = []
    for _ in range(level):
        while True:
            k = pygame.Rect(random.randint(0,W-20),random.randint(0,H-20),20,20)
            if any(k.colliderect(w) for w in walls) or k.colliderect(player) or k.colliderect(door): continue
            keys.append(k); break
    enemies=[]
    for _ in range(level+1):
        while True:
            e = pygame.Rect(random.randint(0,W-30),random.randint(0,H-30),30,30)
            if any(e.colliderect(w) for w in walls) or e.colliderect(player) or e.colliderect(door) or any(e.colliderect(k) for k in keys): continue
            if math.hypot(e.x - player.x, e.y - player.y) < MIN_DIST: continue
            enemies.append(e); break
    return player, walls, door, keys, enemies

player, walls, door, keys, enemies = new_level(level)
got_keys = 0; game_over=False

def move_rect(rect, dx, dy):
    rect.x += dx
    if any(rect.colliderect(w) for w in walls): rect.x -= dx
    rect.y += dy
    if any(rect.colliderect(w) for w in walls): rect.y -= dy

def draw():
    sc.fill((20,20,30))
    pygame.draw.rect(sc,(0,200,0),player)
    for e in enemies: pygame.draw.rect(sc,(200,50,50),e)
    for w in walls: pygame.draw.rect(sc,(100,100,100),w)
    for k in keys: pygame.draw.rect(sc,(255,255,0),k)
    pygame.draw.rect(sc,(150,75,0),door)
    sc.blit(font.render(f"Level: {level} Keys: {got_keys}/{len(keys)}",1,(255,255,255)),(10,10))
    if game_over: sc.blit(font.render("Game Over",1,(255,0,0)),(W//2-80,H//2))
    pygame.display.flip()

while True:
    for ev in pygame.event.get():
        if ev.type==pygame.QUIT: pygame.quit();sys.exit()
    if not game_over:
        keys_pressed=pygame.key.get_pressed()
        dx=(keys_pressed[pygame.K_RIGHT]-keys_pressed[pygame.K_LEFT])*4
        dy=(keys_pressed[pygame.K_DOWN]-keys_pressed[pygame.K_UP])*4
        move_rect(player, dx, dy)
        for e in enemies:
            ex,ey = 0,0
            if e.x < player.x: ex=2
            elif e.x > player.x: ex=-2
            if e.y < player.y: ey=2
            elif e.y > player.y: ey=-2
            move_rect(e, ex, ey)
            if e.colliderect(player): game_over=True
        for k in keys[:]:
            if player.colliderect(k):
                keys.remove(k); got_keys+=1
        if player.colliderect(door) and got_keys==level:
            level+=1
            player, walls, door, keys, enemies = new_level(level)
            got_keys=0
    draw()
    clk.tick(30)

📌 Описание:

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

🛠

pip install pygame

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

Я дошел до 5 уровня, а вы? 😀

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

Неа все таки уже до 7 уровня дошел 😀

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

Процедурная генерация подземелья (roguelike-style) с помощью клеточного автомата.

import random, pygame
pygame.init()
W,H=800,600
T=10
C=(0,0,0)
Wc,Hc=W//T,H//T
s=pygame.display.set_mode((W,H))

def gen():
    m=[[1 if random.random()<0.45 else 0 for x in range(Wc)] for y in range(Hc)]
    for _ in range(5):
        nm=[[0]*Wc for _ in range(Hc)]
        for y in range(Hc):
            for x in range(Wc):
                cnt=sum(m[yy][xx] for yy in range(y-1,y+2) for xx in range(x-1,x+2) if 0<=xx<Wc and 0<=yy<Hc)
                nm[y][x]=1 if cnt>=5 else 0
        m=nm
    return m

m=gen()

while True:
    for e in pygame.event.get():
        if e.type==pygame.QUIT:pygame.quit();exit()
    for y in range(Hc):
        for x in range(Wc):
            pygame.draw.rect(s,(200,200,200) if m[y][x]==0 else C,(x*T,y*T,T,T))
    pygame.display.flip()

👉 Что это делает:

* Генерирует карты-пещеры в стиле roguelike / Terraria.
* Используется клеточный автомат: случайная заготовка → несколько итераций «эволюции» → получается пещера.

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

Отвечаю на вопрос по извлечению фактов из чатов и текстов

Всё намного банальнее в реальности. Вот тут реальный кейс компании: ~10 000 сообщений, ~700 участников, 28 реальных вопросов-ответов, 25 реально недублирующихся устойчивых фактов. Всё остальное — шум типа «привет, пока, а как, а че, я тут подумал»...

LLM это выделяет очень хорошо. Конечно, важен промт.

Мы сейчас тестируем новый подход, в том числе к индексированию документов (Factology) — выделение фактов вместо простого чанкования. Как выяснилось, в документах тоже очень много воды и дубликатов.

И если в переписке был упомянут промт как промт, то в нашем случае LLM его сохранит как факт.

Главное — не переоценивать плотность информации в переписках и даже документах: там очень-очень-очень много воды. Нам людям так удобнее общаться, но для LLM это лишний шум.

А если надо извлечь эмоции из чатов, то это тоже можно сделать и отдельно сохранить, не держа весь объём переписок.

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

Добавим игрока, управление стрелками, и фонарик — освещается только область вокруг героя.

import random,pygame,math
pygame.init()
W,H=800,600
T=10
C=(0,0,0)
Wc,Hc=W//T,H//T
s=pygame.display.set_mode((W,H))
clock=pygame.time.Clock()

def gen():
    m=[[1 if random.random()<0.45 else 0 for x in range(Wc)] for y in range(Hc)]
    for _ in range(5):
        nm=[[0]*Wc for _ in range(Hc)]
        for y in range(Hc):
            for x in range(Wc):
                cnt=sum(m[yy][xx] for yy in range(y-1,y+2) for xx in range(x-1,x+2)
                        if 0<=xx<Wc and 0<=yy<Hc)
                nm[y][x]=1 if cnt>=5 else 0
        m=nm
    return m

m=gen()
px,py=W//2//T,H//2//T
r=80  # радиус фонаря в пикселях

while True:
    for e in pygame.event.get():
        if e.type==pygame.QUIT:pygame.quit();exit()
    k=pygame.key.get_pressed()
    dx,dy=0,0
    if k[pygame.K_LEFT]:dx=-1
    if k[pygame.K_RIGHT]:dx=1
    if k[pygame.K_UP]:dy=-1
    if k[pygame.K_DOWN]:dy=1
    if 0<=px+dx<Wc and 0<=py+dy<Hc and m[py+dy][px+dx]==0:
        px+=dx;py+=dy

    # рисуем карту
    s.fill(C)
    for y in range(Hc):
        for x in range(Wc):
            if m[y][x]==0:
                pygame.draw.rect(s,(200,200,200),(x*T,y*T,T,T))

    # затемняем всё кроме круга фонаря
    mask=pygame.Surface((W,H))
    mask.fill((0,0,0))
    mask.set_alpha(220)
    pygame.draw.circle(mask,(0,0,0,0),(px*T+T//2,py*T+T//2),r)
    s.blit(mask,(0,0))

    pygame.draw.circle(s,(255,255,0),(px*T+T//2,py*T+T//2),4) # игрок
    pygame.display.flip()
    clock.tick(30)

📌 Теперь:

* Карта генерируется процедурно.
* Игрок ходит стрелками, но не может пройти сквозь стены.
* Видна только область вокруг героя (фонарик).

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