rayforge-burgerguy 0.3.0__tar.gz

rayforge_burgerguy-0.3.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: rayforge-burgerguy
+Version: 0.3.0
+Summary: A small, renderer-agnostic raycasting engine library
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Provides-Extra: pygame
+Requires-Dist: pygame; extra == "pygame"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pillow; extra == "dev"

rayforge_burgerguy-0.3.0/README.md

@@ -0,0 +1,63 @@
+# rayforge 0.3
+
+A toolkit for raycaster (Wolf3D/Doom-style) and Mode 7 (SNES kart-style) games in Python.
+Core needs only NumPy. pygame is optional (windowing, HUD, sound playback). No art or audio files required.
+
+    pip install -e .            # inside this folder
+    pip install pygame          # for App / hud / sound playback
+    python examples/doom_full.py    python examples/kart_race.py    (add --demo to watch a bot play)
+    python -m pytest            # 35 tests
+
+Every pygame app also runs headless: `--frames 120 --screenshot out.png`.
+
+## What's in the box
+
+| Area | Pieces |
+|---|---|
+| **Raycasting** | `GridMap`, `Door`, `Camera`, `cast_ray`, `line_of_sight`, `hitscan`, `Renderer` (textured walls/floors/ceilings, per-cell floors via `floor_map`, sky panorama, coloured fog, doors, billboard `Sprite`s with `z`/`flip`/`fullbright`) |
+| **Mode 7 racing** | `Mode7Renderer`, `M7Camera`, `ChaseCam`, `M7Sprite` (ground shadows, side-on squash), `Track` (spline -> image + surface map + waypoints + grid + minimap, `Track.preset('twisty'/'oval'/'kidney')`), `Vehicle` (drift, mini-turbo, surfaces, collisions, spin-out), `AIDriver`, `Race` (countdown, laps, positions, rubber banding) |
+| **Shooter kit** | `World`, `Entity`, `Actor`, `Player`, `Projectile`, `Pickup`, `Enemy` (idle/chase/attack/pain/dead, A* paths, opens doors, melee or ranged), `astar`, `Inventory` + `PISTOL/SHOTGUN/CHAINGUN/ROCKET`, `Level.from_text`, `create('imp'/'health'/...)`, `register(...)` for your own kinds |
+| **Art** | `textures.*` procedural walls, floors, skies, sprites (imp, kart, tree, cone, barrel, crate, medkit...), `Canvas` to draw your own, `load_image`, `spritesheet`, `Animation` |
+| **Polish** | `ParticleSystem` (both renderers), `effects` (tint, fade, vignette, scanlines, shake, pixelate...), `Shake`, `Timer`, `Cooldown`, easing/math in `util` |
+| **Audio** | `SoundBank` plays ~20 synthesized sounds by name; `.play_events(world.pop_events())`, `.engine(speed)`; `tone`/`noise`/`mix` to make more. Silent no-op without an audio device |
+| **App kit** | `App` (window, loop, fixed-step headless mode), `Input.fps()/racing()` named actions, `hud` (text, bars, crosshair, minimap, `track_minimap`, weapons, flash, `blit_frame`) |
+| **Misc** | `save_png` (no Pillow needed), `move_circle` collision |
+
+## Recipes
+
+**Minimal raycaster**
+```python
+import rayforge as rf
+world = rf.GridMap.from_strings(["#####", "#...#", "#####"])
+frame = rf.Renderer(320, 200, textures={1: rf.textures.brick()}).render(world, rf.Camera(2.5, 1.5))
+rf.save_png(frame, "out.png")
+```
+
+**Shooter from a text map** (see examples/doom_full.py)
+```python
+level = rf.Level.from_text(open("e1m1.txt").read())   # P start, # walls, D doors, R/B locked, i/z/b/g enemies, h/a pickups, E exit
+world = level.build_world(seed=1); player = world.player
+# each frame:  world.update(dt);  player.inventory.fire(world, player);  world.use()
+# draw:        renderer.render(world.grid, player.cam, world.sprites())
+# react:       for name, data in world.pop_events(): ...   # shot, enemy_death, pickup, door, player_hurt, exit...
+```
+
+**Racer** (see examples/kart_race.py)
+```python
+track = rf.Track.from_points([(20,40),(60,20),(100,50),(60,80)], width=7)   # your own circuit
+race = rf.Race(track, laps=3); kart = rf.Vehicle(*track.start)
+race.add(rf.Racer(kart, "me", is_player=True))
+kart.update(dt, throttle, steer, brake, drift, surface=track.surface_at(kart.x, kart.y))
+race.update(dt)   # race.place(racer), race.countdown_text(), race.standings(), race.pop_events()
+```
+
+**A new kind of enemy / pickup**
+```python
+rf.ENEMY_TYPES["cyber"] = rf.EnemyType("cyber", hp=40, speed=2.2, ranged=True, damage=15, color=(60,200,220), scale=1.1)
+rf.register("cyber", lambda x, y: rf.Enemy(x, y, "cyber"))     # now 'c'-style spawns / create('cyber', x, y) work
+```
+
+## Conventions
+- Angles are radians; 0 = +x, +pi/2 = +y (down the map). `right = (-sin a, cos a)`.
+- Raycaster sizes are in map cells / wall heights; Mode 7 sizes are in world units (`scale` px per unit on the track image).
+- Textures are `uint8` arrays: `HxWx3` for walls/floors, `HxWx4` (alpha) for sprites.

