doom 0.6.0 → 0.11.0

data/lib/doom/game/sound_engine.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Plays sound effects for game events.
+    class SoundEngine
+      # Weapon fire sounds
+      WEAPON_SOUNDS = {
+        PlayerState::WEAPON_FIST => 'DSPUNCH',
+        PlayerState::WEAPON_PISTOL => 'DSPISTOL',
+        PlayerState::WEAPON_SHOTGUN => 'DSSHOTGN',
+        PlayerState::WEAPON_CHAINGUN => 'DSPISTOL',
+        PlayerState::WEAPON_ROCKET => 'DSRLAUNC',
+        PlayerState::WEAPON_PLASMA => 'DSPLASMA',
+        PlayerState::WEAPON_BFG => 'DSBFG',
+        PlayerState::WEAPON_CHAINSAW => 'DSSAWIDL'
+      }.freeze
+
+      # Monster see/activation sounds (from mobjinfo seesound)
+      MONSTER_SEE = {
+        3004 => 'DSPOSIT1', # Zombieman
+        9 => 'DSSGTSIT', # Shotgun Guy
+        3001 => 'DSBGSIT1',  # Imp
+        3002 => 'DSSGTSIT',  # Demon
+        58 => 'DSSGTSIT', # Spectre
+        3003 => 'DSBRSSIT', # Baron
+        69 => 'DSBRSSIT', # Hell Knight
+        3005 => 'DSCACSIT',  # Cacodemon
+        3006 => 'DSSKLATK',  # Lost Soul
+        65 => 'DSPOSIT2',  # Heavy Weapon Dude
+        16 => 'DSCYBSIT',  # Cyberdemon
+        7 => 'DSSPISIT' # Spider Mastermind
+      }.freeze
+
+      # Monster death sounds (from mobjinfo deathsound)
+      MONSTER_DEATH = {
+        3004 => 'DSPODTH1', # Zombieman
+        9 => 'DSSGTDTH', # Shotgun Guy
+        3001 => 'DSBGDTH1',  # Imp
+        3002 => 'DSSGTDTH',  # Demon
+        58 => 'DSSGTDTH', # Spectre
+        3003 => 'DSBRSDTH', # Baron
+        69 => 'DSBRSDTH', # Hell Knight
+        3005 => 'DSCACDTH',  # Cacodemon
+        3006 => 'DSFIRXPL',  # Lost Soul
+        65 => 'DSPODTH2',  # Heavy Weapon Dude
+        16 => 'DSCYBDTH',  # Cyberdemon
+        7 => 'DSSPIDTH' # Spider Mastermind
+      }.freeze
+
+      # Monster pain sounds (from mobjinfo painsound)
+      MONSTER_PAIN = {
+        3004 => 'DSPOPAIN', # Zombieman
+        9 => 'DSPOPAIN', # Shotgun Guy
+        3001 => 'DSDMPAIN',  # Imp
+        3002 => 'DSDMPAIN',  # Demon
+        58 => 'DSDMPAIN', # Spectre
+        3003 => 'DSDMPAIN', # Baron
+        69 => 'DSDMPAIN', # Hell Knight
+        3005 => 'DSDMPAIN',  # Cacodemon
+        3006 => 'DSDMPAIN',  # Lost Soul
+        65 => 'DSPOPAIN' # Heavy Weapon Dude
+      }.freeze
+
+      # Monster attack sounds (from mobjinfo attacksound)
+      MONSTER_ATTACK = {
+        3004 => 'DSPISTOL', # Zombieman: pistol
+        9 => 'DSSHOTGN', # Shotgun Guy: shotgun
+        3001 => 'DSFIRSHT',  # Imp: fireball launch
+        3002 => 'DSSGTATK',  # Demon: bite
+        58 => 'DSSGTATK', # Spectre: bite
+        3003 => 'DSFIRSHT', # Baron: fireball
+        69 => 'DSFIRSHT', # Hell Knight: fireball
+        3005 => 'DSFIRSHT', # Cacodemon: fireball
+        65 => 'DSSHOTGN'  # Heavy Weapon Dude: chaingun burst
+      }.freeze
+
+      def initialize(sound_manager)
+        @sounds = sound_manager
+        @last_played = {} # Throttle rapid repeats
+      end
+
+      def play(name, volume: 1.0, throttle: 0)
+        now = Time.now.to_f
+        return if (throttle > 0) && @last_played[name] && (now - @last_played[name]) < throttle
+
+        sample = @sounds[name]
+        sample&.play(volume)
+        @last_played[name] = now
+      end
+
+      # --- Menu sounds ---
+      def menu_move
+        play('DSPSTOP', throttle: 0.05)
+      end
+
+      def menu_select
+        play('DSPISTOL')
+      end
+
+      def menu_back
+        play('DSSWTCHX')
+      end
+
+      # --- Weapon events ---
+      def weapon_fire(weapon)
+        sound = WEAPON_SOUNDS[weapon]
+        play(sound, throttle: 0.05) if sound
+      end
+
+      # --- Player events ---
+      def player_pain
+        play('DSPLPAIN', throttle: 0.3)
+      end
+
+      def player_death
+        play('DSPLDETH')
+      end
+
+      def item_pickup
+        play('DSITEMUP', throttle: 0.1)
+      end
+
+      def weapon_pickup
+        play('DSWPNUP')
+      end
+
+      def noway
+        play('DSNOWAY', throttle: 0.3)
+      end
+
+      # --- Door/environment sounds ---
+      def door_open
+        play('DSDOROPN', throttle: 0.2)
+      end
+
+      def door_close
+        play('DSDORCLS', throttle: 0.2)
+      end
+
+      def platform_start
+        play('DSPSTART', throttle: 0.2)
+      end
+
+      def platform_stop
+        play('DSPSTOP', throttle: 0.2)
+      end
+
+      # --- Monster sounds ---
+      def monster_see(type)
+        sound = MONSTER_SEE[type]
+        play(sound, throttle: 0.5) if sound
+      end
+
+      def monster_death(type)
+        sound = MONSTER_DEATH[type]
+        play(sound) if sound
+      end
+
+      def monster_pain(type)
+        sound = MONSTER_PAIN[type]
+        play(sound, throttle: 0.2) if sound
+      end
+
+      def monster_attack(type)
+        sound = MONSTER_ATTACK[type]
+        play(sound, throttle: 0.1) if sound
+      end
+
+      # --- Explosions / impacts ---
+      def explosion
+        play('DSBAREXP')
+      end
+    end
+  end
+end

