doom 0.8.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

@@ -7,10 +7,10 @@ module Doom
     class Font
       SPACE_WIDTH = 4
 
-      def initialize(wad, hud_graphics)
+      def initialize(_wad, hud_graphics)
         @chars = {}
         (33..121).each do |ascii|
-          name = "STCFN%03d" % ascii
+          name = 'STCFN%03d' % ascii
           sprite = hud_graphics.send(:load_graphic, name)
           @chars[ascii] = sprite if sprite
         end
@@ -67,9 +67,11 @@ module Doom
 
           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
+
+            framebuffer[(sy * screen_width) + sx] = color
           end
         end
       end