doom 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70d72175c1f115b3363e188d7075047bc32cece4f3a3dd1feda17dc6f965b07f
-  data.tar.gz: 22eb9172267c578a6fbaa3dd526ec19e8d4587dba9a349080ad1626d3e04fd92
+  metadata.gz: cb48bcb7558c2e4f4ab959b16dbd857d2a1b6a3b9a9cc76c19a08ec91bdeb93e
+  data.tar.gz: 610f42cf954c60048a0c4030d96a8e8ceb2872aba90e90a141b2179329867c05
 SHA512:
-  metadata.gz: 6f5fdd281119ba4bec5a29b8f9cd32f8d0aa37d1674125c3095835ba24942e66e6356037c3e424f320578cac5b1ed94dc7738388d3ced296f8de22ce78e9e79e
-  data.tar.gz: 35de5ff2f711aa4084a54d811d26b919cf8f1b00be1d9b06597b7e7aac09eab3ee8ff597b1ece2ac451d175dad2faf3c16bc73f3dbf56b50867407509fc4f234
+  metadata.gz: 1ff09fd05c29a5c49b7d41285424d58b8b46dbf995e1f18106d571f18866762e8b20ecb47d472dc2cb2be8f2fc8cdea5eb0b3a2dedae55d5b1881bbcb796088b
+  data.tar.gz: 41d4fcb793f3b25fb57f2d50c02f5eee1a56cb40a40baf2a9f7e0831634f43aa4777abf80968130c44593055dbaea23bd3257e7d4b509a068af2c92e1e16698d

data/README.md

@@ -2,7 +2,7 @@
 
 A faithful ruby port of the DOOM (1993) rendering engine to Ruby.
 
