game.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 = {
    "room_id": 0,
    "difficulty": 0.5,
}


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

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


# =====================================================
# MATERIAL DEFINITIONS
# =====================================================

BLOCKS = {
    "wall_thick": True,
    "wall_thin": True,
    "tree_thick": True,
    "tree_thin": True,
    "arch_thick": False,
    "arch_thin": False,
    "empty": False
}


COLORS = {
    "wall_thick": (60, 60, 60),
    "wall_thin": (90, 90, 90),
    "tree_thick": (20, 90, 20),
    "tree_thin": (40, 140, 40),
    "arch_thick": (160, 120, 80),
    "arch_thin": (190, 150, 110),
    "empty": (0, 0, 0)
}


# =====================================================
# ROOM GENERATION (RADIAL + STRUCTURE GRAMMAR)
# =====================================================

def generate_room(room_id, difficulty):

    random.seed(room_id)

    size = 20
    grid = []

    center = size // 2
    radius = 6 + int(difficulty * 4)

    for y in range(size):

        row = []

        for x in range(size):

            dx = x - center
            dy = y - center
            dist = math.sqrt(dx*dx + dy*dy)

            noise = random.random()

            cell = "empty"

            # -----------------------------
            # OUTER WALL RING
            # -----------------------------
            if dist > radius + 1.5:
                cell = "wall_thick"

            elif dist > radius:
                cell = "wall_thin" if noise < 0.6 else "wall_thick"

            # -----------------------------
            # INNER AREA STRUCTURE
            # -----------------------------
            else:

                openness = 0.35 + (1.0 - difficulty) * 0.3

                if noise < openness:
                    cell = "empty"
                else:

                    r = random.random()

                    if r < 0.25:
                        cell = "arch_thin" if noise < 0.5 else "arch_thick"

                    elif r < 0.6:
                        cell = "tree_thin" if noise < 0.5 else "tree_thick"

                    else:
                        cell = "wall_thin"

            row.append(cell)

        grid.append(row)

    return grid


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


# =====================================================
# COLLISION
# =====================================================

def is_blocking(cell):
    return BLOCKS.get(cell, False)


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

def move():

    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])

    grid = get_room()

    def can_move(nx, ny):

        mx = int(nx / TILE)
        my = int(ny / TILE)

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

        return not is_blocking(grid[my][mx])

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

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


# =====================================================
# RAYCAST (WITH MATERIAL SUPPORT)
# =====================================================

def render(screen):

    grid = get_room()

    ray_angle = player["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(player["x"] / TILE)
        map_y = int(player["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
        side_y = delta_y

        hit_cell = "empty"
        dist = 9999

        for _ in range(25):

            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:
                cell = grid[map_y][map_x]

                # -----------------------------
                # TREE = partial occlusion
                # -----------------------------
                if cell.startswith("tree"):
                    continue

                # -----------------------------
                # ARCH = pass-through + visual frame
                # -----------------------------
                if cell.startswith("arch"):
                    hit_cell = cell
                    continue

                # -----------------------------
                # WALL = solid stop
                # -----------------------------
                if is_blocking(cell):
                    hit_cell = cell
                    break

            except:
                break

        dist = min(side_x, side_y) * TILE
        dist *= math.cos(player["angle"] - ray_angle)

        if dist < 1:
            dist = 1

        h = 5000 / dist

        base = 255 / (1 + dist * 0.02)

        # MATERIAL LIGHTING
        color = COLORS.get(hit_cell, (100, 100, 100))

        if hit_cell.startswith("tree"):
            base *= 0.6

        elif hit_cell.startswith("arch"):
            base *= 1.2

        r = min(255, color[0] * base / 255)
        g = min(255, color[1] * base / 255)
        b = min(255, color[2] * base / 255)

        pygame.draw.rect(
            screen,
            (r, g, b),
            (ray * (WIDTH // NUM_RAYS), HEIGHT//2 - h//2, WIDTH//NUM_RAYS, h)
        )

        ray_angle += step


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

def main():

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

    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

        move()
        render(screen)

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

    pygame.quit()
    sys.exit()


if __name__ == "__main__":
    main()