doom 0.6.0 → 0.11.0

data/lib/doom/platform/sdl.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Doom
+  module Platform
+    # SDL2 keyboard grab via Gosu's bundled SDL -- prevents OS key interception.
+    module SDLKeyboardGrab
+      def self.setup
+        require 'fiddle'
+        gosu_spec = Gem.loaded_specs['gosu']
+        lib_ext = RbConfig::CONFIG['DLEXT'] || 'so'
+        bundle = File.join(gosu_spec.full_gem_path, 'lib', "gosu.#{lib_ext}")
+        @lib = Fiddle.dlopen(bundle)
+        @shared_window = Fiddle::Function.new(
+          @lib['_ZN4Gosu13shared_windowEv'], [], Fiddle::TYPE_VOIDP
+        )
+        @set_kb_grab = Fiddle::Function.new(
+          @lib['SDL_SetWindowKeyboardGrab'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_VOID
+        )
+        @ready = true
+      rescue StandardError, LoadError => e
+        warn "SDLKeyboardGrab.setup failed: #{e.class}: #{e.message}"
+        @ready = false
+      end
+
+      def self.grab!
+        return unless @ready
+
+        @set_kb_grab.call(@shared_window.call, 1)
+      end
+
+      def self.release!
+        return unless @ready
+
+        @set_kb_grab.call(@shared_window.call, 0)
+      end
+    end
+
+    # Ask SDL for the display's refresh rate.
+    #
+    # Timing our own buffer swaps cannot answer this: when the engine renders
+    # slower than the display refreshes -- which is the normal case here --
+    # the swap cadence measures our render time, not the monitor. SDL knows
+    # the real number, and Gosu bundles SDL, so we read it directly the same
+    # way SDLKeyboardGrab reaches for SDL_SetWindowKeyboardGrab.
+    module SDLDisplayMode
+      # SDL_DisplayMode { Uint32 format; int w; int h; int refresh_rate; void *driverdata; }
+      REFRESH_RATE_OFFSET = 12
+      STRUCT_SIZE = 32
+
+      def self.refresh_rate
+        require 'fiddle'
+        gosu_spec = Gem.loaded_specs['gosu']
+        lib_ext = RbConfig::CONFIG['DLEXT'] || 'so'
+        lib = Fiddle.dlopen(File.join(gosu_spec.full_gem_path, 'lib', "gosu.#{lib_ext}"))
+
+        get_mode = Fiddle::Function.new(
+          lib['SDL_GetCurrentDisplayMode'],
+          [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT
+        )
+
+        buf = Fiddle::Pointer.malloc(STRUCT_SIZE)
+        return nil unless get_mode.call(0, buf).zero?
+
+        hz = buf[REFRESH_RATE_OFFSET, 4].unpack1('l')
+        # SDL reports 0 when the rate is unspecified (some virtual displays).
+        hz.positive? ? hz : nil
+      rescue StandardError, LoadError => e
+        warn "SDLDisplayMode.refresh_rate failed: #{e.class}: #{e.message}"
+        nil
+      end
+    end
+  end
+end

data/lib/doom/platform/window_logic.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Doom
+  module Platform
+    # Pure helpers extracted from GosuWindow so they can be tested without a
+    # display. GosuWindow subclasses Gosu::Window, which cannot be loaded (let
+    # alone instantiated) under RSpec, so any decision logic worth testing lives
+    # here as plain functions and GosuWindow just delegates to them.
+    module WindowLogic
+      # DOOM thing flags: bit 0 = skill 1-2 (baby/easy), bit 1 = skill 3
+      # (medium), bit 2 = skill 4-5 (hard/nightmare), bit 4 = multiplayer-only.
+      SKILL_FLAG_EASY = 0x0001
+      SKILL_FLAG_MEDIUM = 0x0002
+      SKILL_FLAG_HARD = 0x0004
+      MULTIPLAYER_ONLY_FLAG = 0x0010
+
+      # The flag bit a thing must carry to appear at the given skill.
+      # skill uses Game::Menu::SKILL_* values (0-4).
+      def self.skill_flag_bit(skill)
+        case skill
+        when Game::Menu::SKILL_BABY, Game::Menu::SKILL_EASY then SKILL_FLAG_EASY
+        when Game::Menu::SKILL_MEDIUM then SKILL_FLAG_MEDIUM
+        when Game::Menu::SKILL_HARD, Game::Menu::SKILL_NIGHTMARE then SKILL_FLAG_HARD
+        else SKILL_FLAG_EASY | SKILL_FLAG_MEDIUM | SKILL_FLAG_HARD
+        end
+      end
+
+      # Which things this skill hides. A thing is hidden if it is
+      # multiplayer-only, or if it does not carry the flag bit for this skill.
+      # Returns { index => true } (matching the world's skill_hidden shape).
+      def self.skill_hidden(skill, things)
+        flag_bit = skill_flag_bit(skill)
+        hidden = {}
+        things.each_with_index do |thing, idx|
+          hidden[idx] = true if (thing.flags & MULTIPLAYER_ONLY_FLAG) != 0 || (thing.flags & flag_bit) == 0
+        end
+        hidden
+      end
+
+      # Frame-presentation cadence. Rendering runs every loop iteration, but we
+      # only blit/swap once a refresh interval (minus slack, so we aim slightly
+      # before vblank) has elapsed since the last present.
+      def self.present_due?(now_ms, last_present_ms, interval_ms, slack)
+        (now_ms - last_present_ms) >= (interval_ms * slack)
+      end
+
+      # Net status overlay lines. A lockstep stall under the threshold is normal
+      # -- every peer briefly waits for the next command between tics -- so it
+      # produces nothing; only a stall past the threshold, a session that has
+      # not started yet, or a desync is worth interrupting the player for.
+      def self.net_status_lines(started:, host:, waiting:, stalled_seconds:,
+                                stall_threshold:, desync: nil)
+        lines = []
+        lines << (host ? 'WAITING FOR PLAYERS' : 'CONNECTING...') unless started
+        lines << "WAITING FOR PLAYER #{waiting.join(', ')}" if waiting.any? && stalled_seconds > stall_threshold
+        lines << "DESYNC AT TIC #{desync.tic} (#{Array(desync.sections).join(', ')})" if desync
+        lines
+      end
+    end
+  end
+end

data/lib/doom/render/font.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # DOOM's built-in font loaded from STCFN patches (ASCII 33-121).
+    # Uppercase only -- lowercase is auto-uppercased.
+    class Font
+      SPACE_WIDTH = 4
+
+      def initialize(_wad, hud_graphics)
+        @chars = {}
+        (33..121).each do |ascii|
+          name = 'STCFN%03d' % ascii
+          sprite = hud_graphics.send(:load_graphic, name)
+          @chars[ascii] = sprite if sprite
+        end
+      end
+
+      # Draw text into framebuffer at (x, y). Returns width drawn.
+      def draw_text(framebuffer, text, x, y, screen_width: 320, screen_height: 240)
+        cursor_x = x
+        text.upcase.each_char do |char|
+          if char == ' '
+            cursor_x += SPACE_WIDTH
+            next
+          end
+
+          sprite = @chars[char.ord]
+          next unless sprite
+
+          draw_char(framebuffer, sprite, cursor_x, y, screen_width, screen_height)
+          cursor_x += sprite.width
+        end
+        cursor_x - x
+      end
+
+      # Measure text width without drawing
+      def text_width(text)
+        width = 0
+        text.upcase.each_char do |char|
+          if char == ' '
+            width += SPACE_WIDTH
+            next
+          end
+          sprite = @chars[char.ord]
+          width += sprite.width if sprite
+        end
+        width
+      end
+
+      # Draw text centered horizontally
+      def draw_centered(framebuffer, text, y, screen_width: 320, screen_height: 240)
+        w = text_width(text)
+        x = (screen_width - w) / 2
+        draw_text(framebuffer, text, x, y, screen_width: screen_width, screen_height: screen_height)
+      end
+
+      private
+
+      def draw_char(framebuffer, sprite, x, y, screen_width, screen_height)
+        sprite.width.times do |col_x|
+          sx = x + col_x
+          next if sx < 0 || sx >= screen_width
+
+          col = sprite.column_pixels(col_x)
+          next unless col
+
+          col.each_with_index do |color, col_y|
+            next unless color
+
+            sy = y + col_y
+            next if sy < 0 || sy >= screen_height
+
+            framebuffer[(sy * screen_width) + sx] = color
+          end
+        end
+      end
+    end
+  end
+end