quake-rb 0.1.0

data/lib/quake/entity.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Quake
+  # Represents a parsed entity from the BSP entities lump.
+  # All Quake entities (players, monsters, items, triggers, brush models)
+  # are defined as key-value property bags in the BSP entity string.
+  class Entity
+    attr_accessor :properties, :position, :angle, :angles, :classname,
+                  :model_index, :think_time, :state, :move_dir,
+                  :target, :targetname, :speed, :wait, :lip, :health,
+                  :sounds, :message
+
+    def initialize(properties = {})
+      @properties = properties
+      @classname = properties["classname"] || ""
+
+      # Parse common fields
+      @position = parse_vec3(properties["origin"]) || Math::Vec3::ORIGIN
+      @angle = (properties["angle"] || "0").to_f
+      @angles = parse_vec3(properties["angles"]) || Math::Vec3::ORIGIN
+
+      # Brush model reference: "*1", "*2", etc.
+      @model_index = nil
+      if (model_str = properties["model"])
+        @model_index = model_str[1..].to_i if model_str.start_with?("*")
+      end
+
+      # Targeting
+      @target = properties["target"]
+      @targetname = properties["targetname"]
+
+      # Movement/behavior
+      @speed = (properties["speed"] || default_speed).to_f
+      @wait = (properties["wait"] || "3").to_f
+      @lip = (properties["lip"] || "8").to_f
+      @health = (properties["health"] || "0").to_f
+      @sounds = (properties["sounds"] || "0").to_i
+      @message = properties["message"]
+
+      # Runtime state
+      @state = :idle
+      @think_time = 0.0
+      @move_dir = Math::Vec3::ORIGIN
+    end
+
+    def [](key) = @properties[key]
+
+    def brush_entity? = !@model_index.nil?
+
+    # Direction vector from the "angle" field (Quake convention)
+    def forward_vector
+      case @angle.to_i
+      when -1 # UP
+        Math::Vec3.new(0.0, 0.0, 1.0)
+      when -2 # DOWN
+        Math::Vec3.new(0.0, 0.0, -1.0)
+      else
+        rad = @angle * ::Math::PI / 180.0
+        Math::Vec3.new(::Math.cos(rad), ::Math.sin(rad), 0.0)
+      end
+    end
+
+    private
+
+    def parse_vec3(str)
+      return nil unless str
+      parts = str.split.map(&:to_f)
+      return nil unless parts.size == 3
+      Math::Vec3.new(parts[0], parts[1], parts[2])
+    end
+
+    def default_speed
+      case @classname
+      when "func_door" then "100"
+      when "func_plat" then "150"
+      when "func_button" then "40"
+      when "func_train" then "100"
+      else "100"
+      end
+    end
+  end
+
+  # Parses the BSP entity string into an array of Entity objects.
+  module EntityParser
+    def self.parse(entity_string)
+      entities = []
+      current = nil
+
+      entity_string.each_line do |line|
+        line = line.strip
+        case line
+        when "{"
+          current = {}
+        when "}"
+          entities << Entity.new(current) if current
+          current = nil
+        else
+          if current && line =~ /\A"([^"]+)"\s+"([^"]*)"\z/
+            current[$1] = $2
+          end
+        end
+      end
+
+      entities
+    end
+
+    # Build a lookup table: targetname -> [Entity]
+    def self.build_target_map(entities)
+      map = Hash.new { |h, k| h[k] = [] }
+      entities.each do |ent|
+        map[ent.targetname] << ent if ent.targetname
+      end
+      map
+    end
+  end
+end

data/lib/quake/game/brush_entities.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+module Quake
+  module Game
+    # Manages brush entity behavior: doors, platforms, buttons, triggers.
+    # Each entity has a state machine and moves between positions.
+    class BrushEntities
+      # Entity states
+      STATE_IDLE     = :idle
+      STATE_OPENING  = :opening
+      STATE_OPEN     = :open
+      STATE_CLOSING  = :closing
+      STATE_CLOSED   = :closed
+
+      def initialize(entities, level, target_map)
+        @entities = entities
+        @level = level
+        @target_map = target_map
+        @brush_entities = entities.select(&:brush_entity?)
+
+        # Initialize movement data for each brush entity
+        @brush_entities.each { |ent| init_brush_entity(ent) }
+
+        puts "Initialized #{@brush_entities.size} brush entities"
+      end
+
+      # Update all brush entities. Returns entities that need rendering.
+      def update(dt, player_pos)
+        # Save previous positions for platform-riding
+        @brush_entities.each do |ent|
+          ent.instance_variable_set(:@prev_pos, ent.position)
+        end
+
+        @brush_entities.each do |ent|
+          case ent.classname
+          when "func_door"
+            update_door(ent, dt, player_pos)
+          when "func_plat"
+            update_platform(ent, dt, player_pos)
+          when "func_button"
+            update_button(ent, dt, player_pos)
+          when "func_train"
+            update_train(ent, dt)
+          end
+        end
+
+        @brush_entities
+      end
+
+      # If the player is standing on a moving platform, return a new
+      # position snapped to the platform's top surface (so on_ground stays
+      # true and the player rides smoothly). Returns nil if not on a
+      # moving platform.
+      def snap_to_platform(player_pos)
+        @brush_entities.each do |ent|
+          next unless ent.classname == "func_plat"
+          model = @level.models[ent.model_index]
+          next unless model
+
+          prev = ent.instance_variable_get(:@prev_pos)
+          next unless prev
+
+          ent_delta_z = ent.position.z - prev.z
+
+          # Use the OLD platform position for the on_top check, since
+          # player_pos hasn't been updated for this frame's movement yet.
+          old_top_z = prev.z + model.maxs.z
+          next unless player_pos.z >= old_top_z - 8 && player_pos.z <= old_top_z + 24
+          next unless player_pos.x >= ent.position.x + model.mins.x &&
+                      player_pos.x <= ent.position.x + model.maxs.x &&
+                      player_pos.y >= ent.position.y + model.mins.y &&
+                      player_pos.y <= ent.position.y + model.maxs.y
+
+          # Snap to the new platform top surface, slightly above so the
+          # trace-down ground check can detect it cleanly (avoid epsilon
+          # edge case at exact plane boundary).
+          new_top_z = ent.position.z + model.maxs.z + 0.5
+          return Math::Vec3.new(player_pos.x, player_pos.y, new_top_z)
+        end
+        nil
+      end
+
+      # Backward-compatible delta-only method
+      def platform_motion_for(player_pos)
+        snapped = snap_to_platform(player_pos)
+        return Math::Vec3::ORIGIN unless snapped
+        snapped - player_pos
+      end
+
+      # Check if player touches any trigger entities
+      def check_triggers(player_pos, player_radius: 16.0)
+        @entities.each do |ent|
+          next unless ent.classname.start_with?("trigger_")
+          next unless ent.brush_entity?
+
+          model = @level.models[ent.model_index]
+          next unless model
+
+          # Simple AABB check against player
+          mins = model.mins
+          maxs = model.maxs
+          origin = ent.position
+
+          if player_pos.x >= origin.x + mins.x - player_radius &&
+             player_pos.x <= origin.x + maxs.x + player_radius &&
+             player_pos.y >= origin.y + mins.y - player_radius &&
+             player_pos.y <= origin.y + maxs.y + player_radius &&
+             player_pos.z >= origin.z + mins.z - player_radius &&
+             player_pos.z <= origin.z + maxs.z + player_radius
+            fire_targets(ent.target) if ent.target
+            yield ent if block_given?
+          end
+        end
+      end
+
+      private
+
+      def init_brush_entity(ent)
+        return unless ent.model_index
+
+        model = @level.models[ent.model_index]
+        return unless model
+
+        # Store the closed (original) position
+        ent.instance_variable_set(:@closed_pos, ent.position)
+        ent.instance_variable_set(:@open_pos, ent.position)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+
+        case ent.classname
+        when "func_door"
+          setup_door(ent, model)
+        when "func_plat"
+          setup_platform(ent, model)
+        when "func_button"
+          setup_button(ent, model)
+        end
+      end
+
+      DOOR_START_OPEN = 1
+
+      def setup_door(ent, model)
+        # Calculate move direction from angle
+        dir = ent.forward_vector
+        size = model.maxs - model.mins
+        move_dist = dir.x.abs * size.x + dir.y.abs * size.y + dir.z.abs * size.z
+        move_dist -= ent.lip
+
+        pos1 = ent.position                    # authored = "closed"
+        pos2 = ent.position + dir * move_dist  # offset = "open"
+
+        # DOOR_START_OPEN: door is authored at the open position. Swap so
+        # that pos1 = closed (down/hidden) and pos2 = open (visible).
+        spawnflags = (ent["spawnflags"] || "0").to_i
+        if (spawnflags & DOOR_START_OPEN) != 0
+          ent.position = pos2
+          ent.instance_variable_set(:@closed_pos, pos2)
+          ent.instance_variable_set(:@open_pos, pos1)
+        else
+          ent.instance_variable_set(:@closed_pos, pos1)
+          ent.instance_variable_set(:@open_pos, pos2)
+        end
+      end
+
+      def setup_platform(ent, model)
+        # In Quake, the map origin is the TOP position.
+        # See plats.qc func_plat:
+        #   pos1 = top (authored origin)
+        #   pos2 = top - (height - 8)  // 8-unit lip stays visible
+        # Platforms WITHOUT a targetname start at the bottom and rise when
+        # the player steps on them. Platforms WITH a targetname start at
+        # the top and go down when triggered.
+        size = model.maxs - model.mins
+        height = size.z - 8.0
+
+        top_pos = ent.position
+        bottom_pos = Math::Vec3.new(top_pos.x, top_pos.y, top_pos.z - height)
+
+        if ent.targetname
+          # Targeted: start at top, button press lowers it
+          ent.instance_variable_set(:@closed_pos, top_pos)
+          ent.instance_variable_set(:@open_pos, bottom_pos)
+        else
+          # Normal: start at bottom, player steps on to ride up
+          ent.position = bottom_pos
+          ent.instance_variable_set(:@closed_pos, bottom_pos)
+          ent.instance_variable_set(:@open_pos, top_pos)
+        end
+      end
+
+      def setup_button(ent, model)
+        dir = ent.forward_vector
+        size = model.maxs - model.mins
+        move_dist = dir.x.abs * size.x + dir.y.abs * size.y + dir.z.abs * size.z
+        move_dist -= ent.lip
+
+        ent.instance_variable_set(:@open_pos, ent.position + dir * move_dist)
+      end
+
+      def update_door(ent, dt, player_pos)
+        case ent.state
+        when STATE_IDLE, STATE_CLOSED
+          # Check if player is near or if targeted
+          if near_entity?(ent, player_pos, 128.0) || ent.instance_variable_get(:@triggered)
+            ent.state = STATE_OPENING
+            ent.instance_variable_set(:@triggered, false)
+          end
+        when STATE_OPENING
+          move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+          if ent.instance_variable_get(:@move_fraction) >= 1.0
+            ent.state = STATE_OPEN
+            ent.think_time = ent.wait
+          end
+        when STATE_OPEN
+          ent.think_time -= dt
+          if ent.think_time <= 0 && ent.wait >= 0
+            ent.state = STATE_CLOSING
+          end
+        when STATE_CLOSING
+          move_toward(ent, ent.instance_variable_get(:@closed_pos), dt)
+          if ent.instance_variable_get(:@move_fraction) >= 1.0
+            ent.state = STATE_CLOSED
+          end
+        end
+      end
+
+      def update_platform(ent, dt, player_pos)
+        case ent.state
+        when STATE_IDLE
+          model = @level.models[ent.model_index]
+          triggered = ent.instance_variable_get(:@triggered)
+          on_top = model && on_top_of?(ent, model, player_pos)
+
+          # Targeted platforms only react to button triggers.
+          # Normal platforms also activate when player steps on them.
+          should_move = if ent.targetname
+                          triggered
+                        else
+                          triggered || on_top
+                        end
+
+          if should_move
+            ent.state = STATE_OPENING
+            ent.instance_variable_set(:@triggered, false)
+          end
+        when STATE_OPENING
+          move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+          if ent.instance_variable_get(:@move_fraction) >= 1.0
+            ent.state = STATE_OPEN
+            ent.think_time = ent.wait
+          end
+        when STATE_OPEN
+          ent.think_time -= dt
+          if ent.think_time <= 0
+            ent.state = STATE_CLOSING
+          end
+        when STATE_CLOSING
+          move_toward(ent, ent.instance_variable_get(:@closed_pos), dt)
+          if ent.instance_variable_get(:@move_fraction) >= 1.0
+            ent.state = STATE_IDLE
+          end
+        end
+      end
+
+      def update_button(ent, dt, player_pos)
+        case ent.state
+        when STATE_IDLE, STATE_CLOSED
+          if near_entity?(ent, player_pos, 64.0) || ent.instance_variable_get(:@triggered)
+            ent.state = STATE_OPENING
+            ent.instance_variable_set(:@triggered, false)
+            fire_targets(ent.target)
+          end
+        when STATE_OPENING
+          move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+          if ent.instance_variable_get(:@move_fraction) >= 1.0
+            ent.state = STATE_OPEN
+            ent.think_time = ent.wait
+          end
+        when STATE_OPEN
+          ent.think_time -= dt
+          if ent.think_time <= 0
+            ent.state = STATE_CLOSING
+          end
+        when STATE_CLOSING
+          move_toward(ent, ent.instance_variable_get(:@closed_pos), dt)
+          if ent.instance_variable_get(:@move_fraction) >= 1.0
+            ent.state = STATE_CLOSED
+          end
+        end
+      end
+
+      def update_train(ent, dt)
+        # Trains follow path_corner entities - basic movement only
+        return unless ent.state == STATE_OPENING
+
+        move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+        if ent.instance_variable_get(:@move_fraction) >= 1.0
+          ent.state = STATE_IDLE
+        end
+      end
+
+      def move_toward(ent, target, dt)
+        current = ent.position
+        diff = target - current
+        dist = diff.length
+
+        # Already at target
+        if dist < 0.1
+          ent.position = target
+          ent.instance_variable_set(:@move_fraction, 1.0)
+          return
+        end
+
+        move_amount = ent.speed * dt
+        if move_amount >= dist
+          # Snap to target
+          ent.position = target
+          ent.instance_variable_set(:@move_fraction, 1.0)
+        else
+          # Partial movement, not done yet
+          ent.position = current + diff * (move_amount / dist)
+          ent.instance_variable_set(:@move_fraction, 0.0)
+        end
+      end
+
+      def near_entity?(ent, player_pos, radius)
+        model = @level.models[ent.model_index]
+        return false unless model
+
+        # Check distance to model center
+        center = ent.position + (model.mins + model.maxs) * 0.5
+        dx = player_pos.x - center.x
+        dy = player_pos.y - center.y
+        dz = player_pos.z - center.z
+        (dx * dx + dy * dy + dz * dz) < radius * radius
+      end
+
+      def on_top_of?(ent, model, player_pos)
+        # Check if player is standing on top of the platform.
+        # Tolerance: -8 to +24 units above the surface (player feet within
+        # one stair step of the platform top).
+        top_z = ent.position.z + model.maxs.z
+        player_pos.z >= top_z - 8 && player_pos.z <= top_z + 24 &&
+          player_pos.x >= ent.position.x + model.mins.x &&
+          player_pos.x <= ent.position.x + model.maxs.x &&
+          player_pos.y >= ent.position.y + model.mins.y &&
+          player_pos.y <= ent.position.y + model.maxs.y
+      end
+
+      def fire_targets(target_name)
+        return unless target_name
+
+        targets = @target_map[target_name]
+        targets.each do |ent|
+          ent.instance_variable_set(:@triggered, true)
+          # Reset movement fraction for re-triggering
+          ent.instance_variable_set(:@move_fraction, 0.0)
+        end
+      end
+    end
+  end
+end