doom_pop.py

import pygame
import math
import random
import sys


# =====================================================
# CONFIG
# =====================================================

WIDTH, HEIGHT = 900, 600
FOV = math.pi / 3
HALF_FOV = FOV / 2
NUM_RAYS = 120
TILE = 50


# =====================================================
# WORLD STATE
# =====================================================

world_state = {
    "room_id": 0,
    "difficulty": 0.5,

    "exit_progress": 0.0,
    "exit_needed": 120.0,

    "tick": 0
}


# =====================================================
# PLAYER
# =====================================================

player = {
    "x": 150,
    "y": 150,
    "angle": 0,
    "hp": 100
}


# =====================================================
# ROOM GENERATION
# =====================================================

def generate_room(room_id, difficulty):

    random.seed(room_id)

    size = 10
    room = []

    for y in range(size):
        row = ""

        for x in range(size):

            if x == 0 or y == 0 or x == size - 1 or y == size - 1:
                row += "1"
            else:
                # difficulty increases wall density
                if random.random() < 0.2 + difficulty * 0.25:
                    row += "1"
                else:
                    row += "0"

        room.append(row)

    return room


def get_room():
    return generate_room(world_state["room_id"], world_state["difficulty"])


# =====================================================
# ENEMIES
# =====================================================

enemies = []


def spawn_enemy():

    return {
        "x": random.randint(100, 400),
        "y": random.randint(100, 400),
        "alive": True,
        "speed": 1.0
    }


def spawn_enemies():

    enemies.clear()

    count = int(4 + world_state["difficulty"] * 8)

    for _ in range(count):
        enemies.append(spawn_enemy())


# =====================================================
# WALL CHECK
# =====================================================

def is_wall(x, y):

    grid = get_room()

    mx = int(x / TILE)
    my = int(y / TILE)

    if my < 0 or mx < 0 or my >= len(grid) or mx >= len(grid[0]):
        return True

    return grid[my][mx] == "1"


# =====================================================
# LINE OF SIGHT
# =====================================================

def has_los(ex, ey, px, py):

    dx = px - ex
    dy = py - ey

    dist = math.sqrt(dx*dx + dy*dy)

    for i in range(0, int(dist), 5):

        t = i / (dist + 0.0001)

        x = ex + dx * t
        y = ey + dy * t

        if is_wall(x, y):
            return False

    return True


# =====================================================
# ENEMY AI
# =====================================================

def update_enemies():

    for e in enemies:

        if not e["alive"]:
            continue

        dx = player["x"] - e["x"]
        dy = player["y"] - e["y"]

        dist = math.sqrt(dx*dx + dy*dy)

        if dist > 0:
            dx /= dist
            dy /= dist

        sees = has_los(e["x"], e["y"], player["x"], player["y"])

        speed = 1.0 + world_state["difficulty"] * 0.5

        mx = dx * speed if sees else random.uniform(-0.5, 0.5)
        my = dy * speed if sees else random.uniform(-0.5, 0.5)

        if not is_wall(e["x"] + mx, e["y"]):
            e["x"] += mx

        if not is_wall(e["x"], e["y"] + my):
            e["y"] += my


# =====================================================
# DAMAGE SYSTEM
# =====================================================

def enemy_damage():

    for e in enemies:

        if not e["alive"]:
            continue

        dx = player["x"] - e["x"]
        dy = player["y"] - e["y"]

        if math.sqrt(dx*dx + dy*dy) < 25:

            player["hp"] -= 0.25 * (1.0 + world_state["difficulty"])


# =====================================================
# SHOOTING (CENTER SCREEN)
# =====================================================

def shoot():

    rx = math.cos(player["angle"])
    ry = math.sin(player["angle"])

    hit = None
    best = 9999

    for e in enemies:

        if not e["alive"]:
            continue

        dx = e["x"] - player["x"]
        dy = e["y"] - player["y"]

        proj = dx * rx + dy * ry

        if proj < 0:
            continue

        px = dx - proj * rx
        py = dy - proj * ry

        dist = math.sqrt(px*px + py*py)

        if dist < 35 and proj < best:

            best = proj
            hit = e

    if hit:
        hit["alive"] = False


# =====================================================
# MOVEMENT
# =====================================================

