quake-rb 0.1.0

data/lib/quake/game/engine.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require_relative "../debug/screenshot"
+
+module Quake
+  module Game
+    # Encapsulates the entire game state and per-frame loop, allowing both
+    # interactive (bin/quake) and scripted (bin/quake-debug) execution.
+    class Engine
+      attr_reader :pak, :palette, :wad, :window, :level, :entities,
+                  :player, :player_state, :camera,
+                  :viewmodel, :hud, :particles, :sound_events,
+                  :brush_game, :item_pickups
+      attr_accessor :game_time
+
+      def initialize(pak_path:, window: nil, window_visible: true,
+                     window_width: nil, window_height: nil,
+                     enable_sound: true, enable_render: true)
+        @enable_render = enable_render
+
+        # PAK + assets
+        @pak = Pak::Reader.new(pak_path)
+        @palette = Palette.new(@pak.read("gfx/palette.lmp"))
+
+        wad_data = @pak.read("gfx.wad")
+        @wad = Wad::Reader.new(wad_data) if wad_data
+
+        # Sound (optional)
+        if enable_sound
+          @sound_mixer = Sound::Mixer.new(@pak)
+          @sound_mixer.open
+        end
+        @sound_events = Sound::Events.new(@sound_mixer)
+
+        # Window
+        if window
+          @window = window
+          @owns_window = false
+        else
+          opts = { visible: window_visible }
+          opts[:width] = window_width if window_width
+          opts[:height] = window_height if window_height
+          @window = Window.new(**opts)
+          @owns_window = true
+        end
+
+        @keys = {}
+        @game_time = 0.0
+      end
+
+      # Load a BSP map and (re)build all per-level state.
+      def load_map(map_name)
+        bsp_data = @pak.read(map_name)
+        raise "Map not found: #{map_name}" unless bsp_data
+
+        @level = Bsp::Reader.new(bsp_data).parse
+        @entities = EntityParser.parse(@level.entities)
+        @target_map = EntityParser.build_target_map(@entities)
+
+        # Find player start
+        player_ent = @entities.find { |e| e.classname == "info_player_start" }
+        @player_start = player_ent&.position || Math::Vec3::ORIGIN
+        @player_yaw = player_ent&.angle || 0.0
+
+        # Load MDL models referenced by entities
+        @mdl_cache ||= {}
+        @entities.each do |ent|
+          model_path = ent["model"]
+          next unless model_path&.end_with?(".mdl")
+          next if @mdl_cache.key?(model_path)
+          begin
+            mdl_data = @pak.read(model_path)
+            @mdl_cache[model_path] = Mdl::Reader.new(mdl_data).parse
+          rescue => e
+            warn "Failed to load #{model_path}: #{e.message}"
+            @mdl_cache[model_path] = nil
+          end
+        end
+
+        # Persistent player state across level loads
+        @player_state ||= PlayerState.new
+        @item_pickups = ItemPickups.new(@entities)
+        @brush_game = BrushEntities.new(@entities, @level, @target_map)
+
+        # Player + camera (reset position to start)
+        @player = Physics::Player.new(position: @player_start, yaw: @player_yaw)
+        @camera = Camera.new(position: @player.eye_position, yaw: @player_yaw)
+
+        build_renderers if @enable_render
+      end
+
+      # Update + render one frame.
+      def tick(dt)
+        @game_time += dt
+
+        # Brush entities first (so collision uses current positions)
+        if @brush_game
+          @brush_game.update(dt, @player.position)
+          @brush_game.check_triggers(@player.position) do |trigger|
+            handle_trigger(trigger)
+          end
+
+          snapped = @brush_game.snap_to_platform(@player.position)
+          if snapped
+            @player.position = snapped
+            @player.on_ground = true
+            @player.velocity = Math::Vec3.new(@player.velocity.x, @player.velocity.y, 0.0)
+          end
+        end
+
+        solid_brush = @entities.select(&:brush_entity?)
+        @player.update(dt, @level, @keys, brush_entities: solid_brush)
+
+        # Item pickups
+        events = @item_pickups.check_pickups(@player.position, @player_state)
+        events.each do |evt|
+          @sound_events&.on_pickup(evt)
+          @particles&.pickup_effect(evt[:entity].position)
+          @viewmodel&.set_weapon(@player_state.current_weapon_model)
+        end
+
+        # Viewmodel bob (before camera so bob is applied to camera too)
+        if @viewmodel
+          speed = ::Math.sqrt(@player.velocity.x**2 + @player.velocity.y**2)
+          @viewmodel.update(dt, speed)
+        end
+
+        # Sync camera
+        eye = @player.eye_position
+        bob = @viewmodel ? @viewmodel.bob : 0.0
+        @camera.position = Math::Vec3.new(eye.x, eye.y, eye.z + bob)
+        @camera.yaw = @player.yaw
+        @camera.pitch = @player.pitch
+
+        return unless @enable_render
+
+        @world_renderer.update(dt) if @world_renderer.respond_to?(:update)
+        @particles&.update(dt)
+
+        render
+      end
+
+      def render
+        @world_renderer.render(@camera, @window.aspect_ratio)
+        @brush_renderer&.render(@entities)
+
+        @entities.each do |ent|
+          next if @item_pickups.picked_up?(ent)
+          model_path = ent["model"]
+          next unless model_path&.end_with?(".mdl")
+
+          gl_model = @mdl_renderers[model_path]
+          next unless gl_model
+
+          frame_rate = 10.0
+          frame = (@game_time * frame_rate).to_i
+          lerp = (@game_time * frame_rate) % 1.0
+
+          gl_model.render(
+            frame_index: frame,
+            lerp: lerp,
+            position: ent.position,
+            yaw: ent.angle
+          )
+        end
+
+        @particles&.render
+        @viewmodel&.render(@camera, @window.aspect_ratio)
+        @hud&.render(@player_state)
+      end
+
+      def swap_buffers
+        @window.swap
+      end
+
+      # ---------------------- input control ----------------------
+
+      def set_key(scancode, pressed)
+        @keys[scancode] = pressed
+      end
+
+      def set_keys(keys_hash)
+        @keys = keys_hash.dup
+      end
+
+      def clear_keys
+        @keys = {}
+      end
+
+      def keys
+        @keys
+      end
+
+      # ---------------------- player control ---------------------
+
+      def teleport(x, y, z, yaw: nil, pitch: nil)
+        @player.position = Math::Vec3.new(x.to_f, y.to_f, z.to_f)
+        @player.velocity = Math::Vec3::ORIGIN
+        @player.instance_variable_set(:@yaw, yaw.to_f) if yaw
+        @player.instance_variable_set(:@pitch, pitch.to_f) if pitch
+        @camera.position = @player.eye_position
+        @camera.yaw = @player.yaw
+        @camera.pitch = @player.pitch
+      end
+
+      # ---------------------- debug output -----------------------
+
+      def screenshot(filename)
+        Debug::Screenshot.save(filename, @window.width, @window.height)
+      end
+
+      def dump_state
+        {
+          time: @game_time,
+          player: {
+            position: vec_to_a(@player.position),
+            velocity: vec_to_a(@player.velocity),
+            yaw: @player.yaw,
+            pitch: @player.pitch,
+            on_ground: @player.on_ground,
+            water_level: @player.water_level,
+            noclip: @player.noclip
+          },
+          stats: {
+            health: @player_state.health,
+            armor: @player_state.armor,
+            armor_type: @player_state.armor_type,
+            current_weapon: @player_state.current_weapon,
+            ammo: @player_state.ammo.dup
+          },
+          brush_entities: brush_entity_summaries,
+          particles: @particles ? @particles.particle_count : 0
+        }
+      end
+
+      def shutdown
+        @sound_mixer&.close
+        if @owns_window
+          @window&.close
+        end
+        @pak.close
+      end
+
+      private
+
+      def vec_to_a(v)
+        [v.x.round(3), v.y.round(3), v.z.round(3)]
+      end
+
+      def brush_entity_summaries
+        return [] unless @brush_game
+        @entities.select(&:brush_entity?).map do |e|
+          {
+            classname: e.classname,
+            targetname: e.targetname,
+            state: e.state,
+            position: vec_to_a(e.position)
+          }
+        end
+      end
+
+      def build_renderers
+        @tex_manager = Renderer::GLTextureManager.new(@level, @palette)
+        @tex_manager.upload_all
+
+        @lightmap = Renderer::GLLightmap.new(@level, @palette)
+        @lightmap.build_all
+
+        @sky = Renderer::GLSky.new(@level, @palette, @tex_manager)
+        @water = Renderer::GLWater.new(@level, @tex_manager)
+
+        @world_renderer = Renderer::GLTextured.new(
+          @level, @tex_manager,
+          lightmap: @lightmap, sky: @sky, water: @water
+        )
+
+        @brush_renderer = Renderer::GLBrushModel.new(@level, @tex_manager, @lightmap)
+
+        @mdl_renderers = {}
+        @mdl_cache.each do |path, mdl|
+          next unless mdl
+          @mdl_renderers[path] = Renderer::GLAliasModel.new(mdl, @palette)
+        end
+
+        @viewmodel = Renderer::GLViewmodel.new(@pak, @palette)
+        @viewmodel.set_weapon(@player_state.current_weapon_model)
+
+        @hud = Renderer::GLHud.new(@wad, @palette, @window.width, @window.height) if @wad
+        @particles = Renderer::GLParticles.new(@palette)
+      end
+
+      def handle_trigger(trigger)
+        case trigger.classname
+        when "trigger_changelevel"
+          # Will be implemented later (level transitions)
+        end
+      end
+    end
+  end
+end