data/lib/doom/game/state_hash.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Doom
+  module Game
+    # A fingerprint of the simulation, for catching lockstep desync.
+    #
+    # Peers exchange this every so often. If two peers disagree at the same
+    # tic their worlds have diverged, and we want to say so loudly at the tic
+    # it happened rather than let the games drift silently apart.
+    #
+    # Deliberately NOT built on Object#hash: Ruby randomises string and array
+    # hashing per process, so two peers would disagree on identical state and
+    # every session would look like a desync. Zlib.crc32 over an explicitly
+    # packed byte string is stable across processes and machines.
+    #
+    # Floats are packed as raw IEEE754 ('E', little-endian), not rounded. In
+    # lockstep a one-ULP difference is a real divergence -- it compounds -- so
+    # the check must see it.
+    module StateHash
+      # Sections are hashed separately as well as folded together. When a
+      # desync fires, the section that differs says where to look.
+      SECTIONS = %i[rng players monsters combat sectors].freeze
+
+      module_function
+
+      def of(world)
+        fold(sections(world))
+      end
+
+      def sections(world)
+        {
+          rng: crc([world.leveltime, world.random.index].pack('q<q<')),
+          players: crc(pack_players(world.players)),
+          monsters: crc(pack_monsters(world.monster_ai)),
+          combat: crc(pack_combat(world.combat)),
+          sectors: crc(pack_sectors(world))
+        }
+      end
+
+      def fold(sections)
+        crc(SECTIONS.map { |name| sections[name] }.pack('L<*'))
+      end
+
+      def crc(bytes)
+        Zlib.crc32(bytes)
+      end
+
+      def pack_players(players)
+        players.flat_map do |p|
+          s = p.state
+          [
+            p.id, s.health, s.armor, s.weapon, (s.dead ? 1 : 0),
+            s.ammo_bullets, s.ammo_shells, s.ammo_rockets, s.ammo_cells,
+            s.keys.count { |_, v| v },
+            # Frags are simulation state: peers that disagree on the score
+            # disagree on who won, and that must show up as a desync.
+            p.frags
+          ].pack('q<*') +
+            [p.x, p.y, p.z, p.angle, p.momx, p.momy].pack('E*')
+        end.join
+      end
+
+      def pack_monsters(monster_ai)
+        return '' unless monster_ai
+
+        things = monster_ai.instance_variable_get(:@map).things
+        monster_ai.monsters.flat_map do |m|
+          thing = things[m.thing_idx]
+          [
+            m.thing_idx, m.movedir, m.movecount, (m.active ? 1 : 0),
+            (m.attacking ? 1 : 0), m.target&.id || -1,
+            # The map thing's integer position, which hitscan traces against,
+            # lags mon.x/mon.y and is distinct sim state -- a desync in it makes
+            # bullets miss where a monster appears to be.
+            thing.x, thing.y
+          ].pack('q<*') + [m.x, m.y].pack('E*')
+        end.join
+      end
+
+      def pack_combat(combat)
+        return '' unless combat
+
+        hp = combat.instance_variable_get(:@monster_hp) || {}
+        parts = [
+          hp.sort.flatten.pack('q<*'),
+          combat.dead_things.keys.sort.pack('q<*')
+        ]
+        # z and dz are as much sim state as x/y -- a projectile diverging only in
+        # height still diverges. spawn_tic pins its identity, and the damage
+        # multiplier it carries changes the damage it will deal on impact.
+        parts << combat.projectiles.flat_map do |pr|
+          [pr.x, pr.y, pr.z, pr.dx, pr.dy, pr.dz || 0.0, pr.damage_multiplier || 1.0]
+        end.pack('E*')
+        parts << combat.projectiles.map(&:spawn_tic).pack('q<*')
+        parts.join
+      end
+
+      # Sector heights as well as lights. Doors and lifts move floor and
+      # ceiling heights, and until now the fingerprint watched only the light
+      # level -- so a door desyncing between peers went unnoticed. Active door
+      # and lift animations are folded in too, so a divergence is caught while
+      # the sector is still moving rather than only once it settles.
+      def pack_sectors(world)
+        sectors = world.map.sectors
+        heights = sectors.flat_map { |s| [s.light_level, s.floor_height, s.ceiling_height] }
+
+        actions = world.sector_actions
+        doors = actions.instance_variable_get(:@active_doors) || {}
+        lifts = actions.instance_variable_get(:@active_lifts) || {}
+        sorted_lifts = lifts.sort_by { |idx, _| idx }
+        moving = doors.sort_by { |idx, _| idx }.flat_map { |idx, d| [idx, d[:state], d[:wait_tics]] } +
+                 sorted_lifts.flat_map { |idx, l| [idx, l[:wait_tics]] }
+        # A lift's :state is a symbol (going down / waiting / coming up), not an
+        # integer like a door's, so it is folded in as bytes rather than packed
+        # with the integer run -- otherwise a lift changing phase between peers
+        # would go unnoticed the way a moving door once did.
+        lift_states = sorted_lifts.map { |_, l| l[:state].to_s }.join("\0")
+
+        heights.pack('q<*') + moving.pack('q<*') + lift_states
+      end
+    end
+  end
+end