-![DOOM Ruby Screenshot](https://raw.githubusercontent.com/khasinski/doom-rb/main/e1m1_spawn.png)
+![DOOM Ruby Screenshot](screenshot.png)
 
 ## Features
 

data/lib/doom/game/player_state.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Tracks player state for HUD display and weapon rendering
+    class PlayerState
+      # Weapons
+      WEAPON_FIST = 0
+      WEAPON_PISTOL = 1
+      WEAPON_SHOTGUN = 2
+      WEAPON_CHAINGUN = 3
+      WEAPON_ROCKET = 4
+      WEAPON_PLASMA = 5
+      WEAPON_BFG = 6
+      WEAPON_CHAINSAW = 7
+
+      # Weapon symbols for graphics lookup
+      WEAPON_NAMES = {
+        WEAPON_FIST => :fist,
+        WEAPON_PISTOL => :pistol,
+        WEAPON_SHOTGUN => :shotgun,
+        WEAPON_CHAINGUN => :chaingun,
+        WEAPON_ROCKET => :rocket,
+        WEAPON_PLASMA => :plasma,
+        WEAPON_BFG => :bfg,
+        WEAPON_CHAINSAW => :chainsaw
+      }.freeze
+
+      # Attack durations (in frames at 35fps)
+      ATTACK_DURATIONS = {
+        WEAPON_FIST => 12,
+        WEAPON_PISTOL => 8,
+        WEAPON_SHOTGUN => 20,
+        WEAPON_CHAINGUN => 4,
+        WEAPON_ROCKET => 16,
+        WEAPON_PLASMA => 6,
+        WEAPON_BFG => 40,
+        WEAPON_CHAINSAW => 4
+      }.freeze
+
+      attr_accessor :health, :armor, :max_health, :max_armor
+      attr_accessor :ammo_bullets, :ammo_shells, :ammo_rockets, :ammo_cells
+      attr_accessor :max_bullets, :max_shells, :max_rockets, :max_cells
+      attr_accessor :weapon, :has_weapons
+      attr_accessor :keys
+      attr_accessor :attacking, :attack_frame, :attack_tics
+      attr_accessor :bob_angle, :bob_amount
+      attr_accessor :is_moving
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @health = 100
+        @armor = 0
+        @max_health = 100
+        @max_armor = 200
+
+        # Ammo
+        @ammo_bullets = 50
+        @ammo_shells = 0
+        @ammo_rockets = 0
+        @ammo_cells = 0
+
+        @max_bullets = 200
+        @max_shells = 50
+        @max_rockets = 50
+        @max_cells = 300
+
+        # Start with fist and pistol
+        @weapon = WEAPON_PISTOL
+        @has_weapons = [true, true, false, false, false, false, false, false]
+
+        # No keys
+        @keys = {
+          blue_card: false,
+          yellow_card: false,
+          red_card: false,
+          blue_skull: false,
+          yellow_skull: false,
+          red_skull: false
+        }
+
+        # Attack state
+        @attacking = false
+        @attack_frame = 0
+        @attack_tics = 0
+
+        # Weapon bob
+        @bob_angle = 0.0
+        @bob_amount = 0.0
+        @is_moving = false
+      end
+
+      def weapon_name
+        WEAPON_NAMES[@weapon]
+      end
+
+      def current_ammo
+        case @weapon
+        when WEAPON_PISTOL, WEAPON_CHAINGUN
+          @ammo_bullets
+        when WEAPON_SHOTGUN
+          @ammo_shells
+        when WEAPON_ROCKET
+          @ammo_rockets
+        when WEAPON_PLASMA, WEAPON_BFG
+          @ammo_cells
+        else
+          nil # Fist/chainsaw don't use ammo
+        end
+      end
+
+      def max_ammo_for_weapon
+        case @weapon
+        when WEAPON_PISTOL, WEAPON_CHAINGUN
+          @max_bullets
+        when WEAPON_SHOTGUN
+          @max_shells
+        when WEAPON_ROCKET
+          @max_rockets
+        when WEAPON_PLASMA, WEAPON_BFG
+          @max_cells
+        else
+          nil
+        end
+      end
+
+      def can_attack?
+        return true if @weapon == WEAPON_FIST || @weapon == WEAPON_CHAINSAW
+
+        ammo = current_ammo
+        ammo && ammo > 0
+      end
+
+      def start_attack
+        return unless can_attack?
+        return if @attacking
+
+        @attacking = true
+        @attack_frame = 0
+        @attack_tics = 0
+
+        # Consume ammo
+        case @weapon
+        when WEAPON_PISTOL
+          @ammo_bullets -= 1 if @ammo_bullets > 0
+        when WEAPON_SHOTGUN
+          @ammo_shells -= 1 if @ammo_shells > 0
+        when WEAPON_CHAINGUN
+          @ammo_bullets -= 1 if @ammo_bullets > 0
+        when WEAPON_ROCKET
+          @ammo_rockets -= 1 if @ammo_rockets > 0
+        when WEAPON_PLASMA
+          @ammo_cells -= 1 if @ammo_cells > 0
+        when WEAPON_BFG
+          @ammo_cells -= 40 if @ammo_cells >= 40
+        end
+      end
+
+      def update_attack
+        return unless @attacking
+
+        @attack_tics += 1
+
+        # Calculate which frame we're on based on tics
+        duration = ATTACK_DURATIONS[@weapon] || 8
+        frame_count = @weapon == WEAPON_FIST ? 3 : 4
+
+        tics_per_frame = duration / frame_count
+        @attack_frame = (@attack_tics / tics_per_frame).to_i
+
+        # Attack finished?
+        if @attack_tics >= duration
+          @attacking = false
+          @attack_frame = 0
+          @attack_tics = 0
+        end
+      end
+
+      def update_bob(delta_time)
+        if @is_moving
+          # Increase bob while moving
+          @bob_angle += delta_time * 10.0
+          @bob_amount = [@bob_amount + delta_time * 16.0, 6.0].min
+        else
+          # Decay bob when stopped
+          @bob_amount = [@bob_amount - delta_time * 12.0, 0.0].max
+        end
+      end
+
+      def weapon_bob_x
+        Math.cos(@bob_angle) * @bob_amount
+      end
+
+      def weapon_bob_y
+        Math.sin(@bob_angle * 2) * @bob_amount * 0.5
+      end
+
+      def health_level
+        # 0 = dying, 4 = full health
+        case @health
+        when 80..200 then 4
+        when 60..79 then 3
+        when 40..59 then 2
+        when 20..39 then 1
+        else 0
+        end
+      end
+
+      def switch_weapon(weapon_num)
+        return unless weapon_num >= 0 && weapon_num < 8
+        return unless @has_weapons[weapon_num]
+        return if @attacking
+
+        @weapon = weapon_num
+      end
+    end
+  end
+end

data/lib/doom/game/sector_actions.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Manages animated sector actions (doors, lifts, etc.)
+    class SectorActions
+      # Door states
+      DOOR_CLOSED = 0
+      DOOR_OPENING = 1
+      DOOR_OPEN = 2
+      DOOR_CLOSING = 3
+
+      # Door speeds (units per tic, 35 tics/sec)
+      DOOR_SPEED = 2
+      DOOR_WAIT = 150  # Tics to wait when open (~4 seconds)
+      PLAYER_HEIGHT = 56  # Player height for door collision
+
+      def initialize(map)
+        @map = map
+        @active_doors = {}  # sector_index => door_state
+        @player_x = 0
+        @player_y = 0
+      end
+
+      def update_player_position(x, y)
+        @player_x = x
+        @player_y = y
+      end
+
+      def update
+        update_doors
+      end
+
+      # Try to use a linedef (called when player presses use key)
+      def use_linedef(linedef, linedef_idx)
+        return false if linedef.special == 0
+
+        case linedef.special
+        when 1  # DR Door Open Wait Close
+          activate_door(linedef)
+          true
+        when 31  # D1 Door Open Stay
+          activate_door(linedef, stay_open: true)
+          true
+        when 26  # DR Blue Door
+          activate_door(linedef, key: :blue_card)
+          true
+        when 27  # DR Yellow Door
+          activate_door(linedef, key: :yellow_card)
+          true
+        when 28  # DR Red Door
+          activate_door(linedef, key: :red_card)
+          true
+        else
+          false
+        end
+      end
+
+      private
+
+      def activate_door(linedef, stay_open: false, key: nil)
+        # Find the sector on the back side of the linedef
+        return unless linedef.two_sided?
+
+        back_sidedef_idx = linedef.sidedef_left
+        return if back_sidedef_idx == 0xFFFF || back_sidedef_idx < 0
+
+        back_sidedef = @map.sidedefs[back_sidedef_idx]
+        sector_idx = back_sidedef.sector
+        sector = @map.sectors[sector_idx]
+        return unless sector
+
+        # Check if door is already active
+        if @active_doors[sector_idx]
+          door = @active_doors[sector_idx]
+          # If closing, reverse direction
+          if door[:state] == DOOR_CLOSING
+            door[:state] = DOOR_OPENING
+          end
+          return
+        end
+
+        # Calculate target height (find lowest adjacent ceiling)
+        target_height = find_lowest_ceiling_around(sector_idx) - 4
+
+        # Start the door
+        @active_doors[sector_idx] = {
+          sector: sector,
+          state: DOOR_OPENING,
+          target_height: target_height,
+          original_height: sector.ceiling_height,
+          wait_tics: 0,
+          stay_open: stay_open
+        }
+      end
+
+      def update_doors
+        @active_doors.each do |sector_idx, door|
+          case door[:state]
+          when DOOR_OPENING
+            door[:sector].ceiling_height += DOOR_SPEED
+            if door[:sector].ceiling_height >= door[:target_height]
+              door[:sector].ceiling_height = door[:target_height]
+              if door[:stay_open]
+                @active_doors.delete(sector_idx)
+              else
+                door[:state] = DOOR_OPEN
+                door[:wait_tics] = DOOR_WAIT
+              end
+            end
+
+          when DOOR_OPEN
+            door[:wait_tics] -= 1
+            if door[:wait_tics] <= 0
+              door[:state] = DOOR_CLOSING
+            end
+
+          when DOOR_CLOSING
+            # Check if player is in the door sector
+            player_sector = @map.sector_at(@player_x, @player_y)
+            if player_sector == door[:sector]
+              # Player is in door - reopen it
+              door[:state] = DOOR_OPENING
+              next
+            end
+
+            door[:sector].ceiling_height -= DOOR_SPEED
+            if door[:sector].ceiling_height <= door[:original_height]
+              door[:sector].ceiling_height = door[:original_height]
+              @active_doors.delete(sector_idx)
+            end
+          end
+        end
+      end
+
+      def find_lowest_ceiling_around(sector_idx)
+        lowest = Float::INFINITY
+
+        @map.linedefs.each do |linedef|
+          next unless linedef.two_sided?
+
+          # Check if this linedef touches our sector
+          right_sidedef = @map.sidedefs[linedef.sidedef_right]
+          left_sidedef = @map.sidedefs[linedef.sidedef_left] if linedef.sidedef_left != 0xFFFF
+
+          adjacent_sector = nil
+          if right_sidedef&.sector == sector_idx && left_sidedef
+            adjacent_sector = @map.sectors[left_sidedef.sector]
+          elsif left_sidedef&.sector == sector_idx
+            adjacent_sector = @map.sectors[right_sidedef.sector]
+          end
+
+          if adjacent_sector
+            lowest = [lowest, adjacent_sector.ceiling_height].min
+          end
+        end
+
+        lowest == Float::INFINITY ? 128 : lowest
+      end
+    end
+  end
+end

data/lib/doom/platform/gosu_window.rb

@@ -13,24 +13,62 @@ module Doom
       MOUSE_SENSITIVITY = 0.15  # Mouse look sensitivity
       PLAYER_RADIUS = 16.0   # Collision radius
 
-      def initialize(renderer, palette, map)
+      USE_DISTANCE = 64.0  # Max distance to use a linedef
+
+      def initialize(renderer, palette, map, player_state = nil, status_bar = nil, weapon_renderer = nil, sector_actions = nil)
         super(Render::SCREEN_WIDTH * SCALE, Render::SCREEN_HEIGHT * SCALE, false)
         self.caption = 'Doom Ruby'
 
         @renderer = renderer
         @palette = palette
         @map = map
+        @player_state = player_state
+        @status_bar = status_bar
+        @weapon_renderer = weapon_renderer
+        @sector_actions = sector_actions
         @screen_image = nil
         @mouse_captured = false
         @last_mouse_x = nil
+        @last_update_time = Time.now
+        @use_pressed = false
 
         # Pre-build palette lookup for speed
         @palette_rgba = palette.colors.map { |r, g, b| [r, g, b, 255].pack('CCCC') }
       end
 
       def update
+        # Calculate delta time for smooth animations
+        now = Time.now
+        delta_time = now - @last_update_time
+        @last_update_time = now
+
         handle_input
+
+        # Update player state
+        if @player_state
+          @player_state.update_attack
+          @player_state.update_bob(delta_time)
+        end
+
+        # Update HUD animations
+        @status_bar&.update
+
+        # Update sector actions (doors, lifts, etc.)
+        if @sector_actions
+          @sector_actions.update_player_position(@renderer.player_x, @renderer.player_y)
+          @sector_actions.update
+        end
+
+        # Render the 3D world
         @renderer.render_frame
+
+        # Render HUD on top
+        if @weapon_renderer
+          @weapon_renderer.render(@renderer.framebuffer)
+        end
+        if @status_bar
+          @status_bar.render(@renderer.framebuffer)
+        end
       end
 
       def handle_input
@@ -68,10 +106,149 @@ module Doom
           move_y += @renderer.cos_angle * MOVE_SPEED
         end
 
+        # Track if player is moving (for weapon bob)
+        is_moving = move_x != 0.0 || move_y != 0.0
+        @player_state.is_moving = is_moving if @player_state
+
         # Apply movement with collision detection
-        if move_x != 0.0 || move_y != 0.0
+        if is_moving
           try_move(move_x, move_y)
         end
+
+        # Handle firing
+        if @player_state && @mouse_captured && Gosu.button_down?(Gosu::MS_LEFT)
+          @player_state.start_attack
+        end
+
+        # Handle weapon switching with number keys
+        handle_weapon_switch if @player_state
+
+        # Handle use key (spacebar or E)
+        handle_use_key if @sector_actions
+      end
+
+      def handle_use_key
+        use_down = Gosu.button_down?(Gosu::KB_SPACE) || Gosu.button_down?(Gosu::KB_E)
+
+        if use_down && !@use_pressed
+          @use_pressed = true
+          try_use_linedef
+        elsif !use_down
+          @use_pressed = false
+        end
+      end
+
+      def try_use_linedef
+        # Cast a ray forward to find a usable linedef
+        player_x = @renderer.player_x
+        player_y = @renderer.player_y
+        cos_angle = @renderer.cos_angle
+        sin_angle = @renderer.sin_angle
+
+        # Check point in front of player
+        use_x = player_x + cos_angle * USE_DISTANCE
+        use_y = player_y + sin_angle * USE_DISTANCE
+
+        # Find the closest linedef the player is facing
+        best_linedef = nil
+        best_idx = nil
+        best_dist = Float::INFINITY
+
+        @map.linedefs.each_with_index do |linedef, idx|
+          next if linedef.special == 0  # Skip non-special linedefs
+
+          v1 = @map.vertices[linedef.v1]
+          v2 = @map.vertices[linedef.v2]
+
+          # Check if player is close enough to the linedef
+          dist = point_to_line_distance(player_x, player_y, v1.x, v1.y, v2.x, v2.y)
+          next if dist > USE_DISTANCE
+          next if dist >= best_dist
+
+          # Check if player is facing the linedef (on the front side)
+          next unless facing_linedef?(player_x, player_y, cos_angle, sin_angle, v1, v2)
+
+          best_linedef = linedef
+          best_idx = idx
+          best_dist = dist
+        end
+
+        if best_linedef
+          @sector_actions.use_linedef(best_linedef, best_idx)
+        end
+      end
+
+      def point_to_line_distance(px, py, x1, y1, x2, y2)
+        # Vector from line start to point
+        dx = px - x1
+        dy = py - y1
+
+        # Line direction vector
+        line_dx = x2 - x1
+        line_dy = y2 - y1
+        line_len_sq = line_dx * line_dx + line_dy * line_dy
+
+        return Math.sqrt(dx * dx + dy * dy) if line_len_sq == 0
+
+        # Project point onto line, clamped to segment
+        t = ((dx * line_dx) + (dy * line_dy)) / line_len_sq
+        t = [[t, 0.0].max, 1.0].min
+
+        # Closest point on line segment
+        closest_x = x1 + t * line_dx
+        closest_y = y1 + t * line_dy
+
+        # Distance from point to closest point on segment
+        dist_x = px - closest_x
+        dist_y = py - closest_y
+        Math.sqrt(dist_x * dist_x + dist_y * dist_y)
+      end
+
+      def facing_linedef?(px, py, cos_angle, sin_angle, v1, v2)
+        # Calculate linedef normal (perpendicular to line, pointing to front side)
+        line_dx = v2.x - v1.x
+        line_dy = v2.y - v1.y
+
+        # Normal points to the right of the line direction
+        normal_x = -line_dy
+        normal_y = line_dx
+
+        # Normalize
+        len = Math.sqrt(normal_x * normal_x + normal_y * normal_y)
+        return false if len == 0
+
+        normal_x /= len
+        normal_y /= len
+
+        # Check if player is on the front side (normal side) of the line
+        to_player_x = px - v1.x
+        to_player_y = py - v1.y
+        dot_player = to_player_x * normal_x + to_player_y * normal_y
+
+        # Player must be on front side
+        return false if dot_player < 0
+
+        # Check if player is facing toward the line
+        dot_facing = cos_angle * (-normal_x) + sin_angle * (-normal_y)
+        dot_facing > 0.5  # Must be roughly facing the line
+      end
+
+      def handle_weapon_switch
+        if Gosu.button_down?(Gosu::KB_1)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_FIST)
+        elsif Gosu.button_down?(Gosu::KB_2)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_PISTOL)
+        elsif Gosu.button_down?(Gosu::KB_3)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_SHOTGUN)
+        elsif Gosu.button_down?(Gosu::KB_4)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_CHAINGUN)
+        elsif Gosu.button_down?(Gosu::KB_5)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_ROCKET)
+        elsif Gosu.button_down?(Gosu::KB_6)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_PLASMA)
+        elsif Gosu.button_down?(Gosu::KB_7)
+          @player_state.switch_weapon(Game::PlayerState::WEAPON_BFG)
+        end
       end
 
       def try_move(dx, dy)