def movement():

    keys = pygame.key.get_pressed()

    speed = 2.5

    if keys[pygame.K_a]:
        player["angle"] -= 0.04

    if keys[pygame.K_d]:
        player["angle"] += 0.04

    dx = math.cos(player["angle"]) * speed * (keys[pygame.K_w] - keys[pygame.K_s])
    dy = math.sin(player["angle"]) * speed * (keys[pygame.K_w] - keys[pygame.K_s])

    if not is_wall(player["x"] + dx, player["y"]):
        player["x"] += dx

    if not is_wall(player["x"], player["y"] + dy):
        player["y"] += dy


# =====================================================
# EXIT PROGRESSION (FIXED PACING)
# =====================================================

def update_exit():

    if player["x"] > 420:

        world_state["exit_progress"] += 1.5 + world_state["difficulty"]

    else:

        world_state["exit_progress"] -= 0.7

    world_state["exit_progress"] = max(0, world_state["exit_progress"])

    if world_state["exit_progress"] >= world_state["exit_needed"]:

        world_state["room_id"] += 1
        world_state["difficulty"] += 0.1

        player["x"] = 120
        player["y"] = 120

        world_state["exit_progress"] = 0

        spawn_enemies()

        print("ENTER ROOM", world_state["room_id"], "DIFF", world_state["difficulty"])


# =====================================================
# DDA RAYCAST (FAST)
# =====================================================

def render(screen):

    p = player

    ray_angle = p["angle"] - HALF_FOV
    step = FOV / NUM_RAYS

    for ray in range(NUM_RAYS):

        sin_a = math.sin(ray_angle)
        cos_a = math.cos(ray_angle)

        map_x = int(p["x"] / TILE)
        map_y = int(p["y"] / TILE)

        delta_x = abs(1 / (cos_a + 1e-6))
        delta_y = abs(1 / (sin_a + 1e-6))

        step_x = -1 if cos_a < 0 else 1
        step_y = -1 if sin_a < 0 else 1

        side_x = delta_x * (1 if step_x > 0 else 0)
        side_y = delta_y * (1 if step_y > 0 else 0)

        hit = False
        side = 0

        for _ in range(20):

            if side_x < side_y:
                side_x += delta_x
                map_x += step_x
                side = 0
            else:
                side_y += delta_y
                map_y += step_y
                side = 1

            try:
                if get_room()[map_y][map_x] == "1":
                    hit = True
                    break
            except:
                hit = True
                break

        dist = (side_x - delta_x) if side == 0 else (side_y - delta_y)
        dist *= TILE
        dist *= math.cos(p["angle"] - ray_angle)

        if dist < 1:
            dist = 1

        h = 5000 / dist

        shade = max(30, 255 / (1 + dist * 0.02))

        color = (shade, shade * 0.8, shade * 0.6)

        pygame.draw.rect(
            screen,
            color,
            (
                ray * (WIDTH // NUM_RAYS),
                HEIGHT // 2 - h // 2,
                WIDTH // NUM_RAYS + 1,
                h
            )
        )

        ray_angle += step


# =====================================================
# ENEMY RENDER
# =====================================================

def draw_enemies(screen):

    for e in enemies:

        if not e["alive"]:
            continue

        dx = e["x"] - player["x"]
        dy = e["y"] - player["y"]

        dist = math.sqrt(dx*dx + dy*dy)

        angle = math.atan2(dy, dx) - player["angle"]

        if -FOV < angle < FOV:

            size = 5000 / (dist + 1)

            sx = int((angle + HALF_FOV) / FOV * WIDTH)

            pygame.draw.circle(
                screen,
                (255, 80, 120),
                (sx, HEIGHT // 2),
                int(size / 25)
            )


# =====================================================
# MAIN LOOP
# =====================================================

def main():

    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()

    spawn_enemies()

    running = True

    while running:

        screen.fill((0, 0, 0))

        pygame.draw.rect(screen, (30, 30, 50), (0, 0, WIDTH, HEIGHT // 2))
        pygame.draw.rect(screen, (20, 20, 20), (0, HEIGHT // 2, WIDTH, HEIGHT))

        for e in pygame.event.get():

            if e.type == pygame.QUIT:
                running = False

            if e.type == pygame.KEYDOWN:

                if e.key == pygame.K_SPACE:
                    shoot()

        movement()

        update_enemies()
        enemy_damage()

        update_exit()

        render(screen)
        draw_enemies(screen)

        # 💀 DEATH CONDITION
        if player["hp"] <= 0:
            print("YOU DIED")
            pygame.quit()
            sys.exit()

        world_state["tick"] += 1

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


if __name__ == "__main__":
    main()