data/lib/doom/game/ticcmd.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # One tic's worth of player intent, as in DOOM's ticcmd_t.
+    #
+    # This is the only thing that travels between peers in lockstep
+    # multiplayer: never positions, never health. Each peer feeds identical
+    # ticcmds to an identical simulation and arrives at an identical world, so
+    # the wire format stays tiny and cheating by position injection is
+    # impossible by construction.
+    #
+    #   forwardmove  -1.0..1.0  (negative = backward)
+    #   sidemove     -1.0..1.0  (positive = strafe right)
+    #   angleturn    degrees to turn this tic (positive = left, as DOOM)
+    #   buttons      bitmask, see constants below
+    # Subclassed rather than built with a Struct.new block: constants assigned
+    # inside a block land in the enclosing lexical scope (Doom::Game), not on
+    # the struct class, so Ticcmd::BTN_FIRE would not resolve.
+    class Ticcmd < Struct.new(:forwardmove, :sidemove, :angleturn, :buttons)
+      BTN_FIRE = 1
+      BTN_USE  = 2
+      PACKED_SIZE = 7
+
+      def self.none
+        new(0.0, 0.0, 0.0, 0)
+      end
+
+      def fire?
+        (buttons & BTN_FIRE) != 0
+      end
+
+      def use?
+        (buttons & BTN_USE) != 0
+      end
+
+      def moving?
+        forwardmove != 0.0 || sidemove != 0.0
+      end
+
+      # Fixed 7 bytes on the wire ('s>s>s>C', == PACKED_SIZE): three signed
+      # shorts plus a byte of buttons, no padding. Movement is quantised to
+      # 1/1000 and the turn to 1/100 of a degree -- both far finer than any input
+      # device resolves, and identical on every peer, which matters more than the
+      # precision itself.
+      def pack
+        [
+          (forwardmove * 1000).round.clamp(-32_768, 32_767),
+          (sidemove * 1000).round.clamp(-32_768, 32_767),
+          (angleturn * 100).round.clamp(-32_768, 32_767),
+          buttons & 0xff
+        ].pack('s>s>s>C')
+      end
+
+      def self.unpack(bytes)
+        f, s, a, b = bytes.unpack('s>s>s>C')
+        new(f / 1000.0, s / 1000.0, a / 100.0, b)
+      end
+    end
+  end
+end