data/lib/quake/game/item_pickups.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Quake
+  module Game
+    # Handles item pickup logic: checks proximity between player and item
+    # entities, applies effects to PlayerState, marks items as picked up.
+    class ItemPickups
+      PICKUP_RADIUS = 32.0 # units (roughly player bbox width)
+
+      # Pickup definitions: classname -> { type:, ... }
+      ITEMS = {
+        # Health
+        "item_health" => { type: :health, amount: 25 },
+
+        # Armor
+        "item_armor1" => { type: :armor, points: 100, armor_type: 1 }, # green
+        "item_armor2" => { type: :armor, points: 150, armor_type: 2 }, # yellow
+        "item_armorInv" => { type: :armor, points: 200, armor_type: 3 }, # red
+
+        # Ammo
+        "item_shells" => { type: :ammo, ammo_type: :shells, amount: 20 },
+        "item_spikes" => { type: :ammo, ammo_type: :nails, amount: 25 },
+        "item_rockets" => { type: :ammo, ammo_type: :rockets, amount: 5 },
+        "item_cells" => { type: :ammo, ammo_type: :cells, amount: 6 },
+
+        # Weapons (give weapon + starting ammo)
+        "weapon_supershotgun" => {
+          type: :weapon, weapon: :super_shotgun,
+          ammo_type: :shells, ammo_amount: 5
+        },
+        "weapon_nailgun" => {
+          type: :weapon, weapon: :nailgun,
+          ammo_type: :nails, ammo_amount: 30
+        },
+        "weapon_supernailgun" => {
+          type: :weapon, weapon: :super_nailgun,
+          ammo_type: :nails, ammo_amount: 30
+        },
+        "weapon_grenadelauncher" => {
+          type: :weapon, weapon: :grenade_launcher,
+          ammo_type: :rockets, ammo_amount: 5
+        },
+        "weapon_rocketlauncher" => {
+          type: :weapon, weapon: :rocket_launcher,
+          ammo_type: :rockets, ammo_amount: 5
+        },
+        "weapon_lightning" => {
+          type: :weapon, weapon: :lightning_gun,
+          ammo_type: :cells, ammo_amount: 15
+        },
+
+        # Powerups
+        "item_artifact_super_damage" => { type: :powerup, powerup: :quad },
+        "item_artifact_invulnerability" => { type: :powerup, powerup: :pentagram },
+        "item_artifact_envirosuit" => { type: :powerup, powerup: :biosuit },
+        "item_artifact_invisibility" => { type: :powerup, powerup: :ring }
+      }.freeze
+
+      def initialize(entities)
+        @item_entities = entities.select { |e| ITEMS.key?(e.classname) }
+        @picked_up = Set.new # entity object_ids that have been collected
+      end
+
+      # Check for pickups near player position. Returns array of pickup
+      # event hashes (for sound/effect triggering).
+      def check_pickups(player_pos, player_state)
+        events = []
+
+        @item_entities.each do |ent|
+          next if @picked_up.include?(ent.object_id)
+
+          dx = player_pos.x - ent.position.x
+          dy = player_pos.y - ent.position.y
+          dz = player_pos.z - ent.position.z
+          dist_sq = dx * dx + dy * dy + dz * dz
+
+          next if dist_sq > PICKUP_RADIUS * PICKUP_RADIUS
+
+          defn = ITEMS[ent.classname]
+          next unless defn
+
+          picked = try_pickup(player_state, defn, ent)
+          if picked
+            @picked_up.add(ent.object_id)
+            events << { classname: ent.classname, type: defn[:type], entity: ent }
+          end
+        end
+
+        events
+      end
+
+      def picked_up?(entity)
+        @picked_up.include?(entity.object_id)
+      end
+
+      private
+
+      def try_pickup(ps, defn, ent)
+        case defn[:type]
+        when :health
+          # Health items: check spawnflags for mega/rotten
+          amount = defn[:amount]
+          mega = false
+          if (flags = ent["spawnflags"])
+            flags = flags.to_i
+            if flags & 1 != 0 # rotten (small health, 15hp, can exceed 100 but not by much)
+              amount = 15
+            elsif flags & 2 != 0 # mega health
+              amount = 100
+              mega = true
+            end
+          end
+          ps.add_health(amount, mega: mega)
+
+        when :armor
+          ps.add_armor(defn[:points], defn[:armor_type])
+
+        when :ammo
+          ps.add_ammo(defn[:ammo_type], defn[:amount])
+
+        when :weapon
+          ps.give_weapon(defn[:weapon],
+                         ammo_type: defn[:ammo_type],
+                         ammo_amount: defn[:ammo_amount])
+
+        when :powerup
+          # Powerups always pick up (full implementation would add timed effects)
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/quake/game/player_state.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Quake
+  module Game
+    # Tracks player game state: health, armor, ammo, weapons.
+    # Separate from physics (Physics::Player handles movement/collision).
+    class PlayerState
+      WEAPONS = %i[axe shotgun super_shotgun nailgun super_nailgun
+                   grenade_launcher rocket_launcher lightning_gun].freeze
+
+      WEAPON_MODELS = {
+        axe:              "progs/v_axe.mdl",
+        shotgun:          "progs/v_shot.mdl",
+        super_shotgun:    "progs/v_shot2.mdl",
+        nailgun:          "progs/v_nail.mdl",
+        super_nailgun:    "progs/v_nail2.mdl",
+        grenade_launcher: "progs/v_rock.mdl",
+        rocket_launcher:  "progs/v_rock2.mdl",
+        lightning_gun:    "progs/v_light.mdl"
+      }.freeze
+
+      # Ammo type per weapon
+      WEAPON_AMMO = {
+        axe:              nil,
+        shotgun:          :shells,
+        super_shotgun:    :shells,
+        nailgun:          :nails,
+        super_nailgun:    :nails,
+        grenade_launcher: :rockets,
+        rocket_launcher:  :rockets,
+        lightning_gun:    :cells
+      }.freeze
+
+      attr_accessor :health, :armor, :armor_type, :current_weapon
+      attr_reader :ammo, :weapons_owned
+
+      def initialize
+        @health = 100
+        @armor = 0
+        @armor_type = 0 # 0=none, 1=green(30%), 2=yellow(60%), 3=red(80%)
+        @current_weapon = :shotgun
+        @weapons_owned = Set.new([:axe, :shotgun])
+        @ammo = { shells: 25, nails: 0, rockets: 0, cells: 0 }
+      end
+
+      def current_ammo_type
+        WEAPON_AMMO[@current_weapon]
+      end
+
+      def current_ammo_count
+        type = current_ammo_type
+        type ? @ammo[type] : nil # nil = infinite (axe)
+      end
+
+      def current_weapon_model
+        WEAPON_MODELS[@current_weapon]
+      end
+
+      # Cycle to next owned weapon (mousewheel or number keys)
+      def next_weapon
+        idx = WEAPONS.index(@current_weapon) || 0
+        WEAPONS.size.times do
+          idx = (idx + 1) % WEAPONS.size
+          if @weapons_owned.include?(WEAPONS[idx])
+            @current_weapon = WEAPONS[idx]
+            return
+          end
+        end
+      end
+
+      def prev_weapon
+        idx = WEAPONS.index(@current_weapon) || 0
+        WEAPONS.size.times do
+          idx = (idx - 1) % WEAPONS.size
+          if @weapons_owned.include?(WEAPONS[idx])
+            @current_weapon = WEAPONS[idx]
+            return
+          end
+        end
+      end
+
+      # Select weapon by slot number (1-8)
+      def select_weapon(slot)
+        slot = slot.clamp(1, WEAPONS.size)
+        weapon = WEAPONS[slot - 1]
+        @current_weapon = weapon if @weapons_owned.include?(weapon)
+      end
+
+      def alive?
+        @health > 0
+      end
+
+      # Max ammo capacities (from Quake defs.qc)
+      MAX_HEALTH = 100
+      MAX_MEGA_HEALTH = 250
+      MAX_ARMOR = 200
+      MAX_SHELLS = 100
+      MAX_NAILS = 200
+      MAX_ROCKETS = 100
+      MAX_CELLS = 100
+
+      AMMO_CAPS = {
+        shells: MAX_SHELLS, nails: MAX_NAILS,
+        rockets: MAX_ROCKETS, cells: MAX_CELLS
+      }.freeze
+
+      # Add health, returns true if picked up
+      def add_health(amount, mega: false)
+        max = mega ? MAX_MEGA_HEALTH : MAX_HEALTH
+        return false if @health >= max
+
+        @health = [@health + amount, max].min
+        true
+      end
+
+      # Add armor, returns true if picked up
+      def add_armor(points, type)
+        # Only pick up if it's better than current armor
+        # type: 1=green(30%), 2=yellow(60%), 3=red(80%)
+        return false if type < @armor_type && @armor > 0
+
+        @armor = [points, MAX_ARMOR].min
+        @armor_type = type
+        true
+      end
+
+      # Add ammo, returns true if picked up
+      def add_ammo(type, amount)
+        cap = AMMO_CAPS[type]
+        return false unless cap
+        return false if @ammo[type] >= cap
+
+        @ammo[type] = [@ammo[type] + amount, cap].min
+        true
+      end
+
+      # Give weapon, returns true if picked up (always true for new weapons)
+      def give_weapon(weapon, ammo_type: nil, ammo_amount: 0)
+        had_weapon = @weapons_owned.include?(weapon)
+        @weapons_owned.add(weapon)
+
+        ammo_picked = false
+        if ammo_type && ammo_amount > 0
+          ammo_picked = add_ammo(ammo_type, ammo_amount)
+        end
+
+        if !had_weapon
+          @current_weapon = weapon
+          true
+        else
+          ammo_picked
+        end
+      end
+    end
+  end
+end

data/lib/quake/math/vec3.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Quake
+  module Math
+    Vec3 = Data.define(:x, :y, :z) do
+      def +(other) = Vec3.new(x + other.x, y + other.y, z + other.z)
+      def -(other) = Vec3.new(x - other.x, y - other.y, z - other.z)
+      def *(scalar) = Vec3.new(x * scalar, y * scalar, z * scalar)
+      def -@ = Vec3.new(-x, -y, -z)
+
+      def dot(other) = x * other.x + y * other.y + z * other.z
+
+      def cross(other)
+        Vec3.new(
+          y * other.z - z * other.y,
+          z * other.x - x * other.z,
+          x * other.y - y * other.x
+        )
+      end
+
+      def length = ::Math.sqrt(x * x + y * y + z * z)
+
+      def normalize
+        l = length
+        return self if l == 0.0
+        Vec3.new(x / l, y / l, z / l)
+      end
+
+      def to_a = [x, y, z]
+
+    end
+
+    Vec3::ORIGIN = Vec3.new(0.0, 0.0, 0.0).freeze
+  end
+end