rayforge_burgerguy-0.3.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rayforge-burgerguy"
+version = "0.3.0"
+description = "A small, renderer-agnostic raycasting engine library"
+requires-python = ">=3.9"
+dependencies = ["numpy"]
+
+[project.optional-dependencies]
+pygame = ["pygame"]
+dev = ["pytest", "pillow"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

rayforge_burgerguy-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rayforge_burgerguy-0.3.0/src/rayforge/__init__.py

@@ -0,0 +1,43 @@
+"""rayforge: a toolkit for raycasting and Mode-7 games.
+
+Core (pure Python + NumPy):  GridMap, Camera, cast_ray, Renderer, Sprite, hitscan, textures
+Mode 7 racing:               Mode7Renderer, M7Camera, M7Sprite, ChaseCam, Track, Vehicle, AIDriver, Race
+Game kit:                    World, Entity, Actor, Player, Enemy, Projectile, Pickup, Inventory, Level, create()
+Extras:                      ParticleSystem, effects, SoundBank (procedural audio), save_png, util helpers
+pygame helpers (loaded on demand):  App, Input, hud
+"""
+import importlib
+
+from .util import (clamp, lerp, inv_lerp, remap, wrap_angle, angle_diff, approach, smoothstep,
+                   dist, normalize, Timer, Cooldown, Shake, ease_in, ease_out, ease_in_out)
+from .grid import GridMap, Door
+from .collision import move_circle, circle_blocked
+from .camera import Camera
+from .caster import RayHit, cast_ray, cast_rays, line_of_sight
+from .combat import ShotResult, hitscan
+from .render import Renderer, Sprite, sprite_view_index
+from . import textures, effects
+from .textures import Animation, load_image, spritesheet
+from .particles import ParticleSystem
+from .mode7 import Mode7Renderer, M7Camera, M7Sprite, ChaseCam
+from .track import Track, GRASS, ROAD, CURB, BOOST, OFFROAD
+from .vehicle import Vehicle, AIDriver, Race, Racer, SURFACE_PROPS
+from .entities import Entity, Actor, Projectile, Pickup, Player, World
+from .weapons import WeaponDef, Inventory, PISTOL, SHOTGUN, CHAINGUN, ROCKET, WEAPONS
+from .ai import Enemy, EnemyType, ENEMY_TYPES, astar
+from .factory import create, register, kinds
+from .level import Level, Spawn
+from .sound import SoundBank
+from .png import save_png
+
+__version__ = "0.3.0"
+
+_LAZY = {"App": "app", "Input": "app", "parse_args": "app"}
+
+
+def __getattr__(name):            # pygame-dependent bits load only when used
+    if name in ("hud", "app"):
+        return importlib.import_module(f".{name}", __name__)
+    if name in _LAZY:
+        return getattr(importlib.import_module(f".{_LAZY[name]}", __name__), name)
+    raise AttributeError(f"module 'rayforge' has no attribute {name!r}")

rayforge_burgerguy-0.3.0/src/rayforge/ai.py

@@ -0,0 +1,213 @@
+"""Enemy AI: A* pathfinding, line-of-sight, and a ready-made Enemy actor
+(idle -> chase -> attack / pain -> dead) with melee and ranged types."""
+from __future__ import annotations
+import heapq, math
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+from .caster import line_of_sight
+from .entities import Actor, Projectile
+from .render import Sprite
+from .util import wrap_angle
+from . import textures
+
+
+def astar(grid, start: Tuple[int, int], goal: Tuple[int, int], through_doors=True,
+          max_nodes=3000, through_locked=False) -> List[Tuple[float, float]]:
+    """Shortest path over grid cells (8-way, no corner cutting). Returns cell
+    centres from the step after `start` to `goal`; [] if unreachable."""
+    if start == goal:
+        return []
+    ok = lambda x, y: grid.passable(x, y, through_doors, through_locked)
+    if not ok(*goal):
+        return []
+    def h(a, b):
+        dx, dy = abs(a[0] - b[0]), abs(a[1] - b[1])
+        return (dx + dy) + (1.4142 - 2) * min(dx, dy)
+    openq = [(h(start, goal), 0.0, start)]
+    came, g = {}, {start: 0.0}
+    n = 0
+    while openq and n < max_nodes:
+        _, cost, cur = heapq.heappop(openq)
+        if cur == goal:
+            path = [cur]
+            while cur in came:
+                cur = came[cur]; path.append(cur)
+            return [(x + .5, y + .5) for x, y in reversed(path[:-1])]
+        if cost > g.get(cur, 1e9):
+            continue
+        n += 1
+        for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1), (1, 1), (1, -1), (-1, 1), (-1, -1)):
+            nx, ny = cur[0] + dx, cur[1] + dy
+            if not ok(nx, ny):
+                continue
+            if dx and dy and not (ok(cur[0] + dx, cur[1]) and ok(cur[0], cur[1] + dy)):
+                continue
+            nc = cost + (1.4142 if dx and dy else 1.0)
+            if nc < g.get((nx, ny), 1e9):
+                g[(nx, ny)] = nc; came[(nx, ny)] = cur
+                heapq.heappush(openq, (nc + h((nx, ny), goal), nc, (nx, ny)))
+    return []
+
+
+@dataclass
+class EnemyType:
+    name: str
+    hp: float = 6
+    speed: float = 1.9
+    sight: float = 14.0
+    attack_range: float = 1.1
+    attack_cooldown: float = 1.2
+    windup: float = 0.3
+    damage: float = 8
+    ranged: bool = False
+    projectile_speed: float = 5.5
+    pain_chance: float = 0.6
+    pain_time: float = 0.25
+    scale: float = 0.85
+    radius: float = 0.3
+    color: Tuple[int, int, int] = (170, 55, 40)
+    score: int = 100
+    persistence: float = 30.0      # seconds an enemy keeps hunting after losing sight of you
+
+
+ENEMY_TYPES: Dict[str, EnemyType] = {
+    "imp":    EnemyType("imp", hp=6, speed=2.0, ranged=True, attack_range=9.0, attack_cooldown=1.7, damage=7),
+    "zombie": EnemyType("zombie", hp=4, speed=1.2, attack_range=1.1, damage=6, pain_chance=0.8,
+                        color=(80, 140, 70), score=60),
+    "brute":  EnemyType("brute", hp=20, speed=1.5, attack_range=1.3, damage=18, pain_chance=0.15, scale=1.05,
+                        radius=0.4, color=(125, 60, 155), score=300),
+    "ghost":  EnemyType("ghost", hp=5, speed=3.0, attack_range=1.0, damage=5, pain_chance=0.4,
+                        color=(150, 185, 235), score=120),
+}
+
+_cache: Dict[Tuple, tuple] = {}
+def _enemy_textures(color):
+    if color not in _cache:
+        base = textures.imp(64, color)
+        _cache[color] = (base, textures.tint(base, (255, 255, 255), 0.8), textures.corpse(base))
+    return _cache[color]
+
+_fire = None
+def _fireball():
+    global _fire
+    if _fire is None: _fire = textures.fireball(24)
+    return _fire
+
+
+class Enemy(Actor):
+    def __init__(self, x, y, kind="imp"):
+        t = ENEMY_TYPES[kind] if isinstance(kind, str) else kind
+        self.type = t
+        self.tex, self.flash_tex, self.corpse_tex = _enemy_textures(t.color)
+        super().__init__(x, y, hp=t.hp, team="enemy", radius=t.radius, name=t.name,
+                         sprite=Sprite(x, y, texture=self.tex, scale=t.scale))
+        self.state, self.state_t = "idle", 0.0
+        self.cool, self.flash, self.memory = 0.0, 0.0, 0.0
+        self.path: List[Tuple[float, float]] = []
+        self.path_t = 0.0
+        self.did_attack = False
+
+    # --- hooks ---
+    def hear(self):
+        if self.state == "idle" and not self.dead:
+            self.state, self.memory = "chase", self.type.persistence
+
+    def on_hurt(self, dmg, source, world):
+        self.flash = 0.12
+        if self.state == "idle":
+            self.state, self.memory = "chase", self.type.persistence
+        if self.state in ("chase", "idle") and world and world.rng.random() < self.type.pain_chance:
+            self.state, self.state_t = "pain", 0.0
+        if world: world.emit("enemy_hurt", enemy=self)
+
+    def on_death(self, source, world):
+        self.state, self.solid = "dead", False
+        self.sprite.texture, self.sprite.scale, self.sprite.z = self.corpse_tex, self.type.scale, 0.0
+        if source is not None and hasattr(source, "score"):
+            source.score += self.type.score
+        if world: world.emit("enemy_death", enemy=self)
+
+    # --- helpers ---
+    def _step(self, world, tx, ty, dt, speed=None):
+        d = math.hypot(tx - self.x, ty - self.y)
+        if d < 1e-6:
+            return
+        sp = (speed or self.type.speed) * dt
+        self.angle = math.atan2(ty - self.y, tx - self.x)
+        dx, dy = (tx - self.x) / d * sp, (ty - self.y) / d * sp
+        for o in world.query(self.x, self.y, self.radius * 2.2, lambda e: isinstance(e, Enemy) and e is not self and not e.dead):
+            ox, oy = self.x - o.x, self.y - o.y
+            od = math.hypot(ox, oy) or 1.0
+            dx += ox / od * sp * 0.5; dy += oy / od * sp * 0.5
+        if self.move(world.grid, dx, dy):
+            ax, ay = self.x + math.cos(self.angle) * 0.7, self.y + math.sin(self.angle) * 0.7
+            door = world.grid.get_door(int(ax // 1), int(ay // 1))
+            if door is not None and not door.key:      # monsters can't pick locks
+                door.activate()
+
+    def _approach(self, world, p, sees, dt):
+        if sees:
+            self.path.clear()
+            self._step(world, p.x, p.y, dt)
+            return
+        self.path_t -= dt
+        if self.path_t <= 0 or not self.path:
+            self.path = astar(world.grid, (int(self.x // 1), int(self.y // 1)), (int(p.x // 1), int(p.y // 1)))
+            self.path_t = 0.6
+        while self.path and math.hypot(self.path[0][0] - self.x, self.path[0][1] - self.y) < 0.3:
+            self.path.pop(0)
+        if self.path:
+            self._step(world, *self.path[0], dt)
+
+    def _attack(self, world, p):
+        t = self.type
+        if t.ranged:
+            ang = math.atan2(p.y - self.y, p.x - self.x)
+            spr = Sprite(self.x, self.y, texture=_fireball(), scale=0.22, z=0.4, fullbright=True)
+            world.add(Projectile(self.x + math.cos(ang) * 0.4, self.y + math.sin(ang) * 0.4, ang,
+                                 t.projectile_speed, t.damage, self, sprite=spr))
+            world.emit("enemy_shoot", enemy=self)
+        elif math.hypot(p.x - self.x, p.y - self.y) <= t.attack_range + p.radius + 0.3:
+            p.hurt(t.damage, self, world)
+            world.emit("enemy_melee", enemy=self)
+
+    # --- frame ---
+    def update(self, dt, world):
+        self.age += dt
+        self.state_t += dt
+        self.flash = max(0.0, self.flash - dt)
+        self.cool = max(0.0, self.cool - dt)
+        self.sprite.texture = self.corpse_tex if self.dead else (self.flash_tex if self.flash > 0 else self.tex)
+        self.sync_sprite()
+        p = world.player
+        if self.dead or p is None or p.dead:
+            return
+        t = self.type
+        d = math.hypot(p.x - self.x, p.y - self.y)
+        sees = d < t.sight and line_of_sight(world.grid, self.x, self.y, p.x, p.y)
+
+        if self.state == "idle":
+            if sees:
+                self.state, self.memory = "chase", t.persistence
+                world.emit("enemy_alert", enemy=self)
+        elif self.state == "pain":
+            if self.state_t >= t.pain_time:
+                self.state, self.state_t = "chase", 0.0
+        elif self.state == "chase":
+            self.memory = t.persistence if sees else self.memory - dt
+            if self.memory <= 0:
+                self.state = "idle"
+            elif sees and d <= t.attack_range and self.cool <= 0:
+                self.state, self.state_t, self.did_attack = "attack", 0.0, False
+                self.angle = math.atan2(p.y - self.y, p.x - self.x)
+            elif not (sees and d <= (t.attack_range * 0.8 if not t.ranged else t.attack_range * 0.5)):
+                self._approach(world, p, sees, dt)
+                self.sprite.z = abs(math.sin(self.age * 9)) * 0.035
+        elif self.state == "attack":
+            self.sprite.z = 0.0
+            if not self.did_attack and self.state_t >= t.windup:
+                self.did_attack = True
+                self._attack(world, p)
+                self.cool = t.attack_cooldown
+            if self.state_t >= t.windup + 0.25:
+                self.state, self.state_t = "chase", 0.0

rayforge_burgerguy-0.3.0/src/rayforge/app.py

@@ -0,0 +1,144 @@
+"""Game framework: window, loop, input actions, mouse look, headless test mode.
+
+    class MyGame(App):
+        title, width, height, scale = "My game", 400, 250, 3
+        def setup(self):  ...                      # build your world
+        def update(self, dt): ...                  # self.input.down("forward") etc.
+        def draw(self, screen): ...                # draw into the window surface
+    MyGame().run()
+
+Run any app headless with:  python game.py --frames 120 --screenshot out.png
+"""
+from __future__ import annotations
+import argparse, os
+import numpy as np
+
+
+def parse_args(extra=None):
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--frames", type=int, default=0, help="run N frames then quit (headless, fixed timestep)")
+    ap.add_argument("--screenshot", help="save the final frame to this PNG")
+    ap.add_argument("--seed", type=int)
+    ap.add_argument("--scale", type=int)
+    ap.add_argument("--demo", action="store_true", help="let your game run itself (if it supports it)")
+    ap.add_argument("--mute", action="store_true")
+    if extra: extra(ap)
+    return ap.parse_args()
+
+
+class Input:
+    """Named actions bound to keys. input.down('fire'), input.pressed('use'), input.mouse_dx."""
+    def __init__(self):
+        import pygame
+        self.pg = pygame
+        self.bindings, self.mouse_dx, self.mouse_dy = {}, 0, 0
+        self._prev, self._cur, self._mouse_prev, self._mouse = {}, {}, (0, 0, 0), (0, 0, 0)
+        self._wheel = 0
+
+    def bind(self, action, *keys):
+        """keys are pygame key names: 'w', 'space', 'left', 'lshift', 'return', 'mouse1'/'mouse2'/'mouse3'."""
+        self.bindings[action] = keys
+        return self
+
+    @classmethod
+    def fps(cls):
+        i = cls()
+        return (i.bind("forward", "w", "up").bind("back", "s", "down").bind("left", "a").bind("right", "d")
+                .bind("turn_left", "q", "left").bind("turn_right", "e", "right")
+                .bind("fire", "space", "mouse1").bind("sprint", "left shift").bind("use", "f", "return")
+                .bind("map", "m").bind("next_weapon", "x").bind("prev_weapon", "z")
+                .bind("weapon1", "1").bind("weapon2", "2").bind("weapon3", "3").bind("weapon4", "4")
+                .bind("restart", "r").bind("quit", "escape"))
+
+    @classmethod
+    def racing(cls):
+        i = cls()
+        return (i.bind("accelerate", "w", "up").bind("brake", "s", "down").bind("left", "a", "left")
+                .bind("right", "d", "right").bind("drift", "left shift", "space").bind("item", "e", "left ctrl")
+                .bind("restart", "r").bind("quit", "escape"))
+
+    def _held(self, name, keys, mouse):
+        pg = self.pg
+        if name.startswith("mouse"):
+            return bool(mouse[int(name[5:]) - 1])
+        return bool(keys[pg.key.key_code(name)])
+
+    def poll(self, events=()):
+        pg = self.pg
+        keys, mouse = pg.key.get_pressed(), pg.mouse.get_pressed()
+        self._prev = self._cur
+        self._cur = {a: any(self._held(k, keys, mouse) for k in ks) for a, ks in self.bindings.items()}
+        self.mouse_dx, self.mouse_dy = pg.mouse.get_rel()
+        self._wheel = sum(e.y for e in events if e.type == pg.MOUSEWHEEL)
+
+    def down(self, a): return self._cur.get(a, False)
+    def pressed(self, a): return self._cur.get(a, False) and not self._prev.get(a, False)
+    def released(self, a): return self._prev.get(a, False) and not self._cur.get(a, False)
+    def axis(self, neg, pos): return float(self.down(pos)) - float(self.down(neg))
+    @property
+    def wheel(self): return self._wheel
+
+
+class App:
+    title = "rayforge"
+    width, height, scale, fps = 400, 250, 3, 60
+    mouse_look = False
+    input_factory = staticmethod(Input.fps)
+
+    def __init__(self, args=None):
+        self.args = args or parse_args()
+        self.frame_no, self.time, self.running = 0, 0.0, True
+        self.screen = self.clock = self.input = None
+
+    # ---- override these ----
+    def setup(self): pass
+    def update(self, dt): pass
+    def draw(self, screen): pass
+    def on_event(self, e): pass
+
+    # ---- helpers ----
+    @property
+    def window_size(self):
+        s = self.args.scale or self.scale
+        return self.width * s, self.height * s
+
+    def quit(self): self.running = False
+
+    def screenshot(self, path):
+        import pygame
+        pygame.image.save(self.screen, path)
+
+    def run(self):
+        a = self.args
+        if a.frames:
+            os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
+            os.environ.setdefault("SDL_AUDIODRIVER", "dummy")
+        import pygame
+        pygame.init()
+        self.screen = pygame.display.set_mode(self.window_size)
+        pygame.display.set_caption(self.title)
+        self.clock = pygame.time.Clock()
+        self.input = self.input_factory()
+        if self.mouse_look and not a.frames:
+            pygame.mouse.set_visible(False); pygame.event.set_grab(True)
+        pygame.mouse.get_rel()
+        self.setup()
+        while self.running:
+            dt = (1.0 / self.fps) if a.frames else min(self.clock.tick(self.fps) / 1000.0, 0.05)
+            events = pygame.event.get()
+            for e in events:
+                if e.type == pygame.QUIT:
+                    self.running = False
+                self.on_event(e)
+            self.input.poll(events)
+            if self.input.pressed("quit"):
+                self.running = False
+            self.update(dt)
+            self.draw(self.screen)
+            pygame.display.flip()
+            self.time += dt; self.frame_no += 1
+            if a.frames and self.frame_no >= a.frames:
+                self.running = False
+        if a.screenshot:
+            self.screenshot(a.screenshot)
+        pygame.quit()

rayforge_burgerguy-0.3.0/src/rayforge/camera.py

@@ -0,0 +1,35 @@
+"""First-person camera with circle collision."""
+from __future__ import annotations
+import math
+from dataclasses import dataclass
+from .grid import GridMap
+from .collision import move_circle
+
+
+@dataclass
+class Camera:
+    x: float = 1.5
+    y: float = 1.5
+    angle: float = 0.0                 # radians; 0 = +x, pi/2 = +y (down on the map)
+    fov: float = math.radians(66)
+    radius: float = 0.2
+
+    @property
+    def dir(self): return math.cos(self.angle), math.sin(self.angle)
+    @property
+    def right(self): return -math.sin(self.angle), math.cos(self.angle)
+
+    def rotate(self, delta: float) -> None:
+        self.angle = (self.angle + delta) % math.tau
+
+    def look_at(self, x: float, y: float) -> None:
+        self.angle = math.atan2(y - self.y, x - self.x) % math.tau
+
+    def move(self, grid: GridMap, dx: float, dy: float) -> None:
+        self.x, self.y = move_circle(grid, self.x, self.y, dx, dy, self.radius)
+
+    def move_forward(self, grid: GridMap, dist: float) -> None:
+        self.move(grid, math.cos(self.angle) * dist, math.sin(self.angle) * dist)
+
+    def strafe(self, grid: GridMap, dist: float) -> None:
+        self.move(grid, -math.sin(self.angle) * dist, math.cos(self.angle) * dist)

rayforge_burgerguy-0.3.0/src/rayforge/caster.py

@@ -0,0 +1,80 @@
+"""DDA grid ray casting (Amanatides & Woo), door-aware."""
+from __future__ import annotations
+import math
+from dataclasses import dataclass
+from typing import List, Optional
+from .grid import GridMap
+
+_INF = float("inf")
+
+
+@dataclass
+class RayHit:
+    tile: int
+    map_x: int
+    map_y: int
+    side: int            # 0 = hit a vertical (x-facing) face, 1 = horizontal
+    distance: float      # euclidean distance from ray origin
+    wall_x: float        # 0..1 position along the face (texture u)
+    x: float
+    y: float
+    angle: float = 0.0
+    perp_distance: float = 0.0
+    is_door: bool = False
+
+
+def cast_ray(grid: GridMap, ox: float, oy: float, angle: float,
+             max_dist: float = 64.0) -> Optional[RayHit]:
+    dx, dy = math.cos(angle), math.sin(angle)
+    mx, my = int(math.floor(ox)), int(math.floor(oy))
+    ddx = abs(1.0 / dx) if dx else _INF
+    ddy = abs(1.0 / dy) if dy else _INF
+    if dx < 0: step_x, sx = -1, (ox - mx) * ddx
+    else:      step_x, sx = 1, (mx + 1.0 - ox) * ddx
+    if dy < 0: step_y, sy = -1, (oy - my) * ddy
+    else:      step_y, sy = 1, (my + 1.0 - oy) * ddy
+
+    side, dist = 0, 0.0
+    doors = grid.doors
+    while dist <= max_dist:
+        if sx < sy:
+            dist, sx, mx, side = sx, sx + ddx, mx + step_x, 0
+        else:
+            dist, sy, my, side = sy, sy + ddy, my + step_y, 1
+        tile = grid.get(mx, my)
+        if tile:
+            hx, hy = ox + dx * dist, oy + dy * dist
+            u = (hy if side == 0 else hx) % 1.0
+            if (side == 0 and dx > 0) or (side == 1 and dy < 0):
+                u = 1.0 - u
+            door = doors.get((mx, my)) if doors else None
+            if door is not None and door.open > 0:
+                if u >= 1.0 - door.open:      # the gap the door has slid open
+                    continue
+                u += door.open                # texture slides with the door
+            return RayHit(tile, mx, my, side, dist, u, hx, hy, angle, is_door=door is not None)
+    return None
+
+
+def cast_rays(grid: GridMap, ox: float, oy: float, direction: float,
+              fov: float, columns: int, max_dist: float = 64.0) -> List[Optional[RayHit]]:
+    """One ray per screen column (flat projection plane, no fisheye)."""
+    half = math.tan(fov / 2.0)
+    out: List[Optional[RayHit]] = []
+    for i in range(columns):
+        offset = (2.0 * (i + 0.5) / columns - 1.0) * half
+        a = direction + math.atan(offset)
+        hit = cast_ray(grid, ox, oy, a, max_dist)
+        if hit is not None:
+            hit.perp_distance = hit.distance * math.cos(a - direction)
+        out.append(hit)
+    return out
+
+
+def line_of_sight(grid: GridMap, x0: float, y0: float, x1: float, y1: float) -> bool:
+    """True if no wall (or closed door) lies between the two points."""
+    d = math.hypot(x1 - x0, y1 - y0)
+    if d < 1e-6:
+        return True
+    hit = cast_ray(grid, x0, y0, math.atan2(y1 - y0, x1 - x0), d + 0.01)
+    return hit is None or hit.distance >= d

rayforge_burgerguy-0.3.0/src/rayforge/collision.py

@@ -0,0 +1,24 @@
+"""Circle-vs-grid collision with wall sliding."""
+from __future__ import annotations
+import math
+
+
+def circle_blocked(grid, x: float, y: float, r: float) -> bool:
+    for cy in range(int(math.floor(y - r)), int(math.floor(y + r)) + 1):
+        for cx in range(int(math.floor(x - r)), int(math.floor(x + r)) + 1):
+            if grid.is_solid(cx + .5, cy + .5):
+                nx = min(max(x, cx), cx + 1)
+                ny = min(max(y, cy), cy + 1)
+                if (x - nx) ** 2 + (y - ny) ** 2 < r * r:
+                    return True
+    return False
+
+
+def move_circle(grid, x: float, y: float, dx: float, dy: float, r: float):
+    """Move a circle by (dx, dy), sliding along walls. Returns (new_x, new_y)."""
+    steps = max(1, int(max(abs(dx), abs(dy)) / max(r, 0.05) + 0.999))   # no tunnelling
+    sx, sy = dx / steps, dy / steps
+    for _ in range(steps):
+        if not circle_blocked(grid, x + sx, y, r): x += sx
+        if not circle_blocked(grid, x, y + sy, r): y += sy
+    return x, y

rayforge_burgerguy-0.3.0/src/rayforge/combat.py

@@ -0,0 +1,33 @@
+"""Hitscan shooting: a ray that stops at walls and hits the nearest target.
+
+A target is any object with `.x` and `.y` (and optionally `.radius`)."""
+from __future__ import annotations
+import math
+from dataclasses import dataclass
+from typing import Any, Iterable, Optional
+from .grid import GridMap
+from .caster import RayHit, cast_ray
+
+
+@dataclass
+class ShotResult:
+    target: Optional[Any]         # nearest target hit, or None
+    distance: float               # distance to whatever was hit
+    wall: Optional[RayHit]        # the wall behind it (None if out of range)
+
+
+def hitscan(grid: GridMap, x: float, y: float, angle: float,
+            targets: Iterable[Any], max_dist: float = 30.0,
+            radius: float = 0.3) -> ShotResult:
+    wall = cast_ray(grid, x, y, angle, max_dist)
+    limit = wall.distance if wall else max_dist
+    dx, dy = math.cos(angle), math.sin(angle)
+    best, best_d = None, limit
+    for t in targets:
+        rx, ry = t.x - x, t.y - y
+        along = rx * dx + ry * dy                 # distance along the ray
+        if along <= 0 or along >= best_d:
+            continue
+        if abs(-rx * dy + ry * dx) <= getattr(t, "radius", radius):  # sideways miss
+            best, best_d = t, along
+    return ShotResult(best, best_d, wall)