quake-rb 0.1.0 → 0.2.0

data/lib/quake/game/engine.rb

@@ -1,22 +1,98 @@
 # frozen_string_literal: true
 
 require_relative "../debug/screenshot"
+require_relative "../mdl/types"
+require_relative "../mdl/reader"
+require_relative "../renderer/gl_lightmap"
+require_relative "../renderer/gl_view_blend"
 
 module Quake
   module Game
     # Encapsulates the entire game state and per-frame loop, allowing both
     # interactive (bin/quake) and scripted (bin/quake-debug) execution.
     class Engine
+      POWERUP_EXPIRING_EVENTS = {
+        ring: :ring_expiring,
+        pentagram: :pentagram_expiring,
+        biosuit: :biosuit_expiring,
+        quad: :quad_expiring
+      }.freeze
+
+      # CheckPowerups sprints (client.qc) shown when a powerup has less
+      # than three seconds left.
+      POWERUP_EXPIRING_MESSAGES = {
+        ring: "Ring of Shadows magic is fading",
+        pentagram: "Protection is almost burned out",
+        biosuit: "Air supply in Biosuit expiring",
+        quad: "Quad Damage is wearing off"
+      }.freeze
+
+      # scr_centertime (screen.c) and con_notifytime (console.c) defaults.
+      CENTERPRINT_TIME = 2.0
+      CON_NOTIFYTIME = 3.0
+      # NUM_CON_TIMES notify lines shown at once (console.c Con_DrawNotify).
+      MAX_NOTIFY_LINES = 4
+
+      START_ITEM_CLASSNAMES = %w[
+        item_health item_armor1 item_armor2 item_armorInv
+        weapon_supershotgun weapon_nailgun weapon_supernailgun
+        weapon_grenadelauncher weapon_rocketlauncher weapon_lightning
+        item_shells item_spikes item_rockets item_cells item_weapon
+        item_key1 item_key2 item_sigil
+        item_artifact_invulnerability item_artifact_envirosuit
+        item_artifact_invisibility item_artifact_super_damage
+      ].freeze
+
+      ITEM_WIDE_BOUNDS_CLASSNAMES = %w[
+        item_health item_shells item_spikes item_rockets item_cells item_weapon
+      ].freeze
+
+      ITEM_TALL_BOUNDS_CLASSNAMES = %w[
+        item_armor1 item_armor2 item_armorInv
+        weapon_supershotgun weapon_nailgun weapon_supernailgun
+        weapon_grenadelauncher weapon_rocketlauncher weapon_lightning
+      ].freeze
+
+      QUAKEWORLD_REMOVED_MONSTER_CLASSNAMES = %w[
+        monster_ogre monster_demon1 monster_shambler monster_knight
+        monster_army monster_wizard monster_dog monster_zombie
+        monster_boss monster_tarbaby monster_hell_knight monster_fish
+        monster_shalrath monster_enforcer monster_oldone
+      ].freeze
+
+      PLAYER_DEATH_FRAMES = {
+        axe: (41..49).to_a,
+        a: (50..60).to_a,
+        b: (61..69).to_a,
+        c: (70..84).to_a,
+        d: (85..93).to_a,
+        e: (94..102).to_a
+      }.freeze
+      PLAYER_DEATHA11_FRAME = 60
+
+      PLAYER_PAIN_FRAMES = {
+        axe: (29..34).to_a,
+        normal: (35..40).to_a
+      }.freeze
+      PLAYER_STAND_FRAMES = {
+        axe: (17..28).to_a,
+        normal: (12..16).to_a
+      }.freeze
+
       attr_reader :pak, :palette, :wad, :window, :level, :entities,
                   :player, :player_state, :camera,
                   :viewmodel, :hud, :particles, :sound_events,
-                  :brush_game, :item_pickups
-      attr_accessor :game_time
+                  :brush_game, :item_pickups, :dynamic_lights
+      attr_accessor :game_time, :samelevel, :deathmatch, :teamplay, :rj, :axe, :temp1,
+                    :timelimit, :fraglimit
+      attr_writer :attack_pressed
 
       def initialize(pak_path:, window: nil, window_visible: true,
                      window_width: nil, window_height: nil,
-                     enable_sound: true, enable_render: true)
+                     enable_sound: true, enable_render: true,
+                     registered: false)
         @enable_render = enable_render
+        @registered = registered
 
         # PAK + assets
         @pak = Pak::Reader.new(pak_path)
@@ -45,7 +121,57 @@ module Quake
         end
 
         @keys = {}
+        @attack_pressed = false
+        @attack_finished = 0.0
+        @pending_changelevel = nil
+        @pending_changelevel_time = nil
+        @samelevel = 0
+        @deathmatch = 0
+        @teamplay = 0
+        @rj = 1.0
+        @axe = 0
+        @temp1 = 0
+        @timelimit = 0
+        @fraglimit = 0
+        @current_map = nil
+        @killed_monsters = 0
+        @total_monsters = 0
+        @level_name = nil
+        @intermission_running = false
+        @intermission_start_time = nil
+        @gravity = GRAVITY
+        @projectiles = []
+        @temporary_dynamic_lights = []
+        @temporary_beams = []
+        @environment_damage_time = 0.0
+        @air_finished = 12.0
+        @drown_damage = 2.0
+        @drown_pain_finished = 0.0
+        @pain_sound_finished = 0.0
+        @invincible_sound_finished = 0.0
+        @swim_sound_finished = 0.0
+        @quad_attack_sound_finished = 0.0
+        @ring_idle_sound_finished = 0.0
+        @powerup_warning_finished = {}
+        @bonus_cshift_percent = 0.0
+        @damage_cshift = Renderer::GLViewBlend::CShift.new(color: [0, 0, 0], percent: 0.0)
+        @damage_kick_time = 0.0
+        @damage_kick_roll = 0.0
+        @damage_kick_pitch = 0.0
+        @weapon_punch_angle = Math::Vec3::ORIGIN
+        @view_oldz = 0.0
+        @view_frame_dt = 0.0
+        @view_idle_scale = 0.0
+        @view_idealpitch = 0.0
+        @view_pitch_velocity = 0.0
+        @view_pitch_nodrift = true
+        @view_pitch_driftmove = 0.0
+        @view_pitch_laststop = 0.0
+        @jump_flag = 0.0
         @game_time = 0.0
+        @notify_lines = []
+        @centerprint = nil
+        @centerprint_expire = nil
       end
 
       # Load a BSP map and (re)build all per-level state.
@@ -54,37 +180,79 @@ module Quake
         raise "Map not found: #{map_name}" unless bsp_data
 
         @level = Bsp::Reader.new(bsp_data).parse
+        @current_map = map_name
+        configure_world_gravity(map_name)
         @entities = EntityParser.parse(@level.entities)
         @target_map = EntityParser.build_target_map(@entities)
+        initialize_body_queue
+        @projectiles = []
+        @temporary_dynamic_lights = []
+        @temporary_beams = []
+        @environment_damage_time = 0.0
+        @air_finished = @game_time + 12.0
+        @drown_damage = 2.0
+        @drown_pain_finished = 0.0
+        @player_in_water = false
+        @bonus_cshift_percent = 0.0
+        @damage_cshift = Renderer::GLViewBlend::CShift.new(color: [0, 0, 0], percent: 0.0)
+        @damage_kick_time = 0.0
+        @damage_kick_roll = 0.0
+        @damage_kick_pitch = 0.0
+        @weapon_punch_angle = Math::Vec3::ORIGIN
+        @view_oldz = 0.0
+        @view_frame_dt = 0.0
+        @view_idle_scale = 0.0
+        @view_idealpitch = 0.0
+        @view_pitch_velocity = 0.0
+        @view_pitch_nodrift = true
+        @view_pitch_driftmove = 0.0
+        @view_pitch_laststop = 0.0
+        @attack_finished = @game_time
+        @jump_flag = 0.0
+        @notify_lines = []
+        @centerprint = nil
+        @centerprint_expire = nil
+        setup_misc_entities
+        setup_ambient_sounds
+
+        # Level stats for the HUD scoreboard/intermission (Quake's
+        # total_monsters / killed_monsters, sbar.c STAT_* values).
+        # Monsters count only entities that actually spawned (the
+        # QuakeWorld-style monster stubs remove themselves at spawn).
+        @killed_monsters = 0
+        @total_monsters = @entities.count do |ent|
+          ent.classname.to_s.start_with?("monster_") && !ent.removed?
+        end
+        message = world_info_value("message")
+        @level_name = message && !message.empty? ? message : File.basename(map_name, ".bsp")
+        @intermission_start_time = nil
 
-        # Find player start
-        player_ent = @entities.find { |e| e.classname == "info_player_start" }
-        @player_start = player_ent&.position || Math::Vec3::ORIGIN
-        @player_yaw = player_ent&.angle || 0.0
+        set_player_spawn_point(select_spawn_point)
 
         # Load MDL models referenced by entities
         @mdl_cache ||= {}
-        @entities.each do |ent|
-          model_path = ent["model"]
-          next unless model_path&.end_with?(".mdl")
-          next if @mdl_cache.key?(model_path)
-          begin
-            mdl_data = @pak.read(model_path)
-            @mdl_cache[model_path] = Mdl::Reader.new(mdl_data).parse
-          rescue => e
-            warn "Failed to load #{model_path}: #{e.message}"
-            @mdl_cache[model_path] = nil
-          end
-        end
+        @entities.each { |ent| load_mdl_model(ent["model"]) unless ent.removed? }
+        TEMP_ENTITY_MODELS.each { |model_path| load_mdl_model(model_path) }
 
         # Persistent player state across level loads
         @player_state ||= PlayerState.new
-        @item_pickups = ItemPickups.new(@entities)
-        @brush_game = BrushEntities.new(@entities, @level, @target_map)
+        @player_state.reset_spawn_runtime_fields
+        apply_start_map_parms
+        @item_pickups = ItemPickups.new(@entities, deathmatch: deathmatch)
+        @brush_game = BrushEntities.new(
+          @entities, @level, @target_map,
+          sound_events: @sound_events,
+          registered: @registered,
+          serverflags: @player_state.serverflags,
+          worldtype: current_worldtype
+        )
 
         # Player + camera (reset position to start)
-        @player = Physics::Player.new(position: @player_start, yaw: @player_yaw)
-        @camera = Camera.new(position: @player.eye_position, yaw: @player_yaw)
+        @player = Physics::Player.new(position: player_spawn_origin, yaw: @player_yaw)
+        @player.gravity = current_gravity
+        set_player_spawn_entity_state
+        apply_put_client_in_server_spawn_effects
+        @camera = Camera.new(position: player_eye_position, yaw: @player_yaw)
 
         build_renderers if @enable_render
       end
@@ -93,10 +261,19 @@ module Quake
       def tick(dt)
         @game_time += dt
 
+        if @intermission_running
+          intermission_think
+          sync_camera
+          return unless @enable_render
+
+          render
+          return
+        end
+
         # Brush entities first (so collision uses current positions)
         if @brush_game
-          @brush_game.update(dt, @player.position)
-          @brush_game.check_triggers(@player.position) do |trigger|
+          @brush_game.update(dt, @player.position, player_state: @player_state)
+          @brush_game.check_triggers(@player.position, player_forward: @player.forward_flat) do |trigger|
             handle_trigger(trigger)
           end
 
@@ -109,14 +286,40 @@ module Quake
         end
 
         solid_brush = @entities.select(&:brush_entity?)
-        @player.update(dt, @level, @keys, brush_entities: solid_brush)
+        update_player_control(dt, solid_brush)
+        @player_state.update_megahealth(@game_time) unless @item_pickups&.owns_megahealth_rot_for?(@player_state)
+        update_start_items
+        if @item_pickups
+          @item_pickups.update(@game_time, player_state: @player_state).each do |evt|
+            @sound_events&.on_pickup(evt)
+          end
+        end
 
         # Item pickups
-        events = @item_pickups.check_pickups(@player.position, @player_state)
+        events = @item_pickups.check_pickups(
+          @player.position, @player_state, game_time: @game_time, water_level: @player.water_level
+        )
         events.each do |evt|
-          @sound_events&.on_pickup(evt)
-          @particles&.pickup_effect(evt[:entity].position)
-          @viewmodel&.set_weapon(@player_state.current_weapon_model)
+          process_item_pickup_feedback(evt)
+          process_item_pickup_targets(evt)
+        end
+
+        if player_postthink_active?
+          check_powerup_warnings
+          refresh_biosuit_air
+          update_player_powerup_visual_state
+          update_player_powerups
+          check_no_ammo_weapon_switch
+          fire_weapon if @attack_pressed && @game_time >= @attack_finished
+        end
+        update_triggered_misc_entities
+        update_projectiles(dt)
+        update_temporary_entities
+        update_player_pain_animation
+        update_player_death_animation
+        check_rules if player_postthink_active?
+        if @pending_changelevel && @game_time + 0.000001 >= @pending_changelevel_time.to_f
+          run_pending_changelevel
         end
 
         # Viewmodel bob (before camera so bob is applied to camera too)
@@ -125,48 +328,132 @@ module Quake
           @viewmodel.update(dt, speed)
         end
 
-        # Sync camera
-        eye = @player.eye_position
-        bob = @viewmodel ? @viewmodel.bob : 0.0
-        @camera.position = Math::Vec3.new(eye.x, eye.y, eye.z + bob)
-        @camera.yaw = @player.yaw
-        @camera.pitch = @player.pitch
+        @view_frame_dt = dt
+        sync_camera
+        update_screen_messages
 
         return unless @enable_render
 
         @world_renderer.update(dt) if @world_renderer.respond_to?(:update)
         @particles&.update(dt)
+        update_view_cshifts(dt)
 
         render
       end
 
       def render
-        @world_renderer.render(@camera, @window.aspect_ratio)
-        @brush_renderer&.render(@entities)
+        build_dynamic_lights
+        @lightmap&.update(@game_time, lightstyles: current_lightstyles, dynamic_lights: @dynamic_lights)
+        @world_renderer.render(@camera, @window.aspect_ratio, time: @game_time)
+        @brush_renderer&.render(@entities, view_origin: @camera.position, time: @game_time,
+                                frustum: @camera.frustum_planes(@window.aspect_ratio))
 
         @entities.each do |ent|
+          next if ent.removed?
           next if @item_pickups.picked_up?(ent)
+
+          emit_entity_effect_particles(ent)
           model_path = ent["model"]
           next unless model_path&.end_with?(".mdl")
 
           gl_model = @mdl_renderers[model_path]
           next unless gl_model
-
-          frame_rate = 10.0
-          frame = (@game_time * frame_rate).to_i
-          lerp = (@game_time * frame_rate) % 1.0
+          ambient_light, shade_light = alias_entity_lighting(ent.position)
 
           gl_model.render(
-            frame_index: frame,
-            lerp: lerp,
+            frame_index: ent.frame,
+            lerp: 0.0,
             position: ent.position,
-            yaw: ent.angle
+            yaw: alias_entity_yaw(ent, model_path),
+            pitch: -ent.angles.x,
+            roll: ent.angles.z,
+            skin_index: ent.skin,
+            time: @game_time + entity_sync_base(ent, gl_model),
+            ambient_light: ambient_light,
+            shade_light: shade_light
           )
         end
 
-        @particles&.render
-        @viewmodel&.render(@camera, @window.aspect_ratio)
-        @hud&.render(@player_state)
+        render_projectiles
+        render_temp_beams
+        @particles&.render(camera: @camera)
+        render_viewmodel
+        @world_renderer.render_water
+        @view_blend&.render(current_view_blend)
+        @hud&.render(@player_state, time: @game_time, stats: hud_stats)
+      end
+
+      # Level statistics for the HUD (Quake's cl.stats STAT_MONSTERS /
+      # STAT_SECRETS etc. plus intermission state, sbar.c).
+      def hud_stats
+        {
+          monsters: @killed_monsters.to_i,
+          total_monsters: @total_monsters.to_i,
+          secrets: @brush_game&.found_secrets.to_i,
+          total_secrets: @brush_game&.total_secrets.to_i,
+          time: @game_time,
+          level_name: @level_name,
+          intermission: !!@intermission_running,
+          completed_time: @intermission_start_time,
+          sb_lines: sb_lines,
+          centerprint: active_centerprint,
+          notify_lines: active_notify_lines
+        }
+      end
+
+      # QuakeC sprint(): queue a console notify line (top-left text,
+      # console.c Con_Print + Con_DrawNotify). Multi-line messages become
+      # one notify line each; only the last MAX_NOTIFY_LINES are kept.
+      def sprint(text)
+        @notify_lines ||= []
+        text.to_s.split("\n").each do |line|
+          next if line.empty?
+
+          @notify_lines << { text: line, expire: @game_time + CON_NOTIFYTIME }
+          @notify_lines.shift while @notify_lines.length > MAX_NOTIFY_LINES
+        end
+      end
+
+      # Latch centerprints written to the player (QuakeC centerprint())
+      # and drop expired on-screen text. Runs once per tick.
+      def update_screen_messages
+        message = @player_state&.centerprint
+        if message && !message.to_s.empty?
+          @centerprint = message
+          @centerprint_expire = @game_time + CENTERPRINT_TIME
+          @player_state.centerprint = nil
+        end
+        @centerprint = nil if @centerprint && @centerprint_expire.to_f <= @game_time
+        @notify_lines&.reject! { |line| line[:expire] <= @game_time }
+      end
+
+      def active_centerprint
+        return nil unless @centerprint
+        return nil if @centerprint_expire.to_f <= @game_time
+
+        @centerprint
+      end
+
+      def active_notify_lines
+        (@notify_lines || []).select { |line| line[:expire] > @game_time }
+                             .map { |line| line[:text] }
+      end
+
+      # viewsize like Quake's +/- keys: 120 hides the bar, 110 shows the
+      # status bar only (default), 100 adds the inventory bar. Sub-100
+      # sizes (shrunk 3D view) are not supported.
+      def adjust_viewsize(delta)
+        @viewsize = ((@viewsize || DEFAULT_VIEWSIZE) + delta).clamp(100, 120)
+        puts "viewsize #{@viewsize}"
+        @viewsize
+      end
+
+      def sb_lines
+        size = @viewsize || DEFAULT_VIEWSIZE
+        return 0 if size >= 120
+        return 24 if size >= 110
+
+        40
       end
 
       def swap_buffers
@@ -191,6 +478,10 @@ module Quake
         @keys
       end
 
+      def set_attack(pressed)
+        @attack_pressed = pressed
+      end
+
       # ---------------------- player control ---------------------
 
       def teleport(x, y, z, yaw: nil, pitch: nil)
@@ -198,9 +489,7 @@ module Quake
         @player.velocity = Math::Vec3::ORIGIN
         @player.instance_variable_set(:@yaw, yaw.to_f) if yaw
         @player.instance_variable_set(:@pitch, pitch.to_f) if pitch
-        @camera.position = @player.eye_position
-        @camera.yaw = @player.yaw
-        @camera.pitch = @player.pitch
+        sync_camera
       end
 
       # ---------------------- debug output -----------------------
@@ -212,6 +501,7 @@ module Quake
       def dump_state
         {
           time: @game_time,
+          map: @current_map,
           player: {
             position: vec_to_a(@player.position),
             velocity: vec_to_a(@player.velocity),
@@ -226,7 +516,8 @@ module Quake
             armor: @player_state.armor,
             armor_type: @player_state.armor_type,
             current_weapon: @player_state.current_weapon,
-            ammo: @player_state.ammo.dup
+            ammo: @player_state.ammo.dup,
+            attack_finished: @attack_finished
           },
           brush_entities: brush_entity_summaries,
           particles: @particles ? @particles.particle_count : 0
@@ -249,7 +540,7 @@ module Quake
 
       def brush_entity_summaries
         return [] unless @brush_game
-        @entities.select(&:brush_entity?).map do |e|
+        @entities.select { |ent| ent.brush_entity? && !ent.removed? }.map do |e|
           {
             classname: e.classname,
             targetname: e.targetname,
@@ -259,11 +550,124 @@ module Quake
         end
       end
 
+      def viewmodel_visible?
+        @player_state&.alive? && !@player_state.powerup_item_active?(:ring, game_time: @game_time)
+      end
+
+      def render_viewmodel
+        return unless @viewmodel
+
+        camera = viewmodel_camera
+        ambient_light, shade_light = alias_entity_lighting(camera.position)
+        @viewmodel.render(
+          camera,
+          @window.aspect_ratio,
+          visible: viewmodel_visible?,
+          ambient_light: ambient_light,
+          shade_light: shade_light
+        )
+      end
+
+      ENTITY_HULL_MINS = Math::Vec3.new(-16.0, -16.0, -24.0)
+      ENTITY_HULL_MAXS = Math::Vec3.new(16.0, 16.0, 32.0)
+      GRAVITY = 800.0
+      STOP_EPSILON = 0.1
+      MOVETYPE_NONE = 0
+      MOVETYPE_WALK = 3
+      MOVETYPE_TOSS = 6
+      MOVETYPE_NOCLIP = 8
+      MOVETYPE_BOUNCE = 10
+      MOVETYPE_PUSH = 7
+      SOLID_NOT = 0
+      SOLID_BBOX = 2
+      SOLID_SLIDEBOX = 3
+      DAMAGE_AIM = 2
+      FL_ONGROUND = 512
+      GRENADE_FUSE = 2.5
+      ROCKET_LIFETIME = 5.0
+      DEFAULT_VIEWSIZE = 110 # status bar only; 100 adds the inventory bar
+      SPIKE_LIFETIME = 6.0
+      LASER_LIFETIME = 5.0
+      EF_ROCKET = 1
+      EF_GRENADE = 2
+      EF_GIB = 4
+      EF_ROTATE = 8
+      EF_TRACER = 16
+      EF_ZOMGIB = 32
+      EF_TRACER2 = 64
+      EF_TRACER3 = 128
+      ENTITY_EFFECT_BRIGHTFIELD = 1
+      ENTITY_EFFECT_MUZZLEFLASH = 2
+      ENTITY_EFFECT_BRIGHTLIGHT = 4
+      ENTITY_EFFECT_DIMLIGHT = 8
+      PLAYER_WEAPON_ITEM_BITS = {
+        shotgun: 1,
+        super_shotgun: 2,
+        nailgun: 4,
+        super_nailgun: 8,
+        grenade_launcher: 16,
+        rocket_launcher: 32,
+        lightning_gun: 64,
+        axe: 4096
+      }.freeze
+      PLAYER_WEAPON_NETNAMES = {
+        axe: "Axe",
+        shotgun: "Shotgun",
+        super_shotgun: "Double-barrelled Shotgun",
+        nailgun: "Nailgun",
+        super_nailgun: "Super Nailgun",
+        grenade_launcher: "Grenade Launcher",
+        rocket_launcher: "Rocket Launcher",
+        lightning_gun: "Thunderbolt"
+      }.freeze
+      TEMP_ENTITY_MODELS = %w[
+        progs/bolt.mdl progs/bolt2.mdl progs/bolt3.mdl
+      ].freeze
+      MAX_BEAMS = 24
+      VIEW_ENTITY = 1
+      VIEW_ORIGIN_NUDGE = 1.0 / 32.0
+      VIEW_ORIGIN_NUDGE_VECTOR = Math::Vec3.new(
+        VIEW_ORIGIN_NUDGE,
+        VIEW_ORIGIN_NUDGE,
+        VIEW_ORIGIN_NUDGE
+      )
+      VIEW_BOUND_XY = 14.0
+      VIEW_BOUND_Z_MIN = -22.0
+      VIEW_BOUND_Z_MAX = 30.0
+      STAIR_SMOOTH_SPEED = 80.0
+      STAIR_SMOOTH_MAX = 12.0
+      VIEW_IDLE_YAW_CYCLE = 2.0
+      VIEW_IDLE_ROLL_CYCLE = 0.5
+      VIEW_IDLE_PITCH_CYCLE = 1.0
+      VIEW_IDLE_YAW_LEVEL = 0.3
+      VIEW_IDLE_ROLL_LEVEL = 0.1
+      VIEW_IDLE_PITCH_LEVEL = 0.3
+      VIEW_CENTER_MOVE = 0.15
+      VIEW_CENTER_SPEED = 500.0
+      WEAPON_PUNCH_DECAY = 10.0
+      WEAPON_PUNCH_ANGLES = {
+        small: Math::Vec3.new(-2.0, 0.0, 0.0),
+        big: Math::Vec3.new(-4.0, 0.0, 0.0)
+      }.freeze
+      Projectile = Data.define(
+        :kind, :position, :velocity, :damage, :damage_variance, :radius_damage, :explode_at,
+        :model, :movetype, :solid, :effects, :angles, :avelocity, :voided, :owner
+      ) do
+        def classname
+          kind == :fireball ? "fireball" : kind.to_s
+        end
+      end
+      DynamicLight = Data.define(:key, :origin, :radius, :minlight, :die)
+      TemporaryDynamicLight = Data.define(:origin, :radius, :minlight, :start_time, :die, :decay)
+      TemporaryBeam = Data.define(:entity, :model, :end_time, :start, :finish)
+      TemporaryBeamSegment = Data.define(:model, :origin, :pitch, :yaw, :roll)
+      WeaponSound = Data.define(:sound)
+
       def build_renderers
         @tex_manager = Renderer::GLTextureManager.new(@level, @palette)
         @tex_manager.upload_all
 
-        @lightmap = Renderer::GLLightmap.new(@level, @palette)
+        @lightmap = Renderer::GLLightmap.new(@level, @palette, lightstyles: current_lightstyles)
         @lightmap.build_all
 
         @sky = Renderer::GLSky.new(@level, @palette, @tex_manager)
@@ -279,22 +683,3937 @@ module Quake
         @mdl_renderers = {}
         @mdl_cache.each do |path, mdl|
           next unless mdl
-          @mdl_renderers[path] = Renderer::GLAliasModel.new(mdl, @palette)
+          @mdl_renderers[path] = Renderer::GLAliasModel.new(mdl, @palette, model_name: path)
         end
 
         @viewmodel = Renderer::GLViewmodel.new(@pak, @palette)
         @viewmodel.set_weapon(@player_state.current_weapon_model)
 
-        @hud = Renderer::GLHud.new(@wad, @palette, @window.width, @window.height) if @wad
+        @hud = Renderer::GLHud.new(@wad, @palette, @window.width, @window.height, pak: @pak) if @wad
         @particles = Renderer::GLParticles.new(@palette)
+        @view_blend = Renderer::GLViewBlend.new
+      end
+
+      def load_mdl_model(model_path)
+        return unless model_path&.end_with?(".mdl")
+        return if @mdl_cache.key?(model_path)
+
+        begin
+          mdl_data = @pak.read(model_path)
+          @mdl_cache[model_path] = Mdl::Reader.new(mdl_data).parse
+        rescue => e
+          warn "Failed to load #{model_path}: #{e.message}"
+          @mdl_cache[model_path] = nil
+        end
+      end
+
+      def apply_start_map_parms
+        return unless @current_map == "maps/start.bsp"
+        return if @player_state.serverflags.zero?
+
+        @player_state.reset_to_new_parms
       end
 
       def handle_trigger(trigger)
         case trigger.classname
         when "trigger_changelevel"
-          # Will be implemented later (level transitions)
+          if samelevel_blocks_changelevel?
+            damage_player(50_000, inflictor: trigger)
+            return
+          end
+
+          @brush_game.use_targets(trigger, activator: @player_state)
+          queue_changelevel(trigger)
+        when "trigger_teleport"
+          return if trigger.targetname && (trigger.think_time.zero? || trigger.think_time < @game_time)
+          return unless @player_state.alive?
+
+          @brush_game.use_targets(trigger, activator: @player_state)
+          teleport_trigger(trigger)
+        when "trigger_hurt"
+          hurt_trigger(trigger)
+        when "trigger_push"
+          push_trigger(trigger)
+        else
+          @brush_game.touch_trigger(trigger, activator: @player_state)
+        end
+      end
+
+      def queue_changelevel(trigger)
+        map = trigger["map"]
+        raise "chagnelevel trigger doesn't have map" if map.nil? || map.empty?
+
+        trigger.instance_variable_set(:@touch_disabled, true)
+        trigger.instance_variable_set(:@think, :execute_changelevel)
+        trigger.think_time = @game_time.to_f + 0.1
+        @pending_changelevel = normalize_map_name(map)
+        @pending_changelevel_time = [@pending_changelevel_time || trigger.think_time, trigger.think_time].min
+      end
+
+      def samelevel_blocks_changelevel?
+        @samelevel.to_i == 2 || (@samelevel.to_i == 3 && current_quake_mapname != "start")
+      end
+
+      def next_level
+        return if @pending_changelevel
+
+        mapname = current_quake_mapname
+        trigger = if @samelevel.to_i == 1
+                    Entity.new("map" => mapname)
+                  elsif mapname == "start"
+                    Entity.new("map" => start_map_next_level)
+                  else
+                    @entities&.find { |ent| ent.classname == "trigger_changelevel" } ||
+                      Entity.new("map" => mapname)
+                  end
+
+        queue_changelevel(trigger)
+      end
+
+      def check_rules
+        next_level if timelimit.to_f.nonzero? && @game_time.to_f >= timelimit.to_f
+        next_level if fraglimit.to_i.nonzero? && @player_state.frags.to_i >= fraglimit.to_i
+      end
+
+      def current_quake_mapname
+        File.basename(@current_map.to_s, ".bsp")
+      end
+
+      def start_map_next_level
+        return "e1m1" unless @registered
+
+        if (@player_state.serverflags & 1).zero?
+          set_serverflags(@player_state.serverflags | 1)
+          "e1m1"
+        elsif (@player_state.serverflags & 2).zero?
+          set_serverflags(@player_state.serverflags | 2)
+          "e2m1"
+        elsif (@player_state.serverflags & 4).zero?
+          set_serverflags(@player_state.serverflags | 4)
+          "e3m1"
+        elsif (@player_state.serverflags & 8).zero?
+          set_serverflags(@player_state.serverflags - 7)
+          "e4m1"
+        else
+          "start"
+        end
+      end
+
+      def set_serverflags(flags)
+        @player_state.instance_variable_set(:@serverflags, flags.to_i)
+      end
+
+      def process_item_pickup_targets(event)
+        entity = event[:entity]
+        return unless entity
+        return if event[:use_targets] == false
+        return if event[:type] == :backpack || entity.classname == "item_backpack"
+
+        @brush_game&.use_targets(entity, activator: @player_state)
+      end
+
+      def process_item_pickup_feedback(event)
+        sprint(event[:message]) if event[:message]
+        @sound_events&.on_pickup(event)
+        trigger_bonus_flash
+        @particles&.pickup_effect(event[:entity].position)
+        @viewmodel&.set_weapon(@player_state.current_weapon_model)
+      end
+
+      def normalize_map_name(map)
+        map = map.to_s
+        map = "maps/#{map}" unless map.include?("/")
+        map.end_with?(".bsp") ? map : "#{map}.bsp"
+      end
+
+      def run_pending_changelevel
+        @intermission_next_map = changelevel_destination_map(@pending_changelevel)
+        @pending_changelevel = nil
+        @pending_changelevel_time = nil
+        execute_changelevel
+      end
+
+      def execute_changelevel
+        @intermission_running = true
+        @intermission_start_time = @game_time.to_f
+        @intermission_exittime = @game_time.to_f + 5.0
+        @intermission_spot = find_intermission_spot
+        @intermission_origin = @intermission_spot.position
+        @intermission_angles = vec3_property(@intermission_spot, "mangle")
+        freeze_intermission_player(@player) if @player
+        (@entities || []).each { |ent| freeze_intermission_player(ent) if ent.classname == "player" }
+      end
+
+      def freeze_intermission_player(player)
+        player.instance_variable_set(:@takedamage, 0)
+        player.instance_variable_set(:@solid, SOLID_NOT)
+        player.instance_variable_set(:@movetype, MOVETYPE_NONE)
+        if player.respond_to?(:model_index=)
+          player.model_index = 0
+        else
+          player.instance_variable_set(:@modelindex, 0)
+        end
+      end
+
+      def intermission_think
+        return if @game_time.to_f < @intermission_exittime.to_f
+        return unless intermission_exit_button_down?
+
+        complete_intermission_changelevel
+      end
+
+      def intermission_exit_button_down?
+        @attack_pressed || (@keys || {})[SDL::SCANCODE_SPACE]
+      end
+
+      def complete_intermission_changelevel
+        next_map = @intermission_next_map
+        @intermission_running = false
+        @intermission_next_map = nil
+        @intermission_spot = nil
+        @intermission_origin = nil
+        @intermission_angles = nil
+
+        # QuakeC changelevel_touch saves SetChangeParms before Host_Changelevel
+        # spawns the next server. PlayerState remains persistent after applying
+        # those transition rules, while player/camera reset to the new start.
+        @player_state.apply_changelevel_parms
+        load_map(next_map)
+      end
+
+      def changelevel_destination_map(next_map)
+        if @samelevel.to_i == 1
+          normalize_map_name(current_quake_mapname)
+        else
+          override = world_info_value(current_quake_mapname)
+          normalize_map_name(override.nil? || override.empty? ? next_map : override)
+        end
+      end
+
+      def teleport_trigger(trigger)
+        target = trigger.target
+        raise "trigger_teleport doesn't have target" if target.nil? || target.empty?
+
+        dest = @target_map[target]&.find { |ent| ent.classname == "info_teleport_destination" } ||
+               @target_map[target]&.first
+        raise "couldn't find target" unless dest
+
+        setup_teleport_destination(dest) if dest.classname == "info_teleport_destination"
+        old_pos = @player.position
+        dest_pos = dest.position
+        mangle = dest.instance_variable_get(:@mangle) || dest.angles
+        forward = angle_forward(mangle)
+        spawn_teleport_fog(old_pos)
+        spawn_teleport_fog(dest_pos + forward * 32.0)
+        apply_telefrag_damage(dest_pos)
+        if @player_state.health <= 0
+          velocity = @player.velocity
+          @player.position = dest_pos
+          @player.velocity = forward * velocity.x + forward * velocity.y
+          return
+        end
+
+        teleport(dest_pos.x, dest_pos.y, dest_pos.z, yaw: mangle.y, pitch: 0.0)
+
+        forward = @player.forward_flat
+        @player.velocity = forward * 300.0
+        @player.instance_variable_set(:@fixangle, true)
+        @player.instance_variable_set(:@teleport_time, @game_time.to_f + 0.7)
+        @player_state.flags &= ~FL_ONGROUND
+        @player.on_ground = false
+      end
+
+      def spawn_teleport_fog(origin)
+        @particles&.teleport_splash(origin)
+        return unless @entities
+
+        fog = Entity.new("classname" => "teleport_fog", "origin" => vec3_string(origin))
+        fog.think_time = @game_time.to_f + 0.2
+        fog.instance_variable_set(:@think, :play_teleport)
+        @entities << fog
+        fog
+      end
+
+      def apply_telefrag_damage(origin)
+        teledeath = teledeath_entity(origin)
+        mins = origin + ENTITY_HULL_MINS - Math::Vec3.new(1.0, 1.0, 1.0)
+        maxs = origin + ENTITY_HULL_MAXS + Math::Vec3.new(1.0, 1.0, 1.0)
+
+        @entities.each do |ent|
+          next unless ent.damageable?
+          next if ent.health.to_f.zero?
+
+          ent_mins, ent_maxs = damageable_bounds(ent)
+          next unless ent_mins && ent_maxs
+          next unless aabb_intersect?(mins, maxs, ent_mins, ent_maxs)
+
+          if ent.classname == "player" && ent.invincible_finished.to_f > @game_time.to_f
+            if player_invincible_finished > @game_time.to_f
+              teledeath.classname = "teledeath3"
+              ent.invincible_finished = 0.0
+              clear_player_invincibility
+              damage_entity(ent, 50_000.0, attacker: teledeath, inflictor: teledeath)
+              teledeath.instance_variable_set(:@owner, ent)
+              @player_state.deathtype = "teledeath3"
+              damage_player(50_000.0, inflictor: teledeath)
+              next
+            end
+
+            teledeath.classname = "teledeath2"
+            @player_state.deathtype = "teledeath2"
+            damage_player(50_000.0, inflictor: teledeath)
+            next
+          end
+
+          damage_entity(ent, 50_000.0, attacker: teledeath, inflictor: teledeath)
+        end
+      end
+
+      def player_invincible_finished
+        @player_state&.powerup_finished&.fetch(:pentagram, 0.0).to_f
+      end
+
+      def clear_player_invincibility
+        @player_state&.powerup_finished&.delete(:pentagram)
+        @player_state&.powerup_warning_time&.delete(:pentagram)
+      end
+
+      def teledeath_entity(origin)
+        Entity.new("classname" => "teledeath", "origin" => "#{origin.x} #{origin.y} #{origin.z}").tap do |ent|
+          ent.instance_variable_set(:@owner, @player_state)
+          ent.instance_variable_set(:@movetype, MOVETYPE_NONE)
+          ent.instance_variable_set(:@solid, 1)
+        end
+      end
+
+      def hurt_trigger(trigger)
+        return unless player_takedamage?
+
+        damage_player(trigger_hurt_damage(trigger), pain_sound: true, inflictor: trigger)
+        trigger.instance_variable_set(:@touch_disabled, true)
+        trigger.instance_variable_set(:@solid, 0)
+        trigger.instance_variable_set(:@think, :hurt_on)
+        # hurt_touch re-arms 1s later; update_trigger_cooldown counts
+        # think_time down as a duration, so store the delay, not a time
+        trigger.think_time = 1.0
+      end
+
+      def player_takedamage?
+        return @player_state&.alive? unless @player
+
+        return @player_state&.alive? unless @player.instance_variable_defined?(:@takedamage)
+
+        @player.instance_variable_get(:@takedamage).to_i != 0
+      end
+
+      def trigger_hurt_damage(trigger)
+        dmg = trigger["dmg"].to_f
+        dmg.zero? ? 5.0 : dmg
+      end
+
+      def push_trigger(trigger)
+        if @player_state.alive?
+          @player.velocity = trigger_movedir(trigger) * trigger.speed * 10.0
+          @player.on_ground = false
+          if @player.instance_variable_get(:@fly_sound).to_f < @game_time
+            @player.instance_variable_set(:@fly_sound, @game_time + 1.5)
+            @sound_events&.on_trigger_push_player
+          end
+        end
+        trigger.instance_variable_set(:@removed, true) if (trigger.spawnflags & 1) != 0
+      end
+
+      # trigger_push_touch pushes grenades too: velocity = movedir*speed*10
+      def grenade_push_trigger_velocity(position)
+        (@entities || []).each do |trigger|
+          next unless trigger.classname == "trigger_push"
+          next if trigger.removed?
+          next unless trigger.model_index
+
+          model = @level&.models&.[](trigger.model_index)
+          next unless model
+          next unless position.x >= trigger.position.x + model.mins.x &&
+                      position.x <= trigger.position.x + model.maxs.x &&
+                      position.y >= trigger.position.y + model.mins.y &&
+                      position.y <= trigger.position.y + model.maxs.y &&
+                      position.z >= trigger.position.z + model.mins.z &&
+                      position.z <= trigger.position.z + model.maxs.z
+
+          velocity = trigger_movedir(trigger) * trigger.speed * 10.0
+          trigger.instance_variable_set(:@removed, true) if (trigger.spawnflags & 1) != 0
+          return velocity
+        end
+        nil
+      end
+
+      def trigger_movedir(trigger)
+        return trigger.move_dir if trigger.move_dir != Math::Vec3::ORIGIN
+        return trigger.forward_vector if trigger["angles"] && trigger["angles"].split.map(&:to_f) != [0.0, 0.0, 0.0]
+        return trigger.forward_vector if trigger["angle"] && trigger["angle"].to_f != 0.0
+
+        Math::Vec3::ORIGIN
+      end
+
+      def apply_environment_damage(dt = @view_frame_dt.to_f)
+        return if @player&.noclip
+        return if @player_state&.health&.negative?
+
+        apply_drowning
+        if @player.water_level.zero?
+          update_water_transition_sounds
+          return
+        end
+
+        if @game_time > (@environment_damage_time || 0.0)
+          case @player.water_type
+          when Physics::CONTENTS_LAVA
+            delay = biosuit_slows_lava_damage? ? 1.0 : 0.2
+            @environment_damage_time = @game_time + delay
+            damage_player(10.0 * @player.water_level)
+          when Physics::CONTENTS_SLIME
+            unless biosuit_blocks_slime_damage?
+              @environment_damage_time = @game_time + 1.0
+              damage_player(4.0 * @player.water_level)
+            end
+          end
+        end
+
+        update_water_transition_sounds
+        apply_water_velocity_drag(dt)
+      end
+
+      def update_water_transition_sounds
+        if @player.water_level.zero?
+          if @player_in_water
+            @sound_events&.on_player(:water_exit)
+            @player_in_water = false
+          end
+          return
+        end
+
+        return if @player_in_water
+
+        @player_in_water = true
+        case @player.water_type
+        when Physics::CONTENTS_LAVA
+          @sound_events&.on_player(:lava_enter)
+        when Physics::CONTENTS_SLIME
+          @sound_events&.on_player(:slime_enter)
+        when Physics::CONTENTS_WATER
+          @sound_events&.on_player(:water_enter)
+        end
+        @environment_damage_time = 0.0
+      end
+
+      def play_jump_sounds
+        return unless @keys[SDL::SCANCODE_SPACE]
+        return if @player_state && (@player_state.flags & PlayerState::FL_WATERJUMP) != 0
+
+        if @player.water_level >= 2
+          return unless (@swim_sound_finished || 0.0) < @game_time
+
+          @swim_sound_finished = @game_time + 1.0
+          @sound_events&.on_player(rand < 0.5 ? :swim1 : :swim2)
+          return
+        end
+
+        return unless @player.on_ground
+        return if (@player_state.flags & PlayerState::FL_JUMPRELEASED).zero?
+        return if @player.jump_held
+
+        @sound_events&.on_player(:jump)
+      end
+
+      def apply_fall_damage
+        return unless @player_state.alive?
+
+        if @jump_flag < -300.0 && @player.on_ground
+          if @player.water_type == Physics::CONTENTS_WATER
+            @sound_events&.on_player(:water_land)
+          elsif @jump_flag < -650.0
+            @player_state.deathtype = "falling"
+            damage_player(5)
+            @sound_events&.on_player(:land_hurt)
+          else
+            @sound_events&.on_player(:land)
+          end
+        end
+
+        @jump_flag = @player.velocity.z
+      end
+
+      def apply_drowning
+        if @player.water_level != 3
+          if @air_finished < @game_time
+            @sound_events&.on_player(:gasp_deep)
+          elsif @air_finished < @game_time + 9.0
+            @sound_events&.on_player(:gasp)
+          end
+          @air_finished = @game_time + 12.0
+          @drown_damage = 2.0
+          return
+        end
+
+        return unless @air_finished < @game_time
+        return unless @drown_pain_finished < @game_time
+
+        @drown_damage += 2.0
+        @drown_damage = 10.0 if @drown_damage > 15.0
+        result = damage_player(@drown_damage)
+        @sound_events&.on_player(rand > 0.5 ? :drown1 : :drown2) if result[:take].positive? && @player_state.alive?
+        @drown_pain_finished = @game_time + 1.0
+      end
+
+      def biosuit_blocks_slime_damage?
+        finished = @player_state.powerup_finished[:biosuit]
+        finished && finished >= @game_time
+      end
+
+      def biosuit_slows_lava_damage?
+        finished = @player_state.powerup_finished[:biosuit]
+        finished && finished > @game_time
+      end
+
+      def apply_water_velocity_drag(dt)
+        return if dt.to_f.zero?
+        return if (@player_state.flags & PlayerState::FL_WATERJUMP) != 0
+
+        scale = 1.0 - 0.8 * @player.water_level.to_f * dt.to_f
+        @player.velocity = @player.velocity * scale
+      end
+
+      def damage_player(amount, pain_sound: false, inflictor: nil, attacker: nil, apply_momentum: true)
+        if @player_state.invulnerable_to_damage?(game_time: @game_time) &&
+           (@invincible_sound_finished || 0.0) < @game_time
+          @invincible_sound_finished = @game_time + 2.0
+          @sound_events&.on_player(:pentagram_protect)
+        end
+
+        was_alive = @player_state.alive?
+        apply_player_direct_damage_momentum(amount, inflictor) if apply_momentum
+        result = @player_state.take_damage(amount, game_time: @game_time)
+        result = result.merge(display_take: (amount.to_f - result[:save].to_f).ceil)
+        trigger_damage_flash(result)
+        trigger_damage_kick(result, inflictor)
+        if was_alive && !@player_state.alive?
+          apply_player_obituary_frags(attacker || inflictor)
+          drop_player_powerups
+          drop_player_backpack
+          apply_player_death_state(inflictor: inflictor)
+          @player_state.clear_powerups_on_death
+          play_death_sound(attacker: attacker || inflictor)
+          select_player_death_animation
+          return result
+        end
+
+        if result[:take].positive?
+          select_player_pain_animation
+          if pain_sound
+            play_player_pain_sound(attacker: attacker || inflictor)
+          else
+            play_environment_pain_sound
+          end
+        end
+        result
+      end
+
+      def play_player_pain_sound(attacker: nil)
+        if attacker_classname(attacker) == "teledeath"
+          @sound_events&.on_player(:teledeath)
+          return
+        end
+
+        if @player&.water_type == Physics::CONTENTS_WATER && @player.water_level == 3
+          spawn_death_bubbles(1)
+          @sound_events&.on_player(rand > 0.5 ? :drown1 : :drown2)
+          return
+        end
+
+        case @player&.water_type
+        when Physics::CONTENTS_LAVA, Physics::CONTENTS_SLIME
+          @sound_events&.on_player(rand > 0.5 ? :burn1 : :burn2)
+        else
+          play_generic_pain_sound
+        end
+      end
+
+      def play_environment_pain_sound
+        case @player&.water_type
+        when Physics::CONTENTS_LAVA, Physics::CONTENTS_SLIME
+          @sound_events&.on_player(rand > 0.5 ? :burn1 : :burn2)
+        end
+      end
+
+      def play_generic_pain_sound
+        if (@pain_sound_finished || 0.0) > @game_time
+          @player&.instance_variable_set(:@axhitme, 0)
+          return
+        end
+
+        @pain_sound_finished = @game_time + 0.5
+        if @player&.instance_variable_get(:@axhitme).to_i == 1
+          @player.instance_variable_set(:@axhitme, 0)
+          @sound_events&.on_player(:axe_body_hit)
+          return
+        end
+
+        index = ((rand * 5.0) + 1.0).round
+        index = [[index, 1].max, 6].min
+        @sound_events&.on_player(:"pain#{index}")
+      end
+
+      def play_death_sound(attacker: nil)
+        if @player_state.health < -40
+          if %w[teledeath teledeath2].include?(attacker_classname(attacker)) ||
+             %w[teledeath teledeath2].include?(@player_state.deathtype)
+            @sound_events&.on_player(:teledeath)
+            return
+          end
+
+          @sound_events&.on_player(rand < 0.5 ? :gib : :udeath)
+          return
+        end
+
+        if @player&.water_level == 3
+          spawn_death_bubbles(5)
+          @sound_events&.on_player(:water_death)
+          return
+        end
+
+        index = ((rand * 4.0) + 1.0).round
+        index = [[index, 1].max, 5].min
+        @sound_events&.on_player(:"death#{index}")
+      end
+
+      def apply_player_obituary_frags(attacker)
+        if deathmatch.to_i > 3 && @player_state.deathtype == "selfwater"
+          @player_state.frags -= 1
+          return
+        end
+
+        if @player_state.deathtype == "squish"
+          apply_player_squish_obituary_frags(attacker)
+          return
+        end
+
+        case attacker_classname(attacker)
+        when "teledeath"
+          telefrag_owner(attacker)&.frags += 1
+        when "teledeath2", "teledeath3"
+          @player_state.frags -= 1
+        when "player"
+          apply_player_attacker_obituary_frags(attacker)
+        else
+          @player_state.frags -= 1
+        end
+      end
+
+      def apply_player_squish_obituary_frags(attacker)
+        if teamplay.to_i.nonzero? &&
+           !quake_info_key(attacker, "team").empty? &&
+           quake_info_key(attacker, "team") == quake_info_key(@player_state, "team") &&
+           !attacker.equal?(@player_state)
+          attacker.frags -= 1 if attacker.respond_to?(:frags=)
+        elsif attacker_classname(attacker) == "player" && !attacker.equal?(@player_state)
+          attacker.frags += 1 if attacker.respond_to?(:frags=)
+        else
+          @player_state.frags -= 1
         end
       end
+
+      def apply_player_attacker_obituary_frags(attacker)
+        if attacker.equal?(@player_state)
+          @player_state.frags -= 1
+        elsif teamplay.to_i == 2 &&
+              !quake_info_key(attacker, "team").empty? &&
+              quake_info_key(attacker, "team") == quake_info_key(@player_state, "team")
+          attacker.frags -= 1 if attacker.respond_to?(:frags=)
+        elsif attacker.respond_to?(:frags=)
+          attacker.frags += 1
+        end
+      end
+
+      def attacker_classname(attacker)
+        attacker.respond_to?(:classname) ? attacker.classname : ""
+      end
+
+      def telefrag_owner(attacker)
+        attacker.instance_variable_get(:@owner) if attacker&.instance_variable_defined?(:@owner)
+      end
+
+      def drop_player_backpack
+        return unless @player_state
+        return unless @player
+
+        ammo = @player_state.ammo
+        return unless ammo.values.sum.positive?
+
+        backpack = Entity.new("classname" => "item_backpack", "origin" => backpack_origin_string)
+        backpack.instance_variable_set(:@items, PLAYER_WEAPON_ITEM_BITS.fetch(@player_state.current_weapon, 0))
+        backpack.instance_variable_set(:@netname, PLAYER_WEAPON_NETNAMES.fetch(@player_state.current_weapon, ""))
+        backpack.instance_variable_set(:@ammo_shells, ammo[:shells])
+        backpack.instance_variable_set(:@ammo_nails, ammo[:nails])
+        backpack.instance_variable_set(:@ammo_rockets, ammo[:rockets])
+        backpack.instance_variable_set(:@ammo_cells, ammo[:cells])
+        backpack.velocity = Math::Vec3.new(-100.0 + rand * 200.0, -100.0 + rand * 200.0, 300.0)
+        backpack.flags = 256
+        backpack.instance_variable_set(:@solid, 1)
+        backpack.instance_variable_set(:@movetype, 6)
+        backpack.properties["model"] = "progs/backpack.mdl"
+        backpack.instance_variable_set(:@mins, Math::Vec3.new(-16.0, -16.0, 0.0))
+        backpack.instance_variable_set(:@maxs, Math::Vec3.new(16.0, 16.0, 56.0))
+        backpack.instance_variable_set(:@touch, :backpack_touch)
+        backpack.think_time = @game_time.to_f + 120.0
+        backpack.instance_variable_set(:@think, :sub_remove)
+        @entities << backpack if @entities
+        @item_pickups&.add_entity(backpack)
+        backpack
+      end
+
+      def drop_player_powerups
+        drop_player_powerup(
+          :quad,
+          "dq",
+          "item_artifact_super_damage",
+          "progs/quaddama.mdl",
+          "items/damage.wav",
+          :q_touch
+        )
+        drop_player_powerup(
+          :ring,
+          "dr",
+          "item_artifact_invisibility",
+          "progs/invisibl.mdl",
+          "items/inv1.wav",
+          :r_touch
+        )
+      end
+
+      def drop_player_powerup(powerup, world_key, classname, model, noise, touch)
+        return unless @player_state
+        return unless @player
+        return unless @entities
+        return unless world_info_enabled?(world_key)
+
+        finish_time = @player_state.powerup_finished[powerup]
+        return unless finish_time&.positive?
+
+        item = Entity.new("classname" => classname, "origin" => player_origin_string)
+        item.velocity = Math::Vec3.new(-100.0 + rand * 200.0, -100.0 + rand * 200.0, 300.0)
+        item.flags = 256
+        item.instance_variable_set(:@solid, 1)
+        item.instance_variable_set(:@movetype, MOVETYPE_TOSS)
+        item.properties["model"] = model
+        item.instance_variable_set(:@mins, Math::Vec3.new(-16.0, -16.0, -24.0))
+        item.instance_variable_set(:@maxs, Math::Vec3.new(16.0, 16.0, 32.0))
+        item.instance_variable_set(:@noise, noise)
+        item.instance_variable_set(:@cnt, finish_time.to_f)
+        item.instance_variable_set(:@touch, touch)
+        item.think_time = finish_time.to_f
+        item.instance_variable_set(:@think, :sub_remove)
+        @entities << item
+        @item_pickups&.add_entity(item)
+        item
+      end
+
+      def player_origin_string
+        origin = @player.position
+        "#{origin.x} #{origin.y} #{origin.z}"
+      end
+
+      def backpack_origin_string
+        origin = @player.position - Math::Vec3.new(0.0, 0.0, 24.0)
+        "#{origin.x} #{origin.y} #{origin.z}"
+      end
+
+      def player_eye_position
+        return @player.eye_position unless @player_state&.view_offset
+
+        @player.position + @player_state.view_offset
+      end
+
+      def sync_camera
+        # Mouse look is always active in this port. With +mlook Quake calls
+        # V_StopPitchDrift every frame (in_win.c IN_MouseMove), and the
+        # laststop == cl.time guard in V_StartPitchDrift then keeps the
+        # view from auto-centering while running forward.
+        stop_pitch_drift
+        drift_view_pitch
+        eye = player_eye_position
+        bob = @viewmodel ? @viewmodel.bob : 0.0
+        punch = current_weapon_punch_angle
+        @viewmodel_base_position = Math::Vec3.new(eye.x, eye.y, eye.z + bob)
+        camera_position = bound_view_origin(Math::Vec3.new(
+          eye.x + VIEW_ORIGIN_NUDGE,
+          eye.y + VIEW_ORIGIN_NUDGE,
+          eye.z + bob + VIEW_ORIGIN_NUDGE
+        ))
+        stair_offset = stair_smooth_offset
+        idle = current_view_idle_angles
+        @camera.position = Math::Vec3.new(
+          camera_position.x,
+          camera_position.y,
+          camera_position.z + stair_offset
+        )
+        @viewmodel_base_position = Math::Vec3.new(
+          @viewmodel_base_position.x,
+          @viewmodel_base_position.y,
+          @viewmodel_base_position.z + stair_offset
+        )
+        @camera.yaw = @player.yaw + idle.y + punch.y
+        damage_roll, pitch = current_damage_kick_angles
+        @camera.pitch = @player.pitch + pitch + idle.x + punch.x
+        @camera.roll = current_view_roll(damage_roll) + idle.z + punch.z
+      end
+
+      def bound_view_origin(origin)
+        player_origin = @player.position
+        Math::Vec3.new(
+          origin.x.clamp(player_origin.x - VIEW_BOUND_XY, player_origin.x + VIEW_BOUND_XY),
+          origin.y.clamp(player_origin.y - VIEW_BOUND_XY, player_origin.y + VIEW_BOUND_XY),
+          origin.z.clamp(player_origin.z + VIEW_BOUND_Z_MIN, player_origin.z + VIEW_BOUND_Z_MAX)
+        )
+      end
+
+      def stair_smooth_offset
+        oldz = @view_oldz.to_f
+        origin_z = @player.position.z
+        if @player.on_ground && origin_z - oldz > 0.0
+          oldz += [@view_frame_dt.to_f, 0.0].max * STAIR_SMOOTH_SPEED
+          oldz = origin_z if oldz > origin_z
+          oldz = origin_z - STAIR_SMOOTH_MAX if origin_z - oldz > STAIR_SMOOTH_MAX
+          @view_oldz = oldz
+          oldz - origin_z
+        else
+          @view_oldz = origin_z
+          0.0
+        end
+      end
+
+      def current_view_idle_angles
+        scale = @view_idle_scale.to_f
+        return Math::Vec3::ORIGIN if scale.zero?
+
+        time = @game_time.to_f
+        Math::Vec3.new(
+          scale * ::Math.sin(time * VIEW_IDLE_PITCH_CYCLE) * VIEW_IDLE_PITCH_LEVEL,
+          scale * ::Math.sin(time * VIEW_IDLE_YAW_CYCLE) * VIEW_IDLE_YAW_LEVEL,
+          scale * ::Math.sin(time * VIEW_IDLE_ROLL_CYCLE) * VIEW_IDLE_ROLL_LEVEL
+        )
+      end
+
+      def start_pitch_drift
+        return if @view_pitch_laststop.to_f == @game_time.to_f
+        return unless @view_pitch_nodrift || @view_pitch_velocity.to_f.zero?
+
+        @view_pitch_velocity = VIEW_CENTER_SPEED
+        @view_pitch_nodrift = false
+        @view_pitch_driftmove = 0.0
+      end
+
+      def stop_pitch_drift
+        @view_pitch_laststop = @game_time.to_f
+        @view_pitch_nodrift = true
+        @view_pitch_velocity = 0.0
+      end
+
+      def drift_view_pitch
+        return unless @player
+        unless @player.on_ground
+          @view_pitch_driftmove = 0.0
+          @view_pitch_velocity = 0.0
+          return
+        end
+
+        if @view_pitch_nodrift
+          if forward_move_pressed?
+            @view_pitch_driftmove = @view_pitch_driftmove.to_f + @view_frame_dt.to_f
+            start_pitch_drift if @view_pitch_driftmove > VIEW_CENTER_MOVE
+          else
+            @view_pitch_driftmove = 0.0
+          end
+          return
+        end
+
+        delta = @view_idealpitch.to_f - @player.pitch.to_f
+        if delta.zero?
+          @view_pitch_velocity = 0.0
+          return
+        end
+
+        move = @view_frame_dt.to_f * @view_pitch_velocity.to_f
+        @view_pitch_velocity = @view_pitch_velocity.to_f + @view_frame_dt.to_f * VIEW_CENTER_SPEED
+        if delta.positive?
+          if move > delta
+            @view_pitch_velocity = 0.0
+            move = delta
+          end
+          @player.instance_variable_set(:@pitch, @player.pitch + move)
+        else
+          if move > -delta
+            @view_pitch_velocity = 0.0
+            move = -delta
+          end
+          @player.instance_variable_set(:@pitch, @player.pitch - move)
+        end
+      end
+
+      def forward_move_pressed?
+        keys = @keys || {}
+        keys[SDL::SCANCODE_W] || keys[SDL::SCANCODE_S]
+      end
+
+      def viewmodel_camera
+        punch = current_weapon_punch_angle
+        idle = current_view_idle_angles
+
+        camera = Camera.new(
+          position: @viewmodel_base_position || (@camera.position - VIEW_ORIGIN_NUDGE_VECTOR),
+          yaw: @camera.yaw - punch.y - idle.y,
+          pitch: @camera.pitch - punch.x - idle.x,
+          fov: @camera.fov,
+          near: @camera.near,
+          far: @camera.far
+        )
+        camera.roll = @camera.roll - punch.z - idle.z
+        camera
+      end
+
+      def current_view_roll(damage_roll = 0.0)
+        return 80.0 if @player_state&.health.to_i <= 0
+
+        @player.instance_variable_get(:@roll).to_f + movement_view_roll + damage_roll.to_f
+      end
+
+      def movement_view_roll
+        quake_calc_roll(@player.velocity, @player.right)
+      end
+
+      def quake_calc_roll(velocity, right)
+        side = velocity.dot(right)
+        sign = side.negative? ? -1.0 : 1.0
+        side = side.abs
+        value = 2.0
+        side = if side < 200.0
+                 side * value / 200.0
+               else
+                 value
+               end
+        side * sign
+      end
+
+      def apply_player_death_state(inflictor: nil)
+        @player_state.weapon_model = ""
+        @player_state.view_offset = PlayerState::DEATH_VIEW_OFFSET
+        @player_state.deadflag = PlayerState::DEAD_DYING
+        @player_state.flags &= ~FL_ONGROUND
+        @player&.instance_variable_set(:@model, "progs/player.mdl")
+        @player&.instance_variable_set(:@solid, SOLID_NOT)
+        @player&.instance_variable_set(:@movetype, MOVETYPE_TOSS)
+        @player&.instance_variable_set(:@takedamage, 0)
+        @player&.instance_variable_set(:@touch, nil)
+        @player&.instance_variable_set(:@effects, 0)
+        @player.on_ground = false if @player
+        return apply_player_gib_state(inflictor: inflictor) if @player_state.health < -40
+        @player&.instance_variable_set(:@pitch, 0.0)
+        @player&.instance_variable_set(:@roll, 0.0)
+        return unless @player && @player.velocity.z < 10.0
+
+        @player.velocity = Math::Vec3.new(
+          @player.velocity.x,
+          @player.velocity.y,
+          @player.velocity.z + rand * 300.0
+        )
+      end
+
+      def apply_player_gib_state(inflictor: nil)
+        @player_state.view_offset = PlayerState::GIB_VIEW_OFFSET
+        @player_state.deadflag = PlayerState::DEAD_DEAD
+        @player&.instance_variable_set(:@movetype, MOVETYPE_BOUNCE)
+        return unless @player
+
+        @player.instance_variable_set(:@model, "progs/h_player.mdl")
+        @player.instance_variable_set(:@frame, 0)
+        @player.instance_variable_set(:@nextthink, -1)
+        @player.instance_variable_set(:@mins, Math::Vec3.new(-16.0, -16.0, 0.0))
+        @player.instance_variable_set(:@maxs, Math::Vec3.new(16.0, 16.0, 56.0))
+        @player.instance_variable_set(:@avelocity, Math::Vec3.new(0.0, crandom * 600.0, 0.0))
+        @player.velocity = gib_velocity_for_damage(@player_state.health, inflictor: inflictor)
+        @player.position = @player.position - Math::Vec3.new(0.0, 0.0, 24.0)
+        throw_player_gib("progs/gib1.mdl", inflictor: inflictor)
+        throw_player_gib("progs/gib2.mdl", inflictor: inflictor)
+        throw_player_gib("progs/gib3.mdl", inflictor: inflictor)
+      end
+
+      def select_player_death_animation
+        return unless @player && @player_state.health >= -40
+
+        frames = if @player_state.current_weapon == :axe
+                   PLAYER_DEATH_FRAMES.fetch(:axe)
+                 else
+                   PLAYER_DEATH_FRAMES.fetch(random_player_death_sequence)
+                 end
+        @player.instance_variable_set(:@death_animation_frames, frames)
+        @player.instance_variable_set(:@death_animation_index, 0)
+        @player.instance_variable_set(:@frame, frames.fetch(0))
+        @player.instance_variable_set(:@nextthink, @game_time.to_f + 0.1)
+      end
+
+      def random_player_death_sequence
+        forced_sequence = @temp1.to_i
+        sequence = forced_sequence.zero? ? 1 + (rand * 6.0).floor : forced_sequence
+        case sequence
+        when 1 then :a
+        when 2 then :b
+        when 3 then :c
+        when 4 then :d
+        else :e
+        end
+      end
+
+      def update_player_death_animation
+        return unless @player && @player_state
+        return unless @player_state.deadflag == PlayerState::DEAD_DYING
+
+        nextthink = @player.instance_variable_get(:@nextthink)
+        return unless nextthink && nextthink >= 0.0
+        return if nextthink > @game_time
+
+        frames = @player.instance_variable_get(:@death_animation_frames)
+        return unless frames && !frames.empty?
+
+        index = @player.instance_variable_get(:@death_animation_index).to_i + 1
+        index = frames.length - 1 if index >= frames.length
+        @player.instance_variable_set(:@death_animation_index, index)
+        @player.instance_variable_set(:@frame, frames.fetch(index))
+        if index == frames.length - 1
+          player_dead
+        else
+          @player.instance_variable_set(:@nextthink, @game_time.to_f + 0.1)
+        end
+      end
+
+      def player_dead
+        @player_state.deadflag = PlayerState::DEAD_DEAD
+        @player&.instance_variable_set(:@nextthink, -1)
+      end
+
+      def set_suicide_frame
+        return unless @player && @player_state
+        return unless @player.instance_variable_get(:@model) == "progs/player.mdl"
+
+        @player.instance_variable_set(:@frame, PLAYER_DEATHA11_FRAME)
+        @player.instance_variable_set(:@solid, SOLID_NOT)
+        @player.instance_variable_set(:@movetype, MOVETYPE_TOSS)
+        @player_state.deadflag = PlayerState::DEAD_DEAD
+        @player.instance_variable_set(:@nextthink, -1)
+      end
+
+      def client_kill
+        return unless @player && @player_state
+
+        set_suicide_frame
+        @player.instance_variable_set(:@model, "progs/player.mdl")
+        @player_state.frags -= 2
+        respawn_player
+      end
+
+      def update_player_control(dt, solid_brush)
+        return if @player_state.view_offset == Math::Vec3::ORIGIN
+
+        @player_state.deathtype = ""
+        if @player_state.deadflag >= PlayerState::DEAD_DEAD
+          player_death_think
+          return
+        end
+        return if @player_state.deadflag == PlayerState::DEAD_DYING
+
+        play_jump_sounds
+        apply_player_pausetime
+        @player.update(dt, @level, quake_player_movement_keys, brush_entities: solid_brush)
+        sync_water_jump_flag
+        apply_fall_damage
+        apply_environment_damage(dt)
+      end
+
+      # Mirror the physics player's FL_WATERJUMP state into the QuakeC-style
+      # player flags so jump sounds and water drag see it.
+      def sync_water_jump_flag
+        if @player.water_jump
+          @player_state.flags |= PlayerState::FL_WATERJUMP
+        else
+          @player_state.flags &= ~PlayerState::FL_WATERJUMP
+        end
+      end
+
+      def player_postthink_active?
+        @player_state.view_offset != Math::Vec3::ORIGIN &&
+          @player_state.deadflag == PlayerState::DEAD_NO
+      end
+
+      def apply_player_pausetime
+        return unless @game_time.to_f < @player.instance_variable_get(:@pausetime).to_f
+
+        @player.velocity = Math::Vec3::ORIGIN
+      end
+
+      def quake_player_movement_keys
+        keys = @keys || {}
+        keys = quake_jump_movement_keys(keys)
+        teleport_time = @player.instance_variable_get(:@teleport_time).to_f
+        return keys unless @game_time.to_f < teleport_time
+        return keys if keys[SDL::SCANCODE_W] || !keys[SDL::SCANCODE_S]
+
+        keys.merge(SDL::SCANCODE_S => false)
+      end
+
+      def quake_jump_movement_keys(keys)
+        return keys unless @player_state
+
+        jump_pressed = keys[SDL::SCANCODE_SPACE]
+        unless jump_pressed
+          @player_state.flags |= PlayerState::FL_JUMPRELEASED
+          return keys
+        end
+
+        return keys if @player.water_level >= 2
+        return keys unless @player.on_ground
+
+        if (@player_state.flags & PlayerState::FL_JUMPRELEASED).zero?
+          return keys.merge(SDL::SCANCODE_SPACE => false)
+        end
+
+        @player_state.flags &= ~PlayerState::FL_JUMPRELEASED
+        keys
+      end
+
+      def player_death_think
+        apply_player_death_friction if @player.on_ground
+        if @player_state.deadflag == PlayerState::DEAD_DEAD
+          return if player_death_button_down?
+
+          @player_state.deadflag = PlayerState::DEAD_RESPAWNABLE
+          return
+        end
+
+        return unless player_death_button_down?
+
+        @attack_pressed = false
+        @keys.delete(SDL::SCANCODE_SPACE) if defined?(SDL::SCANCODE_SPACE)
+        respawn_player
+      end
+
+      def respawn_player
+        copy_player_to_body_queue
+        @player_state.reset_to_new_parms
+        @attack_finished = @game_time
+        @air_finished = @game_time + 12.0
+        @drown_damage = 2.0
+        @drown_pain_finished = 0.0
+        @player_in_water = false
+        @jump_flag = 0.0
+
+        set_player_spawn_point(select_spawn_point)
+        @player.position = player_spawn_origin
+        @player.instance_variable_set(:@yaw, (@player_yaw || 0.0).to_f)
+        apply_put_client_in_server_spawn_effects
+        @player.velocity = Math::Vec3::ORIGIN
+        @player.on_ground = false
+        @player.water_level = 0
+        @player.water_type = Physics::CONTENTS_EMPTY
+        @player.instance_variable_set(:@fixangle, true)
+        @player.instance_variable_set(:@pitch, 0.0)
+        @player.instance_variable_set(:@roll, 0.0)
+        set_player_spawn_entity_state
+        @viewmodel&.set_weapon(@player_state.current_weapon_model)
+        sync_camera if @camera
+      end
+
+      def set_player_spawn_point(spot)
+        return unless spot
+
+        @player_start = spot&.position || Math::Vec3::ORIGIN
+        @player_yaw = spot ? spot.angles.y : 0.0
+      end
+
+      def player_spawn_origin
+        (@player_start || Math::Vec3::ORIGIN) + Math::Vec3.new(0.0, 0.0, 1.0)
+      end
+
+      # SelectSpawnPoint (client.qc): deathmatch spots only in deathmatch;
+      # single player uses info_player_start2 on episode returns
+      # (serverflags set), else info_player_start.
+      def select_spawn_point
+        test_start = @entities&.find { |ent| ent.classname == "testplayerstart" }
+        return test_start if test_start
+
+        if @deathmatch.to_i.positive?
+          deathmatch_spots = @entities&.select { |ent| ent.classname == "info_player_deathmatch" } || []
+          return select_deathmatch_spawn_point(deathmatch_spots) unless deathmatch_spots.empty?
+        end
+
+        if @player_state&.serverflags.to_i.positive?
+          episode_return = @entities&.find { |ent| ent.classname == "info_player_start2" }
+          return episode_return if episode_return
+        end
+
+        @entities&.find { |ent| ent.classname == "info_player_start" }
+      end
+
+      def select_deathmatch_spawn_point(spots)
+        open_spots = spots.select { |spot| player_count_near_spawn(spot).zero? }
+        return random_spawn_spot(spots) if open_spots.empty?
+
+        random_spawn_spot(open_spots.reverse)
+      end
+
+      def player_count_near_spawn(spot)
+        (@entities || []).count do |ent|
+          ent.classname == "player" && (ent.position - spot.position).length <= 84.0
+        end
+      end
+
+      def random_spawn_spot(spots)
+        return nil if spots.empty?
+
+        index = (rand * (spots.length - 1)).round
+        spots.fetch(index)
+      end
+
+      def set_player_spawn_entity_state
+        @player.instance_variable_set(:@model, "progs/player.mdl")
+        frames = @player_state.current_weapon == :axe ? PLAYER_STAND_FRAMES.fetch(:axe) : PLAYER_STAND_FRAMES.fetch(:normal)
+        @player.instance_variable_set(:@frame, frames.fetch(0))
+        @player.instance_variable_set(:@walkframe, 1)
+        @player.instance_variable_set(:@weaponframe, 0)
+        @player.instance_variable_set(:@solid, SOLID_SLIDEBOX)
+        @player.instance_variable_set(:@movetype, MOVETYPE_WALK)
+        @player.instance_variable_set(:@takedamage, DAMAGE_AIM)
+        @player.instance_variable_set(:@effects, 0)
+        @player.instance_variable_set(:@pausetime, 0.0)
+        @player.instance_variable_set(:@mins, ENTITY_HULL_MINS)
+        @player.instance_variable_set(:@maxs, ENTITY_HULL_MAXS)
+        @player.instance_variable_set(:@nextthink, nil)
+        @player.instance_variable_set(:@death_animation_frames, nil)
+        @player.instance_variable_set(:@pain_animation_frames, nil)
+      end
+
+      def apply_put_client_in_server_spawn_effects
+        yaw = (@player_yaw || 0.0).to_f
+        spawn_teleport_fog(@player.position + angle_forward(Math::Vec3.new(0.0, yaw, 0.0)) * 20.0)
+        apply_spawn_telefrag_damage(@player.position)
+        apply_world_spawn_modifiers
+        apply_deathmatch_spawn_parms if @player_state.alive?
+      end
+
+      def apply_world_spawn_modifiers
+        world_rj = world_info_value("rj")
+        @rj = world_rj.to_f if world_rj && world_rj.to_f.nonzero?
+      end
+
+      def apply_deathmatch_spawn_parms
+        case deathmatch.to_i
+        when 4
+          @player_state.health = 250
+          @player_state.armor = 200
+          @player_state.armor_type = 3
+          @player_state.ammo[:shells] = 0
+          if !deathmatch_four_axe_mode?
+            @player_state.ammo[:shells] = 255
+            @player_state.ammo[:nails] = 255
+            @player_state.ammo[:rockets] = 255
+            @player_state.ammo[:cells] = 255
+            @player_state.weapons_owned.merge(
+              %i[nailgun super_nailgun super_shotgun rocket_launcher lightning_gun]
+            )
+          end
+          @player_state.add_powerup(:pentagram, game_time: @game_time, finish_time: @game_time.to_f + 3.0)
+        when 5
+          @player_state.health = 200
+          @player_state.armor = 200
+          @player_state.armor_type = 3
+          @player_state.ammo[:shells] = 30
+          @player_state.ammo[:nails] = 80
+          @player_state.ammo[:rockets] = 10
+          @player_state.ammo[:cells] = 30
+          @player_state.weapons_owned.merge(
+            %i[nailgun super_nailgun super_shotgun rocket_launcher grenade_launcher lightning_gun]
+          )
+          @player_state.add_powerup(:pentagram, game_time: @game_time, finish_time: @game_time.to_f + 3.0)
+        end
+      end
+
+      def deathmatch_four_axe_mode?
+        axe.to_f.nonzero? || world_info_enabled?("axe")
+      end
+
+      def apply_spawn_telefrag_damage(origin)
+        apply_telefrag_damage(origin)
+      end
+
+      def copy_player_to_body_queue
+        initialize_body_queue
+        body = @body_queue.fetch(@body_queue_index)
+        body.angles = Math::Vec3.new(@player.pitch, @player.yaw, @player.instance_variable_get(:@roll).to_f)
+        body.properties["model"] = @player.instance_variable_get(:@model).to_s
+        body.model_index = player_model_index
+        body.frame = @player.instance_variable_get(:@frame).to_i
+        body.instance_variable_set(:@colormap, @player.instance_variable_get(:@colormap))
+        body.instance_variable_set(:@movetype, @player.instance_variable_get(:@movetype))
+        body.velocity = @player.velocity
+        body.flags = 0
+        body.position = @player.position
+        body.instance_variable_set(:@mins, @player.instance_variable_get(:@mins))
+        body.instance_variable_set(:@maxs, @player.instance_variable_get(:@maxs))
+        @body_queue_index = (@body_queue_index + 1) % @body_queue.length
+        body
+      end
+
+      def player_model_index
+        return @player.model_index if @player.respond_to?(:model_index)
+
+        @player.instance_variable_get(:@model_index)
+      end
+
+      def initialize_body_queue
+        return if @body_queue && @body_queue.all? { |body| @entities&.include?(body) }
+
+        @body_queue = 4.times.map { Entity.new("classname" => "bodyque") }
+        @body_queue.each_with_index do |body, index|
+          body.instance_variable_set(:@owner, @body_queue[(index + 1) % @body_queue.length])
+        end
+        @body_queue_index = 0
+        @entities ||= []
+        @entities.concat(@body_queue)
+      end
+
+      def apply_player_death_friction
+        speed = @player.velocity.length - 20.0
+        @player.velocity = if speed <= 0.0
+                             Math::Vec3::ORIGIN
+                           else
+                             @player.velocity.normalize * speed
+                           end
+      end
+
+      def player_death_button_down?
+        @attack_pressed || (@keys || {})[SDL::SCANCODE_SPACE]
+      end
+
+      def select_player_pain_animation
+        return unless @player && @player_state
+        return unless @player_state.deadflag == PlayerState::DEAD_NO
+        return if @player.instance_variable_get(:@weaponframe).to_i.positive?
+        return if @player_state.powerup_active?(:ring, game_time: @game_time)
+
+        frames = if @player_state.current_weapon == :axe
+                   PLAYER_PAIN_FRAMES.fetch(:axe)
+                 else
+                   PLAYER_PAIN_FRAMES.fetch(:normal)
+                 end
+        @player.instance_variable_set(:@pain_animation_frames, frames)
+        @player.instance_variable_set(:@pain_animation_index, 0)
+        @player.instance_variable_set(:@frame, frames.fetch(0))
+        @player.instance_variable_set(:@weaponframe, 0)
+        @player.instance_variable_set(:@pain_nextthink, @game_time.to_f + 0.1)
+      end
+
+      def update_player_pain_animation
+        return unless @player && @player_state
+        return unless @player_state.deadflag == PlayerState::DEAD_NO
+
+        nextthink = @player.instance_variable_get(:@pain_nextthink)
+        return unless nextthink
+        return if nextthink > @game_time
+
+        frames = @player.instance_variable_get(:@pain_animation_frames)
+        return unless frames && !frames.empty?
+
+        index = @player.instance_variable_get(:@pain_animation_index).to_i + 1
+        if index >= frames.length
+          @player.instance_variable_set(:@pain_animation_frames, nil)
+          @player.instance_variable_set(:@pain_animation_index, nil)
+          @player.instance_variable_set(:@pain_nextthink, nil)
+          return
+        end
+
+        @player.instance_variable_set(:@pain_animation_index, index)
+        @player.instance_variable_set(:@frame, frames.fetch(index))
+        @player.instance_variable_set(:@pain_nextthink, @game_time.to_f + 0.1)
+      end
+
+      def gib_velocity_for_damage(damage, inflictor: nil)
+        velocity = if moving_damage_inflictor?(inflictor)
+                     base = inflictor.velocity * 0.5
+                     push = (@player.position - inflictor.position).normalize * 25.0
+                     velocity = base + push
+                     z = 100.0 + 240.0 * rand
+                     Math::Vec3.new(velocity.x + 200.0 * crandom, velocity.y + 200.0 * crandom, z)
+                   else
+                     Math::Vec3.new(100.0 * crandom, 100.0 * crandom, 200.0 + 100.0 * rand)
+                   end
+        scale = if damage > -50
+                  0.7
+                elsif damage > -200
+                  2.0
+                else
+                  10.0
+                end
+        velocity * scale
+      end
+
+      def moving_damage_inflictor?(inflictor)
+        @player && inflictor&.respond_to?(:velocity) && inflictor.respond_to?(:position) &&
+          inflictor.velocity.length.positive?
+      end
+
+      def throw_player_gib(model, inflictor: nil)
+        return unless @entities && @player_state && @player
+
+        gib = Entity.new("origin" => vec3_string(@player.position), "model" => model)
+        gib.instance_variable_set(:@mins, Math::Vec3::ORIGIN)
+        gib.instance_variable_set(:@maxs, Math::Vec3::ORIGIN)
+        gib.velocity = gib_velocity_for_damage(@player_state.health, inflictor: inflictor)
+        gib.instance_variable_set(:@movetype, MOVETYPE_BOUNCE)
+        gib.instance_variable_set(:@solid, SOLID_NOT)
+        gib.instance_variable_set(:@avelocity, Math::Vec3.new(rand * 600.0, rand * 600.0, rand * 600.0))
+        gib.think_time = @game_time.to_f + 10.0 + rand * 10.0
+        gib.frame = 0
+        gib.flags = 0
+        gib.instance_variable_set(:@think, :sub_remove)
+        @entities << gib
+        gib
+      end
+
+      def spawn_death_bubbles(count)
+        return unless @entities && @player
+
+        spawner = Entity.new("origin" => vec3_string(@player.position))
+        spawner.instance_variable_set(:@movetype, MOVETYPE_NONE)
+        spawner.instance_variable_set(:@solid, SOLID_NOT)
+        spawner.think_time = @game_time.to_f + 0.1
+        spawner.instance_variable_set(:@think, :death_bubbles_spawn)
+        spawner.instance_variable_set(:@air_finished, 0)
+        spawner.instance_variable_set(:@owner, @player)
+        spawner.instance_variable_set(:@bubble_count, count)
+        @entities << spawner
+        spawner
+      end
+
+      def spawn_death_bubble(owner)
+        spawn_bubble(
+          origin: owner.position + Math::Vec3.new(0.0, 0.0, 24.0),
+          velocity: Math::Vec3.new(0.0, 0.0, 15.0),
+          frame: 0,
+          cnt: 0,
+          waterlevel: owner.water_level,
+          touch: nil
+        )
+      end
+
+      def spawn_bubble(origin:, velocity:, frame:, cnt:, waterlevel: 0, touch: :bubble_remove)
+        bubble = Entity.new(
+          "classname" => "bubble",
+          "origin" => vec3_string(origin),
+          "model" => "progs/s_bubble.spr"
+        )
+        bubble.instance_variable_set(:@movetype, MOVETYPE_NOCLIP)
+        bubble.instance_variable_set(:@solid, SOLID_NOT)
+        bubble.velocity = velocity
+        bubble.think_time = @game_time.to_f + 0.5
+        bubble.instance_variable_set(:@think, :bubble_bob)
+        bubble.instance_variable_set(:@touch, touch)
+        bubble.frame = frame
+        bubble.instance_variable_set(:@cnt, cnt)
+        bubble.instance_variable_set(:@waterlevel, waterlevel.to_i)
+        bubble.instance_variable_set(:@mins, Math::Vec3.new(-8.0, -8.0, -8.0))
+        bubble.instance_variable_set(:@maxs, Math::Vec3.new(8.0, 8.0, 8.0))
+        @entities << bubble
+        bubble
+      end
+
+      def update_death_bubble_spawner(ent)
+        return if ent.think_time > @game_time
+
+        owner = ent.instance_variable_get(:@owner)
+        return unless owner&.water_level == 3
+
+        spawn_death_bubble(owner)
+        ent.think_time = @game_time.to_f + 0.1
+        ent.instance_variable_set(:@think, :death_bubbles_spawn)
+        air_finished = ent.instance_variable_get(:@air_finished).to_i + 1
+        ent.instance_variable_set(:@air_finished, air_finished)
+        if air_finished >= ent.instance_variable_get(:@bubble_count).to_i
+          ent.instance_variable_set(:@removed, true)
+        end
+      end
+
+      def update_bubble_bob(ent)
+        return if ent.think_time > @game_time
+
+        cnt = ent.instance_variable_get(:@cnt).to_i + 1
+        ent.instance_variable_set(:@cnt, cnt)
+        if cnt == 4
+          waterlevel = ent.instance_variable_get(:@waterlevel).to_i
+          spawn_bubble(origin: ent.position, velocity: ent.velocity, frame: 1, cnt: 10, waterlevel: waterlevel)
+          ent.frame = 1
+          ent.instance_variable_set(:@cnt, 10)
+          ent.instance_variable_set(:@removed, true) if waterlevel != 3
+        end
+        if ent.instance_variable_get(:@cnt).to_i == 20
+          ent.instance_variable_set(:@removed, true)
+        end
+
+        rnd1 = ent.velocity.x + (-10.0 + rand * 20.0)
+        rnd2 = ent.velocity.y + (-10.0 + rand * 20.0)
+        rnd3 = ent.velocity.z + 10.0 + rand * 10.0
+        rnd1 = 5.0 if rnd1 > 10.0
+        rnd1 = -5.0 if rnd1 < -10.0
+        rnd2 = 5.0 if rnd2 > 10.0
+        rnd2 = -5.0 if rnd2 < -10.0
+        rnd3 = 15.0 if rnd3 < 10.0
+        rnd3 = 25.0 if rnd3 > 30.0
+        ent.velocity = Math::Vec3.new(rnd1, rnd2, rnd3)
+        ent.think_time = @game_time.to_f + 0.5
+        ent.instance_variable_set(:@think, :bubble_bob)
+      end
+
+      def update_temporary_entities
+        @temporary_beams&.reject! { |beam| beam.end_time < @game_time.to_f }
+        return unless @entities
+
+        @entities.each do |ent|
+          next if ent.removed?
+          case ent.instance_variable_get(:@think)
+          when :play_teleport
+            next if ent.think_time > @game_time
+
+            @sound_events&.on_teleport_fog(teleport_fog_sound)
+            ent.instance_variable_set(:@removed, true)
+            next
+          when :death_bubbles_spawn
+            update_death_bubble_spawner(ent)
+            next
+          when :bubble_bob
+            update_bubble_bob(ent)
+            next
+          end
+
+          next unless ent.instance_variable_get(:@think) == :sub_remove
+          next if ent.think_time > @game_time
+
+          ent.instance_variable_set(:@removed, true)
+        end
+      end
+
+      def teleport_fog_sound
+        index = (rand * 5.0).floor + 1
+        index = [[index, 1].max, 5].min
+        "misc/r_tele#{index}.wav"
+      end
+
+      def vec3_string(vec)
+        "#{vec.x} #{vec.y} #{vec.z}"
+      end
+
+      def vec3_property(ent, key)
+        raw = ent[key]
+        return Math::Vec3::ORIGIN unless raw
+
+        parts = raw.split.first(3).map(&:to_f)
+        parts << 0.0 while parts.length < 3
+        Math::Vec3.new(parts[0], parts[1], parts[2])
+      end
+
+      def check_powerup_warnings
+        return if @player_state.health <= 0
+
+        play_ring_idle_sound
+        POWERUP_EXPIRING_EVENTS.each do |powerup, event|
+          finished = @player_state.powerup_finished[powerup]
+          next unless finished
+          next unless finished < @game_time + 3.0
+
+          warning_time = @player_state.powerup_warning_time[powerup].to_f
+          if warning_time == 1.0
+            @player_state.powerup_warning_time[powerup] = @game_time.to_f + 1.0
+            sprint(powerup_expiring_message(powerup))
+            trigger_bonus_flash
+            @sound_events&.on_player(event)
+          elsif warning_time < @game_time
+            @player_state.powerup_warning_time[powerup] = @game_time.to_f + 1.0
+            trigger_bonus_flash
+          end
+        end
+      end
+
+      # client.qc CheckPowerups sprints; deathmatch 4 renames the quad to
+      # OctaPower.
+      def powerup_expiring_message(powerup)
+        return "OctaPower is wearing off" if powerup == :quad && @deathmatch.to_i == 4
+
+        POWERUP_EXPIRING_MESSAGES[powerup]
+      end
+
+      def play_ring_idle_sound
+        return unless @player_state.powerup_finished[:ring]
+        return unless (@ring_idle_sound_finished || 0.0) < @game_time
+
+        @ring_idle_sound_finished = @game_time + (rand * 3.0) + 1.0
+        @sound_events&.on_player(:ring_idle)
+      end
+
+      def refresh_biosuit_air
+        return unless @player_state.powerup_finished[:biosuit]
+
+        @air_finished = @game_time + 12.0
+      end
+
+      def update_player_powerup_visual_state
+        return unless @player && @player_state
+        return if @player_state.health <= 0
+
+        if @player_state.powerup_finished[:ring]
+          @player.instance_variable_set(:@model, "progs/eyes.mdl")
+          @player.instance_variable_set(:@frame, 0)
+        else
+          @player.instance_variable_set(:@model, "progs/player.mdl")
+        end
+      end
+
+      def update_player_powerups
+        apply_deathmatch_four_quad_expiry
+        @player_state.update_powerups(@game_time)
+      end
+
+      def apply_deathmatch_four_quad_expiry
+        return unless deathmatch.to_i == 4
+
+        finished = @player_state.powerup_finished[:quad]
+        return unless finished && finished < @game_time.to_f
+
+        @player_state.ammo[:cells] = 255
+        @player_state.armor = 1
+        @player_state.armor_type = 3
+        @player_state.health = 100
+      end
+
+      def check_no_ammo_weapon_switch
+        return unless @player_state.alive?
+        return unless @game_time > @attack_finished
+        return if @player_state.current_weapon == :axe
+        return unless @player_state.current_ammo_count.to_i.zero?
+
+        previous = @player_state.current_weapon
+        @player_state.switch_to_best_weapon(water_level: @player&.water_level.to_i)
+        @viewmodel&.set_weapon(@player_state.current_weapon_model) if @player_state.current_weapon != previous
+      end
+
+      def fire_weapon
+        return unless @player_state.alive?
+        return if @game_time.to_f < @attack_finished.to_f
+
+        play_quad_attack_sound
+
+        if lightning_underwater_discharge?
+          mark_player_show_hostile
+          return if fire_lightning_underwater_discharge
+        end
+
+        event = @player_state.fire_current_weapon(water_level: @player.water_level, deathmatch: deathmatch)
+        return unless event
+
+        mark_player_show_hostile
+        @attack_finished = @game_time + @player_state.current_weapon_cooldown
+        trigger_weapon_punch(event)
+        play_weapon_fire_sound(event)
+        @viewmodel&.play_attack(viewmodel_attack_frames(event))
+        add_muzzle_flash_dynamic_light unless event.kind == :axe
+        case event.kind
+        when :axe
+          fire_axe(event)
+        when :spike
+          fire_spike(event)
+        when :rocket
+          fire_rocket(event)
+        when :lightning
+          fire_lightning(event)
+        when :grenade
+          fire_grenade(event)
+        else
+          fire_bullets(event)
+        end
+      end
+
+      def viewmodel_attack_frames(event)
+        return event.animation_frames unless event.weapon == :axe
+
+        r = rand
+        if r < 0.25
+          1..4
+        elsif r < 0.5
+          5..8
+        elsif r < 0.75
+          1..4
+        else
+          5..8
+        end
+      end
+
+      def mark_player_show_hostile
+        @player_state.show_hostile = @game_time.to_f + 1.0
+      end
+
+      def play_quad_attack_sound
+        return unless @player_state.powerup_active?(:quad, game_time: @game_time)
+        return unless (@quad_attack_sound_finished || 0.0) < @game_time
+
+        @quad_attack_sound_finished = @game_time + 1.0
+        @sound_events&.on_player(:quad_attack)
+      end
+
+      def lightning_underwater_discharge?
+        @player_state.current_weapon == :lightning_gun &&
+          @player.water_level > 1 &&
+          @player_state.can_fire_current_weapon?
+      end
+
+      def fire_lightning_underwater_discharge
+        if deathmatch.to_i > 3 && rand <= 0.5
+          @player_state.deathtype = "selfwater"
+          damage_player(4000.0, inflictor: @player)
+          return false
+        end
+
+        cells = @player_state.ammo[:cells]
+        @player_state.ammo[:cells] = 0
+        @attack_finished = @game_time + @player_state.current_weapon_cooldown
+        play_lightning_start_sound
+        @viewmodel&.play_attack(PlayerState::WEAPON_FIRE.dig(:lightning_gun, :animation_frames))
+        apply_radius_damage(@player.position, 35.0 * cells, inflictor: @player)
+        true
+      end
+
+      def play_weapon_fire_sound(event)
+        if event.kind == :lightning
+          play_lightning_weapon_sounds
+        else
+          @sound_events&.on_weapon_fire(event)
+        end
+      end
+
+      def play_lightning_weapon_sounds
+        play_lightning_start_sound
+
+        return unless (@lightning_hit_sound_finished || 0.0) < @game_time
+
+        @lightning_hit_sound_finished = @game_time + 0.6
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: "weapons/lhit.wav"))
+      end
+
+      def play_lightning_start_sound
+        if (@lightning_attack_active_until || 0.0) < @game_time
+          @sound_events&.on_weapon_fire(WeaponSound.new(sound: "weapons/lstart.wav"))
+        end
+        @lightning_attack_active_until = @game_time + 0.2
+      end
+
+      def fire_axe(event)
+        src = Math::Vec3.new(@player.position.x, @player.position.y, @player.position.z + 16.0)
+        dir = @player.forward
+        solid_brush = @entities.select(&:brush_entity?)
+        trace = Physics::HullTrace.trace_world_and_entities(
+          @level, src, src + dir * event.range, solid_brush, hull_num: 0
+        )
+        entity_hit = trace_axe_touch_entity(src, dir, event.range * trace.fraction)
+        if entity_hit
+          ent, hit_pos = entity_hit
+          impact = hit_pos - dir * 4.0
+          if ent.damageable?
+            ent.instance_variable_set(:@axhitme, 1)
+            damage = deathmatch.to_i > 3 ? 75 : event.damage
+            damage_entity(ent, player_damage(damage), attacker: @player_state, inflictor: @player)
+            @particles&.blood(impact, count: 20)
+          else
+            @sound_events&.on_player(:axe_wall_hit)
+            @particles&.gunshot(impact, count: 3)
+          end
+          return
+        end
+
+        return if trace.fraction >= 1.0
+
+        impact = trace.end_pos - dir * 4.0
+        @sound_events&.on_player(:axe_wall_hit)
+        @particles&.gunshot(impact, count: 3)
+      end
+
+      def fire_spike(event)
+        @projectiles ||= []
+        offset = spike_lateral_offset(event.weapon)
+        @projectiles << Projectile.new(
+          kind: event.weapon == :super_nailgun ? :super_spike : :spike,
+          position: @player.position + Math::Vec3.new(0.0, 0.0, 16.0) + @player.right * offset,
+          velocity: @player.forward * 1000.0,
+          damage: event.damage,
+          damage_variance: event.damage_variance,
+          radius_damage: event.radius_damage,
+          explode_at: @game_time + SPIKE_LIFETIME,
+          model: event.weapon == :super_nailgun ? "progs/s_spike.mdl" : "progs/spike.mdl",
+          movetype: 9,
+          solid: 2,
+          effects: 0,
+          angles: projectile_angles_from_velocity(@player.forward * 1000.0),
+          avelocity: Math::Vec3::ORIGIN,
+          voided: false,
+          owner: @player_state
+        )
+      end
+
+      def fire_rocket(event)
+        @projectiles ||= []
+        @projectiles << Projectile.new(
+          kind: :rocket,
+          position: @player.position + @player.forward * 8.0 + Math::Vec3.new(0.0, 0.0, 16.0),
+          velocity: @player.forward * 1000.0,
+          damage: event.damage,
+          damage_variance: event.damage_variance,
+          radius_damage: event.radius_damage,
+          explode_at: @game_time + ROCKET_LIFETIME,
+          model: "progs/missile.mdl",
+          movetype: 9,
+          solid: 2,
+          effects: 0,
+          angles: projectile_angles_from_velocity(@player.forward * 1000.0),
+          avelocity: Math::Vec3::ORIGIN,
+          voided: false,
+          owner: @player_state
+        )
+      end
+
+      def fire_lightning(event)
+        return unless @level
+
+        src = @player.position + Math::Vec3.new(0.0, 0.0, 16.0)
+        dir = @player.forward
+        solid_brush = @entities.select(&:brush_entity?)
+        trace = Physics::HullTrace.trace_world_and_entities(
+          @level, src, src + dir * event.range, solid_brush, hull_num: 0
+        )
+        spawn_temp_lightning_beam(
+          entity: VIEW_ENTITY,
+          start: src,
+          finish: trace.end_pos,
+          model: "progs/bolt2.mdl"
+        )
+        lightning_damage(@player.position, trace.end_pos + dir * 4.0, event.damage)
+      end
+
+      def spawn_temp_lightning_beam(entity:, start:, finish:, model:)
+        @temporary_beams ||= []
+        beam = TemporaryBeam.new(
+          entity: entity,
+          model: model,
+          end_time: @game_time.to_f + 0.2,
+          start: start,
+          finish: finish
+        )
+        index = @temporary_beams.find_index { |existing| existing.entity == entity }
+        index ||= @temporary_beams.find_index { |existing| existing.end_time < @game_time.to_f }
+        if index
+          @temporary_beams[index] = beam
+        elsif @temporary_beams.size < MAX_BEAMS
+          @temporary_beams << beam
+        end
+        beam
+      end
+
+      def lightning_damage(src, dst, damage)
+        dir = (dst - src).normalize
+        side = quake_lightning_side_offset(dir)
+        offsets = [
+          Math::Vec3::ORIGIN,
+          side,
+          side * -1.0
+        ]
+        trace_entities = []
+
+        offsets.each_with_index do |offset, index|
+          hit = trace_lightning_damage(src + offset, dst + offset)
+          next unless hit
+
+          ent, hit_pos = hit
+          next if trace_entities.include?(ent)
+
+          trace_entities << ent
+          next unless ent.damageable?
+
+          damage_entity(ent, player_damage(damage), attacker: @player_state, inflictor: @player)
+          apply_direct_lightning_player_kick(ent) if index.zero?
+          @particles&.lightning_blood(hit_pos)
+        end
+      end
+
+      def apply_direct_lightning_player_kick(ent)
+        return unless ent.classname == "player"
+
+        ent.velocity = Math::Vec3.new(ent.velocity.x, ent.velocity.y, ent.velocity.z + 400.0)
+      end
+
+      def quake_lightning_side_offset(dir)
+        # QuakeC LightningDamage mutates f_x before assigning f_y, so both
+        # horizontal side-offset components use the negated original y value.
+        component = -dir.y
+        Math::Vec3.new(component, component, 0.0) * 16.0
+      end
+
+      def trace_lightning_damage(src, dst)
+        dir = (dst - src).normalize
+        solid_brush = @entities.select(&:brush_entity?)
+        trace = Physics::HullTrace.trace_world_and_entities(
+          @level, src, dst, solid_brush, hull_num: 0
+        )
+        trace_lightning_touch_entity(src, dir, (dst - src).length * trace.fraction)
+      end
+
+      def fire_grenade(event)
+        @projectiles ||= []
+        velocity = if @player.pitch.zero?
+                     @player.forward_flat * 600.0 + Math::Vec3.new(0.0, 0.0, 200.0)
+                   else
+                     @player.forward * 600.0 + @player.up * 200.0 +
+                       @player.right * (crandom * 10.0) + @player.up * (crandom * 10.0)
+                   end
+
+        @projectiles << Projectile.new(
+          kind: :grenade,
+          position: @player.position,
+          velocity: velocity,
+          damage: event.damage,
+          damage_variance: event.damage_variance,
+          radius_damage: event.radius_damage,
+          explode_at: @game_time + GRENADE_FUSE,
+          model: "progs/grenade.mdl",
+          movetype: 10,
+          solid: 2,
+          effects: 0,
+          angles: projectile_angles_from_velocity(velocity),
+          avelocity: Math::Vec3.new(300.0, 300.0, 300.0),
+          voided: false,
+          owner: @player_state
+        )
+        return unless deathmatch.to_i == 4
+
+        @attack_finished = @game_time.to_f + 1.1
+        damage_player(10.0, inflictor: @player)
+      end
+
+      def update_triggered_misc_entities
+        @entities.each do |ent|
+          case ent.classname
+          when "trap_spikeshooter", "trap_shooter"
+            if ent.instance_variable_get(:@triggered)
+              ent.instance_variable_set(:@triggered, false)
+              fire_spikeshooter(ent)
+            end
+            update_trap_shooter(ent) if ent.classname == "trap_shooter"
+          when "fireball"
+            update_fireball_emitter(ent) if ent.instance_variable_get(:@fireball_emitter)
+          when "misc_noisemaker"
+            update_noisemaker(ent)
+          end
+        end
+      end
+
+      def setup_misc_entities
+        @entities.each do |ent|
+          case ent.classname
+          when "trap_spikeshooter"
+            setup_trap_spikeshooter(ent)
+          when "trap_shooter"
+            setup_trap_spikeshooter(ent)
+            ent.wait = 1.0 if ent.wait.zero?
+            ent.think_time = @game_time + ent["nextthink"].to_f + ent.wait
+            ent.instance_variable_set(:@think, :shooter_think)
+          when "misc_fireball"
+            setup_fireball_emitter(ent)
+          when "misc_noisemaker"
+            setup_noisemaker(ent)
+          when "misc_explobox", "misc_explobox2"
+            setup_explobox(ent)
+          when "viewthing"
+            setup_viewthing(ent)
+          when "light_globe", "light_torch_small_walltorch",
+               "light_flame_large_yellow", "light_flame_small_yellow",
+               "light_flame_small_white"
+            setup_static_light_model(ent)
+          when "item_key1", "item_key2"
+            setup_key_item(ent)
+          when "item_sigil"
+            setup_sigil_item(ent)
+          when "item_artifact_invulnerability", "item_artifact_envirosuit",
+               "item_artifact_invisibility", "item_artifact_super_damage"
+            setup_powerup_item(ent)
+          when "item_health"
+            setup_health_item(ent)
+          when "item_armor1", "item_armor2", "item_armorInv"
+            setup_armor_item(ent)
+          when "item_shells", "item_spikes", "item_rockets", "item_cells", "item_weapon"
+            setup_ammo_item(ent)
+          when "weapon_supershotgun", "weapon_nailgun", "weapon_supernailgun",
+               "weapon_grenadelauncher", "weapon_rocketlauncher", "weapon_lightning"
+            setup_weapon_item(ent)
+          when "info_null", "air_bubbles", "noclass", "event_lightning",
+               *QUAKEWORLD_REMOVED_MONSTER_CLASSNAMES
+            ent.instance_variable_set(:@removed, true)
+          when "light"
+            if ent.targetname
+              setup_toggle_light(ent)
+            else
+              ent.instance_variable_set(:@removed, true)
+            end
+          when "light_fluoro"
+            setup_toggle_light(ent)
+          when "light_fluorospark"
+            setup_fluorospark_light(ent)
+          when "info_intermission"
+            setup_intermission(ent)
+          when "info_teleport_destination"
+            setup_teleport_destination(ent)
+          when "path_corner"
+            setup_path_corner(ent)
+          end
+
+          setup_start_item(ent) if start_item?(ent) && !ent.removed?
+        end
+      end
+
+      def start_item?(ent)
+        START_ITEM_CLASSNAMES.include?(ent.classname)
+      end
+
+      def setup_start_item(ent)
+        mins, maxs = start_item_bounds(ent.classname)
+        ent.instance_variable_set(:@mins, mins)
+        ent.instance_variable_set(:@maxs, maxs)
+        ent.instance_variable_set(:@solid, 0)
+        ent.think_time = (@game_time || 0.0) + 0.2
+        ent.instance_variable_set(:@think, :place_item)
+      end
+
+      def start_item_bounds(classname)
+        if ITEM_WIDE_BOUNDS_CLASSNAMES.include?(classname)
+          [Math::Vec3::ORIGIN, Math::Vec3.new(32.0, 32.0, 56.0)]
+        elsif ITEM_TALL_BOUNDS_CLASSNAMES.include?(classname)
+          [Math::Vec3.new(-16.0, -16.0, 0.0), Math::Vec3.new(16.0, 16.0, 56.0)]
+        else
+          [Math::Vec3.new(-16.0, -16.0, -24.0), Math::Vec3.new(16.0, 16.0, 32.0)]
+        end
+      end
+
+      def update_start_items
+        return unless @entities
+
+        @entities.each do |ent|
+          next unless ent.instance_variable_get(:@think) == :place_item
+          next if ent.think_time > @game_time
+
+          place_item(ent)
+        end
+      end
+
+      def place_item(ent)
+        ent.instance_variable_set(:@mdl, ent["model"])
+        ent.flags = 256
+        ent.instance_variable_set(:@solid, 1)
+        ent.instance_variable_set(:@movetype, 6)
+        ent.velocity = Math::Vec3::ORIGIN
+        ent.position += Math::Vec3.new(0.0, 0.0, 6.0)
+        return unless drop_item_to_floor(ent)
+
+        ent.think_time = 0.0
+        ent.instance_variable_set(:@think, nil)
+      end
+
+      def drop_item_to_floor(ent)
+        return true unless @level
+
+        floor = trace_entity_floor(ent)
+        unless floor
+          ent.instance_variable_set(:@removed, true)
+          return false
+        end
+
+        ent.position = floor
+        ent.flags |= FL_ONGROUND
+        true
+      end
+
+      HULL1_CLIP_MINS = Math::Vec3.new(-16.0, -16.0, -24.0)
+
+      def trace_entity_floor(ent)
+        # SV_ClipMoveToEntity aligns the moving entity's box with the
+        # clipping hull: offset = hull.clip_mins - ent.mins. Items have
+        # mins.z = 0, so without this the player-hull trace starts 24
+        # units inside the floor and reports all_solid ("bonus item fell
+        # out of level" removes the item).
+        ent_mins = ent.instance_variable_get(:@mins)
+        offset = ent_mins ? HULL1_CLIP_MINS - ent_mins : Math::Vec3::ORIGIN
+        start_pos = ent.position - offset
+        end_pos = start_pos + Math::Vec3.new(0.0, 0.0, -256.0)
+        trace = Physics::HullTrace.trace_world_and_entities(@level, start_pos, end_pos, @entities)
+        return nil if trace.fraction == 1.0 || trace.all_solid
+
+        trace.end_pos + offset
+      end
+
+      def setup_key_item(ent)
+        worldtype = current_worldtype
+        key = key_spawn_fields(ent.classname, worldtype)
+        ent.properties["model"] = key[:model]
+        ent.instance_variable_set(:@touch, :key_touch)
+        ent.instance_variable_set(:@noise, key_sound(worldtype))
+        ent.instance_variable_set(:@netname, key[:netname])
+        ent.instance_variable_set(:@items, key[:items])
+      end
+
+      def setup_sigil_item(ent)
+        raise "no spawnflags" if ent.spawnflags.zero?
+
+        ent.properties["model"] = sigil_model(ent.spawnflags)
+        ent.instance_variable_set(:@touch, :sigil_touch)
+        ent.instance_variable_set(:@noise, "misc/runekey.wav")
+      end
+
+      def setup_powerup_item(ent)
+        powerup = powerup_spawn_fields(ent.classname)
+        ent.properties["model"] = powerup[:model]
+        ent.instance_variable_set(:@touch, :powerup_touch)
+        ent.instance_variable_set(:@noise, powerup[:noise])
+        ent.instance_variable_set(:@netname, powerup[:netname])
+        ent.instance_variable_set(:@items, powerup[:items])
+        ent.instance_variable_set(:@effects, powerup_effects(ent, powerup[:effects])) if powerup[:effects]
+        ent.instance_variable_set(:@mins, ENTITY_HULL_MINS)
+        ent.instance_variable_set(:@maxs, ENTITY_HULL_MAXS)
+      end
+
+      def powerup_effects(ent, effects)
+        existing = ent.instance_variable_get(:@effects)
+        existing ||= ent["effects"].to_i if ent["effects"]
+        existing.to_i | effects
+      end
+
+      def key_spawn_fields(classname, worldtype)
+        case [classname, worldtype]
+        when ["item_key1", 1]
+          { model: "progs/m_s_key.mdl", netname: "silver runekey", items: 131_072 }
+        when ["item_key1", 2]
+          { model: "progs/b_s_key.mdl", netname: "silver keycard", items: 131_072 }
+        when ["item_key2", 1]
+          { model: "progs/m_g_key.mdl", netname: "gold runekey", items: 262_144 }
+        when ["item_key2", 2]
+          { model: "progs/b_g_key.mdl", netname: "gold keycard", items: 262_144 }
+        else
+          medieval_key_spawn_fields(classname)
+        end
+      end
+
+      def medieval_key_spawn_fields(classname)
+        if classname == "item_key2"
+          { model: "progs/w_g_key.mdl", netname: "gold key", items: 262_144 }
+        else
+          { model: "progs/w_s_key.mdl", netname: "silver key", items: 131_072 }
+        end
+      end
+
+      def powerup_spawn_fields(classname)
+        case classname
+        when "item_artifact_envirosuit"
+          { model: "progs/suit.mdl", noise: "items/suit.wav", netname: "Biosuit", items: 2_097_152 }
+        when "item_artifact_invulnerability"
+          {
+            model: "progs/invulner.mdl",
+            noise: "items/protect.wav",
+            netname: "Pentagram of Protection",
+            items: 1_048_576,
+            effects: 128
+          }
+        when "item_artifact_invisibility"
+          { model: "progs/invisibl.mdl", noise: "items/inv1.wav", netname: "Ring of Shadows", items: 524_288 }
+        when "item_artifact_super_damage"
+          {
+            model: "progs/quaddama.mdl",
+            noise: "items/damage.wav",
+            netname: deathmatch.to_i == 4 ? "OctaPower" : "Quad Damage",
+            items: 4_194_304,
+            effects: 64
+          }
+        end
+      end
+
+      def sigil_model(spawnflags)
+        if (spawnflags & 8) != 0
+          "progs/end4.mdl"
+        elsif (spawnflags & 4) != 0
+          "progs/end3.mdl"
+        elsif (spawnflags & 2) != 0
+          "progs/end2.mdl"
+        elsif (spawnflags & 1) != 0
+          "progs/end1.mdl"
+        end
+      end
+
+      def setup_health_item(ent)
+        health = health_spawn_fields(ent)
+        ent.properties["model"] = health[:model]
+        ent.instance_variable_set(:@touch, :health_touch)
+        ent.instance_variable_set(:@noise, health[:noise])
+        ent.instance_variable_set(:@healamount, health[:healamount])
+        ent.instance_variable_set(:@healtype, health[:healtype])
+      end
+
+      def setup_armor_item(ent)
+        armor = armor_spawn_fields(ent.classname)
+        ent.properties["model"] = armor[:model]
+        ent.skin = armor[:skin]
+        ent.instance_variable_set(:@touch, :armor_touch)
+      end
+
+      def armor_spawn_fields(classname)
+        skin = case classname
+               when "item_armor2" then 1
+               when "item_armorInv" then 2
+               else 0
+               end
+        { model: "progs/armor.mdl", skin: skin }
+      end
+
+      def health_spawn_fields(ent)
+        if (ent.spawnflags & 1) != 0
+          { model: "maps/b_bh10.bsp", noise: "items/r_item1.wav", healamount: 15, healtype: 0 }
+        elsif (ent.spawnflags & 2) != 0
+          { model: "maps/b_bh100.bsp", noise: "items/r_item2.wav", healamount: 100, healtype: 2 }
+        else
+          { model: "maps/b_bh25.bsp", noise: "items/health1.wav", healamount: 25, healtype: 1 }
+        end
+      end
+
+      def setup_ammo_item(ent)
+        if deathmatch.to_i == 4 && ent.classname != "item_weapon"
+          disable_spawned_item(ent)
+          return
+        end
+
+        ammo = ammo_spawn_fields(ent)
+        if ammo.nil? && ent.classname == "item_weapon"
+          ent.instance_variable_set(:@touch, :ammo_touch)
+          return
+        end
+        return unless ammo
+
+        ent.properties["model"] = ammo[:model]
+        ent.instance_variable_set(:@touch, :ammo_touch)
+        ent.instance_variable_set(:@aflag, ammo[:amount])
+        ent.instance_variable_set(:@weapon, ammo[:weapon])
+        ent.instance_variable_set(:@netname, ammo[:netname])
+      end
+
+      def ammo_spawn_fields(ent)
+        big = (ent.spawnflags & 1) != 0
+        case ent.classname
+        when "item_shells"
+          { model: big ? "maps/b_shell1.bsp" : "maps/b_shell0.bsp", weapon: 1, netname: "shells", amount: big ? 40 : 20 }
+        when "item_spikes"
+          { model: big ? "maps/b_nail1.bsp" : "maps/b_nail0.bsp", weapon: 2, netname: "nails", amount: big ? 50 : 25 }
+        when "item_rockets"
+          { model: big ? "maps/b_rock1.bsp" : "maps/b_rock0.bsp", weapon: 3, netname: "rockets", amount: big ? 10 : 5 }
+        when "item_cells"
+          { model: big ? "maps/b_batt1.bsp" : "maps/b_batt0.bsp", weapon: 4, netname: "cells", amount: big ? 12 : 6 }
+        when "item_weapon"
+          legacy_weapon_spawn_fields(ent)
+        end
+      end
+
+      def legacy_weapon_spawn_fields(ent)
+        flags = ent.spawnflags
+        big = (flags & 8) != 0
+        if (flags & 2) != 0
+          { model: big ? "maps/b_rock1.bsp" : "maps/b_rock0.bsp", weapon: 3, netname: "rockets", amount: big ? 10 : 5 }
+        elsif (flags & 4) != 0
+          { model: big ? "maps/b_nail1.bsp" : "maps/b_nail0.bsp", weapon: 2, netname: "spikes", amount: big ? 40 : 20 }
+        elsif (flags & 1) != 0
+          { model: big ? "maps/b_shell1.bsp" : "maps/b_shell0.bsp", weapon: 1, netname: "shells", amount: big ? 40 : 20 }
+        end
+      end
+
+      def setup_weapon_item(ent)
+        if deathmatch.to_i > 3
+          disable_spawned_item(ent)
+          return
+        end
+
+        weapon = weapon_spawn_fields(ent.classname)
+        return unless weapon
+
+        ent.properties["model"] = weapon[:model]
+        ent.instance_variable_set(:@touch, :weapon_touch)
+        ent.instance_variable_set(:@weapon, weapon[:weapon])
+        ent.instance_variable_set(:@netname, weapon[:netname])
+      end
+
+      def disable_spawned_item(ent)
+        ent.properties["model"] = ""
+        ent.instance_variable_set(:@solid, 0)
+        ent.instance_variable_set(:@removed, true)
+      end
+
+      def weapon_spawn_fields(classname)
+        case classname
+        when "weapon_supershotgun"
+          { model: "progs/g_shot.mdl", weapon: 2, netname: "Double-barrelled Shotgun" }
+        when "weapon_nailgun"
+          { model: "progs/g_nail.mdl", weapon: 4, netname: "nailgun" }
+        when "weapon_supernailgun"
+          { model: "progs/g_nail2.mdl", weapon: 8, netname: "Super Nailgun" }
+        when "weapon_grenadelauncher"
+          { model: "progs/g_rock.mdl", weapon: 3, netname: "Grenade Launcher" }
+        when "weapon_rocketlauncher"
+          { model: "progs/g_rock2.mdl", weapon: 3, netname: "Rocket Launcher" }
+        when "weapon_lightning"
+          { model: "progs/g_light.mdl", weapon: 3, netname: "Thunderbolt" }
+        end
+      end
+
+      def setup_explobox(ent)
+        height = ent.classname == "misc_explobox2" ? 32.0 : 64.0
+        ent.properties["model"] = ent.classname == "misc_explobox2" ? "maps/b_exbox2.bsp" : "maps/b_explob.bsp"
+        ent.health = 20.0
+        ent.instance_variable_set(:@solid, 2)
+        ent.instance_variable_set(:@movetype, 0)
+        ent.instance_variable_set(:@takedamage, 2)
+        ent.instance_variable_set(:@th_die, :barrel_explode)
+        ent.instance_variable_set(:@mins, Math::Vec3::ORIGIN)
+        ent.instance_variable_set(:@maxs, Math::Vec3.new(32.0, 32.0, height))
+        unless ent.instance_variable_get(:@explobox_setup)
+          ent.position += Math::Vec3.new(0.0, 0.0, 2.0)
+          drop_explobox_to_floor(ent)
+          ent.instance_variable_set(:@explobox_setup, true)
+        end
+      end
+
+      def drop_explobox_to_floor(ent)
+        return unless @level
+
+        old_z = ent.position.z
+        if (floor = trace_entity_floor(ent))
+          ent.position = floor
+          ent.flags |= FL_ONGROUND
+        end
+        ent.instance_variable_set(:@removed, true) if old_z - ent.position.z > 250.0
+      end
+
+      def setup_viewthing(ent)
+        ent.properties["model"] = "progs/player.mdl"
+        ent.instance_variable_set(:@movetype, 0)
+        ent.instance_variable_set(:@solid, 0)
+      end
+
+      def setup_static_light_model(ent)
+        light = static_light_spawn_fields(ent.classname)
+        ent.properties["model"] = light[:model]
+        ent.frame = light.fetch(:frame, 0)
+        ent.instance_variable_set(:@static, true)
+      end
+
+      def static_light_spawn_fields(classname)
+        case classname
+        when "light_globe"
+          { model: "progs/s_light.spr" }
+        when "light_torch_small_walltorch"
+          { model: "progs/flame.mdl" }
+        when "light_flame_large_yellow"
+          { model: "progs/flame2.mdl", frame: 1 }
+        when "light_flame_small_yellow", "light_flame_small_white"
+          { model: "progs/flame2.mdl" }
+        end
+      end
+
+      def current_worldtype
+        world = @entities.find { |ent| ent.classname == "worldspawn" }
+        (world&.[]("worldtype") || "0").to_i
+      end
+
+      def world_info_value(key)
+        world = @entities&.find { |ent| ent.classname == "worldspawn" }
+        world&.[](key)
+      end
+
+      def configure_world_gravity(map_name)
+        @gravity = map_name == "maps/e1m8.bsp" ? 100.0 : GRAVITY
+      end
+
+      def current_gravity
+        (@gravity || GRAVITY).to_f
+      end
+
+      def world_info_enabled?(key)
+        value = world_info_value(key)
+        value && value.to_f != 0.0
+      end
+
+      def key_sound(worldtype)
+        case worldtype
+        when 1
+          "misc/runekey.wav"
+        when 2
+          "misc/basekey.wav"
+        else
+          "misc/medkey.wav"
+        end
+      end
+
+      def setup_toggle_light(ent)
+        return if ent.style < 32
+
+        ent.instance_variable_set(:@use, :light_use)
+        ent.lightstyle = (ent.spawnflags & 1) != 0 ? "a" : "m"
+      end
+
+      def setup_fluorospark_light(ent)
+        ent.style = 10 if ent.style.zero?
+      end
+
+      def current_lightstyles
+        lightstyles = Renderer::GLLightmap.default_lightstyles
+        @entities&.each do |ent|
+          next unless ent.lightstyle
+          next if ent.style.negative? || ent.style >= Renderer::GLLightmap::MAX_LIGHTSTYLES
+
+          lightstyles[ent.style] = ent.lightstyle
+        end
+        lightstyles
+      end
+
+      def setup_noisemaker(ent)
+        ent.think_time = @game_time + 0.1 + rand
+        ent.instance_variable_set(:@think, :noise_think)
+      end
+
+      def update_noisemaker(ent)
+        return if ent.think_time > @game_time
+
+        @sound_events&.on_misc_noisemaker(ent)
+        ent.think_time = @game_time + 0.5
+      end
+
+      def setup_intermission(ent)
+        ent.angles = vec3_property(ent, "mangle")
+      end
+
+      def find_intermission_spot
+        intermissions = (@entities || []).select { |ent| ent.classname == "info_intermission" }
+        unless intermissions.empty?
+          spot = intermissions.first
+          cyc = rand * 4.0
+          while cyc > 1.0
+            index = intermissions.index(spot) + 1
+            spot = intermissions[index] || intermissions.first
+            cyc -= 1.0
+          end
+          return spot
+        end
+
+        start = (@entities || []).find { |ent| ent.classname == "info_player_start" }
+        return start if start
+
+        raise "FindIntermission: no spot"
+      end
+
+      def setup_teleport_destination(ent)
+        return if ent.instance_variable_get(:@teleport_destination_setup)
+
+        ent.instance_variable_set(:@mangle, ent.angles)
+        ent.angles = Math::Vec3::ORIGIN
+        ent.properties["model"] = ""
+        ent.position += Math::Vec3.new(0.0, 0.0, 27.0)
+        raise "no targetname" if ent.targetname.nil? || ent.targetname.empty?
+
+        ent.instance_variable_set(:@teleport_destination_setup, true)
+      end
+
+      def setup_path_corner(ent)
+        raise "monster_movetarget: no targetname" if ent.targetname.nil? || ent.targetname.empty?
+
+        ent.instance_variable_set(:@solid, 1)
+        ent.instance_variable_set(:@touch, :t_movetarget)
+        ent.instance_variable_set(:@mins, Math::Vec3.new(-8.0, -8.0, -8.0))
+        ent.instance_variable_set(:@maxs, Math::Vec3.new(8.0, 8.0, 8.0))
+      end
+
+      def setup_ambient_sounds
+        @entities.each { |ent| @sound_events&.on_ambient_entity(ent) }
+      end
+
+      def update_trap_shooter(ent)
+        return if ent.think_time > @game_time
+
+        fire_spikeshooter(ent)
+        @projectiles[-1] = trap_shooter_projectile_with_quake_think_velocity(@projectiles[-1], ent)
+        ent.think_time = @game_time + ent.wait
+        ent.instance_variable_set(:@think, :shooter_think)
+      end
+
+      def setup_trap_spikeshooter(ent)
+        ent.move_dir = ent.forward_vector
+        ent.angles = Math::Vec3::ORIGIN
+        ent.instance_variable_set(:@use, :spikeshooter_use)
+      end
+
+      def fire_spikeshooter(ent)
+        @projectiles ||= []
+        laser = (ent.spawnflags & 2) != 0
+        superspike = (ent.spawnflags & 1) != 0
+        move_dir = ent.move_dir == Math::Vec3::ORIGIN ? ent.forward_vector : ent.move_dir
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: laser ? "enforcer/enfire.wav" : "weapons/spike2.wav"))
+        @projectiles << Projectile.new(
+          kind: laser ? :laser : (superspike ? :super_spike : :spike),
+          position: ent.position,
+          velocity: move_dir * (laser ? 600.0 : 500.0),
+          damage: laser ? 15 : (superspike ? 18 : 9),
+          damage_variance: nil,
+          radius_damage: nil,
+          explode_at: @game_time + (laser ? LASER_LIFETIME : SPIKE_LIFETIME),
+          model: laser ? "progs/laser.mdl" : "progs/spike.mdl",
+          movetype: laser ? 5 : 9,
+          solid: 2,
+          effects: laser ? 8 : 0,
+          angles: projectile_angles_from_velocity(move_dir),
+          avelocity: Math::Vec3::ORIGIN,
+          voided: false,
+          owner: ent
+        )
+      end
+
+      def trap_shooter_projectile_with_quake_think_velocity(projectile, ent)
+        return projectile unless projectile
+
+        projectile.with(velocity: ent.move_dir * 500.0, owner: ent)
+      end
+
+      def setup_fireball_emitter(ent)
+        ent.classname = "fireball"
+        ent.speed = 0.0 unless ent["speed"]
+        ent.think_time = @game_time + rand * 5.0
+        ent.instance_variable_set(:@think, :fire_fly)
+        ent.instance_variable_set(:@fireball_emitter, true)
+      end
+
+      def update_fireball_emitter(ent)
+        return if ent.think_time > @game_time
+
+        fire_lava_ball(ent)
+        ent.think_time = @game_time + rand * 5.0 + 3.0
+        ent.instance_variable_set(:@think, :fire_fly)
+      end
+
+      def fire_lava_ball(ent)
+        @projectiles ||= []
+        velocity = Math::Vec3.new(
+          rand * 100.0 - 50.0,
+          rand * 100.0 - 50.0,
+          ent.speed + rand * 200.0
+        )
+        @projectiles << Projectile.new(
+          kind: :fireball,
+          position: ent.position,
+          velocity: velocity,
+          damage: 20,
+          damage_variance: nil,
+          radius_damage: nil,
+          explode_at: @game_time + 5.0,
+          model: "progs/lavaball.mdl",
+          movetype: 6,
+          solid: 1,
+          effects: 0,
+          angles: projectile_angles_from_velocity(velocity),
+          avelocity: Math::Vec3::ORIGIN,
+          voided: false,
+          owner: nil
+        )
+      end
+
+      def fire_bullets(event)
+        return unless @level
+
+        src = @player.position + @player.forward * 10.0
+        # QuakeC FireBullets: src_z = self.absmin_z + self.size_z * 0.7.
+        # Player hull is -24..32, so the shot source is origin z + 15.2.
+        src = Math::Vec3.new(src.x, src.y, @player.position.z + 15.2)
+        right = @player.right
+        up = @player.up
+        solid_brush = @entities.select(&:brush_entity?)
+        multi_ent = nil
+        multi_damage = 0.0
+        blood_position = nil
+        blood_count = 0
+        puff_position = nil
+        puff_count = 0
+        apply_multi_damage = lambda do
+          return unless multi_ent
+
+          damage_entity(multi_ent, multi_damage, attacker: @player_state, inflictor: @player)
+        end
+
+        aim_trace = Physics::HullTrace.trace_world_and_entities(
+          @level, src, src + @player.forward * event.range, solid_brush, hull_num: 0
+        )
+        aim_entity_hit = trace_bullet_touch_entity(src, @player.forward, event.range * aim_trace.fraction)
+        puff_position = ((aim_entity_hit&.last) || aim_trace.end_pos) - @player.forward * 4.0
+
+        event.pellets.times do
+          dir = @player.forward +
+                right * (crandom * event.spread_x) +
+                up * (crandom * event.spread_y)
+          trace = Physics::HullTrace.trace_world_and_entities(
+            @level, src, src + dir * event.range, solid_brush, hull_num: 0
+          )
+          entity_hit = trace_bullet_touch_entity(src, dir, event.range * trace.fraction)
+          if entity_hit
+            ent, hit_pos = entity_hit
+            if ent.damageable?
+              damage = player_damage(event.damage)
+              if ent.equal?(multi_ent)
+                multi_damage += damage
+              else
+                apply_multi_damage.call
+                multi_ent = ent
+                multi_damage = damage
+              end
+              blood_position = hit_pos - dir * 4.0
+              blood_count += 1
+            else
+              puff_count += 1
+            end
+            next
+          end
+
+          next if trace.fraction >= 1.0
+
+          puff_count += 1
+        end
+
+        apply_multi_damage.call
+        @particles&.gunshot(puff_position, count: puff_count) if puff_count.positive?
+        @particles&.blood(blood_position, count: blood_count) if blood_count.positive?
+      end
+
+      def update_projectiles(dt)
+        return unless @projectiles&.any?
+
+        solid_brush = @entities.select(&:brush_entity?)
+        next_projectiles = []
+        @projectiles.each do |projectile|
+          if @game_time >= projectile.explode_at
+            explode_projectile(projectile, projectile.position) if projectile.kind == :grenade
+            next
+          end
+
+          velocity = projectile.velocity
+          avelocity = projectile.avelocity
+          angles = projectile.angles + avelocity * dt
+          # trigger_push_touch also redirects grenades (triggers.qc)
+          if projectile.kind == :grenade
+            push = grenade_push_trigger_velocity(projectile.position)
+            velocity = push if push
+          end
+          velocity += Math::Vec3.new(0.0, 0.0, -current_gravity * dt) if toss_projectile?(projectile)
+          desired = projectile.position + velocity * dt
+          if projectile.voided
+            next_projectiles << projectile.with(position: desired, velocity: velocity, angles: angles)
+            next
+          end
+
+          trace = Physics::HullTrace.trace_world_and_entities(
+            @level, projectile.position, desired, solid_brush, hull_num: 0
+          )
+          segment = desired - projectile.position
+          distance = segment.length
+          dir = distance.zero? ? Math::Vec3::ORIGIN : segment.normalize
+          entity_hit = if spike_projectile?(projectile)
+                         trace_spike_touch_entity(projectile.position, dir, distance * trace.fraction, ignore: projectile.owner)
+                       elsif laser_projectile?(projectile)
+                         trace_laser_touch_entity(projectile.position, dir, distance * trace.fraction, ignore: projectile.owner)
+                       elsif projectile.kind == :fireball
+                         trace_fireball_touch_entity(projectile.position, dir, distance * trace.fraction, ignore: projectile.owner)
+                       elsif projectile.kind == :rocket || projectile.kind == :grenade
+                         trace_missile_touch_entity(projectile.position, dir, distance * trace.fraction, ignore: projectile.owner)
+                       else
+                         trace_damageable_entity(projectile.position, dir, distance * trace.fraction)
+                       end
+          if entity_hit
+            ent, hit_pos = entity_hit
+            if projectile.kind == :grenade && !grenade_explodes_on_touch?(ent)
+              @sound_events&.on_grenade_bounce
+              # SV_Physics_Toss reflects off the contact plane (backoff 1.5);
+              # approximate the entity-box face normal from the hit point
+              normal = aabb_face_normal(ent, hit_pos)
+              bounced = normal ? bounce_velocity(velocity, normal) : velocity
+              next_projectiles << projectile.with(
+                position: hit_pos,
+                velocity: bounced,
+                angles: angles,
+                avelocity: grenade_bounce_avelocity(projectile, bounced)
+              )
+              next
+            end
+
+            touch_projectile(projectile, hit_pos, ent)
+            next
+          end
+
+          if trace.fraction < 1.0 && trace.plane_normal
+            impact_pos = trace.end_pos
+            if projectile_removed_by_sky?(projectile, impact_pos)
+              next
+            elsif projectile.kind == :rocket
+              explode_projectile(projectile, impact_pos)
+              next
+            elsif laser_projectile?(projectile)
+              play_laser_impact_sound
+              @particles&.gunshot(laser_impact_position(projectile, impact_pos), count: 5)
+              next
+            elsif spike_projectile?(projectile)
+              play_spike_impact_sound
+              @particles&.gunshot(impact_pos, count: spike_impact_particle_count(projectile))
+              next
+            elsif projectile.kind == :fireball
+              next
+            else
+              velocity = bounce_velocity(velocity, trace.plane_normal)
+              @sound_events&.on_grenade_bounce if projectile.kind == :grenade
+              avelocity = grenade_bounce_avelocity(projectile, velocity)
+              desired = impact_pos
+            end
+          end
+
+          emit_projectile_trail(projectile, desired)
+          next_projectiles << Projectile.new(
+            kind: projectile.kind,
+            position: desired,
+            velocity: velocity,
+            damage: projectile.damage,
+            damage_variance: projectile.damage_variance,
+            radius_damage: projectile.radius_damage,
+            explode_at: projectile.explode_at,
+            model: projectile.model,
+            movetype: projectile.movetype,
+            solid: projectile.solid,
+            effects: projectile.effects,
+            angles: angles,
+            avelocity: avelocity,
+            voided: projectile.voided,
+            owner: projectile.owner
+          )
+        end
+        @projectiles = next_projectiles
+      end
+
+      def emit_projectile_trail(projectile, end_pos)
+        trail_type = projectile_trail_type(projectile)
+        @particles&.rocket_trail(projectile.position, end_pos, type: trail_type) if trail_type
+      end
+
+      def projectile_trail_type(projectile)
+        flags = model_flags(projectile.model)
+        if flags
+          return 2 if (flags & EF_GIB) != 0
+          return 4 if (flags & EF_ZOMGIB) != 0
+          return 3 if (flags & EF_TRACER) != 0
+          return 5 if (flags & EF_TRACER2) != 0
+          return 0 if (flags & EF_ROCKET) != 0
+          return 1 if (flags & EF_GRENADE) != 0
+          return 6 if (flags & EF_TRACER3) != 0
+        end
+
+        case projectile.kind
+        when :rocket then 0
+        when :grenade then 1
+        end
+      end
+
+      def render_projectiles
+        return unless @projectiles&.any?
+
+        @projectiles.each do |projectile|
+          gl_model = @mdl_renderers&.[](projectile.model)
+          next unless gl_model
+          ambient_light, shade_light = alias_entity_lighting(projectile.position)
+
+          gl_model.render(
+            frame_index: 0,
+            lerp: 0.0,
+            position: projectile.position,
+            yaw: projectile.angles.y,
+            pitch: -projectile.angles.x,
+            roll: projectile.angles.z,
+            time: @game_time,
+            ambient_light: ambient_light,
+            shade_light: shade_light
+          )
+        end
+      end
+
+      def render_temp_beams
+        active_temp_beam_segments.each do |segment|
+          gl_model = @mdl_renderers&.[](segment.model)
+          next unless gl_model
+
+          ambient_light, shade_light = alias_entity_lighting(segment.origin)
+          gl_model.render(
+            frame_index: 0,
+            lerp: 0.0,
+            position: segment.origin,
+            yaw: segment.yaw,
+            pitch: -segment.pitch,
+            roll: segment.roll,
+            time: @game_time,
+            ambient_light: ambient_light,
+            shade_light: shade_light
+          )
+        end
+      end
+
+      def active_temp_beam_segments
+        Array(@temporary_beams).flat_map do |beam|
+          next [] if beam.end_time < @game_time.to_f
+
+          beam_segments(beam)
+        end
+      end
+
+      def beam_segments(beam)
+        start = beam_start_position(beam)
+        dist = beam.finish - start
+        length = dist.length
+        return [] if length.zero?
+
+        dir = dist * (1.0 / length)
+        pitch, yaw = quake_vectoangles(dist)
+        origin = start
+        remaining = length
+        segments = []
+        while remaining.positive?
+          segments << TemporaryBeamSegment.new(
+            model: beam.model,
+            origin: origin,
+            pitch: pitch,
+            yaw: yaw,
+            roll: (rand * 360.0).to_i
+          )
+          origin += dir * 30.0
+          remaining -= 30.0
+        end
+        segments
+      end
+
+      def beam_start_position(beam)
+        if beam.entity == VIEW_ENTITY && @player
+          return @player.position + Math::Vec3.new(0.0, 0.0, 16.0)
+        end
+
+        beam.start
+      end
+
+      def alias_entity_lighting(origin, ambient_light: nil, shade_light: nil)
+        base_light = quake_light_point(origin)
+        ambient = (ambient_light || base_light).to_f
+        shade = (shade_light || base_light).to_f
+        @dynamic_lights&.each do |light|
+          next if light.die < @game_time.to_f
+
+          add = light.radius.to_f - (origin - light.origin).length
+          next unless add.positive?
+
+          ambient += add
+          shade += add
+        end
+        [ambient, shade]
+      end
+
+      def quake_light_point(point)
+        return 200 unless @level
+        return 255 if @level.lighting.nil? || @level.lighting.empty?
+        return 0 if @level.nodes.empty? || @level.planes.empty?
+
+        # Static geometry means a static answer per position; most callers
+        # (items, torches, the view entity) barely move, so memoize. Sampled
+        # light also depends on the lightstyle values, so the cache drops
+        # whenever they change (style animation or entity-driven styles).
+        styles = current_lightstyle_values
+        if @light_point_cache_level != @level || @light_point_cache_styles != styles ||
+           @light_point_cache.size > 4096
+          @light_point_cache = {}
+          @light_point_cache_level = @level
+          @light_point_cache_styles = styles.dup
+        end
+        key = [point.x.round, point.y.round, point.z.round]
+        @light_point_cache.fetch(key) do
+          finish = point - Math::Vec3.new(0.0, 0.0, 8192.0 + 2.0)
+          light = recursive_light_point(0, point, finish)
+          @light_point_cache[key] = (light == -1 ? 0 : light)
+        end
+      end
+
+      def recursive_light_point(node_index, start, finish)
+        return -1 if node_index.negative?
+
+        node = @level.nodes[node_index]
+        return -1 unless node
+
+        plane = @level.planes[node.plane_index]
+        return -1 unless plane
+
+        front = start.dot(plane.normal) - plane.dist
+        back = finish.dot(plane.normal) - plane.dist
+        side = front.negative? ? 1 : 0
+
+        return recursive_light_point(node.children[side], start, finish) if back.negative? == (side == 1)
+
+        frac = front / (front - back)
+        mid = start + (finish - start) * frac
+
+        light = recursive_light_point(node.children[side], start, mid)
+        return light if light >= 0
+        return -1 if back.negative? == (side == 1)
+
+        sampled = light_point_from_node_surfaces(node, mid)
+        return sampled unless sampled.nil?
+
+        recursive_light_point(node.children[1 - side], mid, finish)
+      end
+
+      def light_point_from_node_surfaces(node, point)
+        first_face = node.first_face
+        last_face = first_face + node.num_faces
+        (first_face...last_face).each do |face_index|
+          face = @level.faces[face_index]
+          next unless face
+          next if (face.flags & Bsp::Face::SURF_DRAWTILED) != 0
+
+          texinfo = @level.texinfo[face.texinfo_index]
+          next unless texinfo
+
+          s = point.dot(texinfo.s_vec) + texinfo.s_offset
+          t = point.dot(texinfo.t_vec) + texinfo.t_offset
+          mins = face.texture_mins || [0, 0]
+          extents = face.extents || [0, 0]
+          next if s < mins[0] || t < mins[1]
+
+          ds = s - mins[0]
+          dt = t - mins[1]
+          next if ds > extents[0] || dt > extents[1]
+
+          return 0 if face.light_offset.negative?
+
+          return sample_surface_light(face, ds.to_i >> 4, dt.to_i >> 4)
+        end
+        nil
+      end
+
+      def sample_surface_light(face, ds, dt)
+        width = (face.extents[0] >> 4) + 1
+        height = (face.extents[1] >> 4) + 1
+        lightmap_size = width * height
+        offset = face.light_offset + dt * width + ds
+        light = 0
+
+        face.styles.each do |style|
+          break if style == 255
+
+          sample = @level.lighting.getbyte(offset)
+          light += sample * current_lightstyle_values.fetch(style, 256) if sample
+          offset += lightmap_size
+        end
+
+        light >> 8
+      end
+
+      def current_lightstyle_values
+        @lightmap&.lightstyle_values ||
+          Renderer::GLLightmap.lightstyle_values_for((@game_time || 0.0).to_f, current_lightstyles)
+      end
+
+      def emit_entity_effect_particles(ent)
+        # NOTE: effects may be nil, and nil & 1 == false in Ruby, which != 0
+        return unless (ent.effects.to_i & ENTITY_EFFECT_BRIGHTFIELD) != 0
+
+        @particles&.entity_particles(ent.position, time: @game_time.to_f)
+      end
+
+      def current_view_blend
+        contents = point_contents(@camera&.position || player_eye_position)
+        Renderer::GLViewBlend.calc_blend(
+          [
+            Renderer::GLViewBlend.contents_cshift(contents),
+            @damage_cshift || Renderer::GLViewBlend::CShift.new(color: [0, 0, 0], percent: 0),
+            Renderer::GLViewBlend.bonus_cshift(@bonus_cshift_percent.to_f),
+            Renderer::GLViewBlend.powerup_cshift(@player_state, game_time: @game_time.to_f)
+          ]
+        )
+      end
+
+      def trigger_bonus_flash
+        @sound_events&.on_player(:bonus_flash)
+        @bonus_cshift_percent = 50.0
+      end
+
+      def update_view_cshifts(dt)
+        @bonus_cshift_percent = [@bonus_cshift_percent.to_f - dt.to_f * 100.0, 0.0].max
+        damage = @damage_cshift || Renderer::GLViewBlend::CShift.new(color: [0, 0, 0], percent: 0.0)
+        @damage_cshift = Renderer::GLViewBlend::CShift.new(
+          color: damage.color,
+          percent: [damage.percent.to_f - dt.to_f * 150.0, 0.0].max
+        )
+        @damage_kick_time = [@damage_kick_time.to_f - dt.to_f, 0.0].max
+        update_weapon_punch_angle(dt)
+      end
+
+      def trigger_weapon_punch(event)
+        @weapon_punch_angle = WEAPON_PUNCH_ANGLES.fetch(event.kick, Math::Vec3::ORIGIN)
+      end
+
+      def update_weapon_punch_angle(dt)
+        punch = current_weapon_punch_angle
+        len = punch.length
+        return if len.zero?
+
+        len = [len - WEAPON_PUNCH_DECAY * dt.to_f, 0.0].max
+        @weapon_punch_angle = len.zero? ? Math::Vec3::ORIGIN : punch.normalize * len
+      end
+
+      def current_weapon_punch_angle
+        @weapon_punch_angle || Math::Vec3::ORIGIN
+      end
+
+      def trigger_damage_flash(result)
+        armor = result[:save].to_f
+        blood = result.fetch(:display_take, result[:take]).to_f
+        return if armor <= 0.0 && blood <= 0.0
+
+        @player_state.face_anim_time = @game_time.to_f + 0.2 if @player_state
+        @damage_cshift = Renderer::GLViewBlend.damage_cshift(
+          armor: armor,
+          blood: blood,
+          current_percent: @damage_cshift&.percent.to_f
+        )
+      end
+
+      def trigger_damage_kick(result, inflictor)
+        source = damage_kick_source(inflictor)
+        return unless @player && source
+
+        from = source - @player.position
+        return if from.length.zero?
+
+        from = from.normalize
+        blood = result.fetch(:display_take, result[:take]).to_f
+        count = blood * 0.5 + result[:save].to_f * 0.5
+        count = 10.0 if count < 10.0
+        @damage_kick_roll = count * from.dot(@player.right) * 0.6
+        @damage_kick_pitch = count * from.dot(@player.forward) * 0.6
+        @damage_kick_time = 0.5
+      end
+
+      def damage_kick_source(inflictor)
+        return inflictor if inflictor.is_a?(Math::Vec3)
+        return inflictor.position if inflictor.respond_to?(:position)
+
+        nil
+      end
+
+      def current_damage_kick_angles
+        return [0.0, 0.0] unless @damage_kick_time.to_f.positive?
+
+        scale = @damage_kick_time.to_f / 0.5
+        [@damage_kick_roll.to_f * scale, @damage_kick_pitch.to_f * scale]
+      end
+
+      def build_dynamic_lights
+        lights = []
+        @entities&.each_with_index do |ent, index|
+          next if ent.removed?
+
+          lights.concat(quake_effect_dynamic_lights(
+                          ent.effects,
+                          origin: ent.position,
+                          angles: ent.angles,
+                          key: index + 1
+                        ))
+        end
+        @projectiles&.each_with_index do |projectile, index|
+          lights.concat(quake_effect_dynamic_lights(
+                          projectile.effects,
+                          origin: projectile.position,
+                          angles: projectile.angles,
+                          key: 10_000 + index
+                        ))
+        end
+        @temporary_dynamic_lights = Array(@temporary_dynamic_lights).filter_map do |light|
+          next if light.die < @game_time.to_f
+
+          radius = light.radius.to_f - (@game_time.to_f - light.start_time.to_f) * light.decay.to_f
+          next if radius <= 0.0
+
+          lights << DynamicLight.new(
+            key: 0,
+            origin: light.origin,
+            radius: radius,
+            minlight: light.minlight,
+            die: light.die
+          )
+          light
+        end
+        @dynamic_lights = lights
+      end
+
+      # CL_MuzzleFlash: dlight 18 units ahead of the eyes, radius
+      # 200 + rand&31, minlight 32, dies after 0.1s
+      def add_muzzle_flash_dynamic_light
+        return unless @player
+
+        origin = player_eye_position + @player.forward * 18.0
+        @temporary_dynamic_lights ||= []
+        @temporary_dynamic_lights << TemporaryDynamicLight.new(
+          origin: origin,
+          radius: 200.0 + rand * 32.0,
+          minlight: 32.0,
+          start_time: @game_time.to_f,
+          die: @game_time.to_f + 0.1,
+          decay: 0.0
+        )
+      end
+
+      def add_temp_explosion_dynamic_light(origin)
+        @temporary_dynamic_lights ||= []
+        @temporary_dynamic_lights << TemporaryDynamicLight.new(
+          origin: origin,
+          radius: 350.0,
+          minlight: 0.0,
+          start_time: @game_time.to_f,
+          die: @game_time.to_f + 0.5,
+          decay: 300.0
+        )
+      end
+
+      def spawn_temp_color_mapped_explosion(origin, color_start:, color_length:)
+        @particles&.color_mapped_explosion(origin, color_start: color_start, color_length: color_length)
+        add_temp_explosion_dynamic_light(origin)
+        play_temp_explosion_sound
+      end
+
+      def spawn_temp_tar_explosion(origin)
+        @particles&.blob_explosion(origin)
+        play_temp_explosion_sound
+      end
+
+      def spawn_temp_spike_impact(origin)
+        @particles&.gunshot(origin, count: 10)
+        play_spike_impact_sound
+      end
+
+      def spawn_temp_super_spike_impact(origin)
+        @particles&.gunshot(origin, count: 20)
+        play_spike_impact_sound
+      end
+
+      def spawn_temp_wizard_spike_impact(origin)
+        @particles&.run_particle_effect(origin, color: 20, count: 30)
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: "wizard/hit.wav"))
+      end
+
+      def spawn_temp_knight_spike_impact(origin)
+        @particles&.run_particle_effect(origin, color: 226, count: 20)
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: "hknight/hit.wav"))
+      end
+
+      def spawn_temp_gunshot_impact(origin)
+        @particles&.gunshot(origin, count: 20)
+      end
+
+      def quake_effect_dynamic_lights(effects, origin:, angles:, key:)
+        light = nil
+        effects = effects.to_i
+
+        if (effects & ENTITY_EFFECT_MUZZLEFLASH) != 0
+          light = DynamicLight.new(
+            key: key,
+            origin: origin + Math::Vec3.new(0.0, 0.0, 16.0) + angle_forward(angles) * 18.0,
+            radius: 200.0 + quake_effect_light_jitter,
+            minlight: 32.0,
+            die: @game_time.to_f + 0.1
+          )
+        end
+
+        if (effects & ENTITY_EFFECT_BRIGHTLIGHT) != 0
+          light = DynamicLight.new(
+            key: key,
+            origin: origin + Math::Vec3.new(0.0, 0.0, 16.0),
+            radius: 400.0 + quake_effect_light_jitter,
+            minlight: 0.0,
+            die: @game_time.to_f + 0.001
+          )
+        end
+
+        if (effects & ENTITY_EFFECT_DIMLIGHT) != 0
+          light = DynamicLight.new(
+            key: key,
+            origin: origin,
+            radius: 200.0 + quake_effect_light_jitter,
+            minlight: 0.0,
+            die: @game_time.to_f + 0.001
+          )
+        end
+
+        light ? [light] : []
+      end
+
+      def quake_effect_light_jitter
+        (rand * 32.0).to_i
+      end
+
+      def projectile_angles_from_velocity(velocity)
+        pitch, yaw = quake_vectoangles(velocity)
+        Math::Vec3.new(pitch, yaw, 0.0)
+      end
+
+      def alias_entity_yaw(ent, model_path)
+        flags = model_flags(model_path)
+        return quake_anglemod(100.0 * @game_time.to_f) if flags && (flags & EF_ROTATE) != 0
+
+        ent.angles == Math::Vec3::ORIGIN ? ent.angle : ent.angles.y
+      end
+
+      # Per-entity random animation phase (entity_t.syncbase) so identical
+      # ST_RAND models (torches, flames) don't animate in lockstep.
+      def entity_sync_base(ent, gl_model)
+        return 0.0 unless gl_model.random_sync?
+
+        @entity_sync_bases ||= {}
+        @entity_sync_bases[ent.object_id] ||= rand
+      end
+
+      def model_flags(model_path)
+        @mdl_cache&.[](model_path)&.flags
+      end
+
+      def quake_anglemod(angle)
+        (360.0 / 65_536.0) * ((angle * (65_536.0 / 360.0)).to_i & 65_535)
+      end
+
+      def quake_vectoangles(vec)
+        if vec.y.zero? && vec.x.zero?
+          pitch = vec.z.positive? ? 90 : 270
+          return [pitch, 0]
+        end
+
+        yaw = (::Math.atan2(vec.y, vec.x) * 180.0 / ::Math::PI).to_i
+        yaw += 360 if yaw.negative?
+        forward = ::Math.sqrt(vec.x * vec.x + vec.y * vec.y)
+        pitch = (::Math.atan2(vec.z, forward) * 180.0 / ::Math::PI).to_i
+        pitch += 360 if pitch.negative?
+        [pitch, yaw]
+      end
+
+      def touch_projectile(projectile, position, ent)
+        return if projectile_removed_by_sky?(projectile, position)
+
+        touch_inflictor = projectile.with(position: position)
+        if projectile.kind == :rocket
+          explode_projectile(projectile, position, direct_hit: ent)
+        elsif spike_projectile?(projectile)
+          if ent.damageable?
+            ent.instance_variable_set(:@deathtype, projectile_deathtype(projectile))
+            damage_entity(
+              ent,
+              projectile_owner_damage(projectile, projectile.damage),
+              attacker: projectile.owner,
+              inflictor: touch_inflictor
+            )
+            @particles&.blood(position, count: projectile_touch_blood_count(projectile))
+          else
+            play_spike_impact_sound
+            @particles&.gunshot(position, count: spike_impact_particle_count(projectile))
+          end
+        elsif laser_projectile?(projectile)
+          play_laser_impact_sound
+          impact = laser_impact_position(projectile, position)
+          if ent.health != 0.0
+            ent.instance_variable_set(:@deathtype, "laser")
+            damage_entity(
+              ent,
+              projectile_owner_damage(projectile, projectile.damage),
+              attacker: projectile.owner,
+              inflictor: touch_inflictor
+            )
+            @particles&.blood(impact, count: projectile_touch_blood_count(projectile))
+          else
+            @particles&.gunshot(impact, count: 5)
+          end
+        elsif projectile.kind == :fireball
+          damage_entity(
+            ent,
+            projectile.damage,
+            attacker: touch_inflictor,
+            inflictor: touch_inflictor
+          )
+        else
+          explode_projectile(projectile, position)
+        end
+      end
+
+      def grenade_explodes_on_touch?(ent)
+        takedamage = ent.instance_variable_get(:@takedamage)
+        takedamage == 2
+      end
+
+      def grenade_bounce_avelocity(projectile, velocity)
+        return projectile.avelocity unless projectile.kind == :grenade
+
+        velocity == Math::Vec3::ORIGIN ? Math::Vec3::ORIGIN : projectile.avelocity
+      end
+
+      def spike_projectile?(projectile)
+        projectile.kind == :spike || projectile.kind == :super_spike
+      end
+
+      def laser_projectile?(projectile)
+        projectile.kind == :laser
+      end
+
+      def projectile_touched_sky?(position)
+        point_contents(position) == Physics::CONTENTS_SKY
+      end
+
+      def projectile_removed_by_sky?(projectile, position)
+        (projectile.kind == :rocket || spike_projectile?(projectile) || laser_projectile?(projectile)) &&
+          projectile_touched_sky?(position)
+      end
+
+      def point_contents(position)
+        return Physics::CONTENTS_EMPTY unless @level
+        return Physics::CONTENTS_EMPTY if @level.nodes.empty? || @level.planes.empty? || @level.leafs.empty?
+
+        leaf = @level.leafs[Bsp::Vis.point_in_leaf(@level, position)]
+        leaf ? leaf.contents : Physics::CONTENTS_EMPTY
+      end
+
+      def play_laser_impact_sound
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: "enforcer/enfstop.wav"))
+      end
+
+      def play_spike_impact_sound
+        sound = if (rand * 5).to_i != 0
+                  "weapons/tink1.wav"
+                else
+                  case (rand * 4).to_i
+                  when 1 then "weapons/ric1.wav"
+                  when 2 then "weapons/ric2.wav"
+                  else "weapons/ric3.wav"
+                  end
+                end
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: sound))
+      end
+
+      def spike_impact_particle_count(projectile)
+        projectile.kind == :super_spike ? 20 : 10
+      end
+
+      def projectile_touch_blood_count(projectile)
+        case projectile.kind
+        when :spike then 9
+        when :super_spike then 18
+        when :laser then 15
+        else 1
+        end
+      end
+
+      def laser_impact_position(projectile, position)
+        position - projectile.velocity.normalize * 8.0
+      end
+
+      def toss_projectile?(projectile)
+        projectile.kind == :grenade || projectile.kind == :fireball
+      end
+
+      def explode_projectile(projectile, position, direct_hit: nil)
+        explosion_inflictor = projectile.with(position: position)
+        if direct_hit && projectile.kind == :rocket && direct_hit.health.to_f.nonzero?
+          direct_damage = projectile.damage + rand * projectile.damage_variance.to_f
+          direct_hit.instance_variable_set(:@deathtype, "rocket")
+          damage_entity(
+            direct_hit,
+            projectile_owner_damage(projectile, direct_damage),
+            attacker: projectile.owner,
+            inflictor: explosion_inflictor
+          )
+        end
+
+        radius_ignore = projectile.kind == :rocket ? direct_hit : nil
+        apply_radius_damage(
+          position,
+          projectile.radius_damage,
+          ignore: radius_ignore,
+          attacker: projectile.owner,
+          attacker_player: player_attacker?(projectile.owner),
+          inflictor: explosion_inflictor,
+          deathtype: projectile_radius_deathtype(projectile)
+        )
+        play_temp_explosion_sound
+        effect_position = explosion_effect_position(projectile, position)
+        add_temp_explosion_dynamic_light(effect_position)
+        @particles&.explosion(effect_position)
+      end
+
+      def explosion_effect_position(projectile, position)
+        return position unless projectile.kind == :rocket
+
+        position - projectile.velocity.normalize * 8.0
+      end
+
+      def bounce_velocity(velocity, normal)
+        backoff = velocity.dot(normal) * 1.5
+        Math::Vec3.new(
+          stop_epsilon_component(velocity.x - normal.x * backoff),
+          stop_epsilon_component(velocity.y - normal.y * backoff),
+          stop_epsilon_component(velocity.z - normal.z * backoff)
+        )
+      end
+
+      # Nearest box face to the hit point approximates the contact normal
+      # for projectiles bouncing off bbox entities.
+      def aabb_face_normal(ent, hit_pos)
+        mins, maxs = damageable_bounds(ent)
+        return nil unless mins && maxs
+
+        [
+          [(hit_pos.x - mins.x).abs, Math::Vec3.new(-1.0, 0.0, 0.0)],
+          [(maxs.x - hit_pos.x).abs, Math::Vec3.new(1.0, 0.0, 0.0)],
+          [(hit_pos.y - mins.y).abs, Math::Vec3.new(0.0, -1.0, 0.0)],
+          [(maxs.y - hit_pos.y).abs, Math::Vec3.new(0.0, 1.0, 0.0)],
+          [(hit_pos.z - mins.z).abs, Math::Vec3.new(0.0, 0.0, -1.0)],
+          [(maxs.z - hit_pos.z).abs, Math::Vec3.new(0.0, 0.0, 1.0)]
+        ].min_by(&:first).last
+      end
+
+      def stop_epsilon_component(value)
+        value > -STOP_EPSILON && value < STOP_EPSILON ? 0.0 : value
+      end
+
+      def apply_radius_damage(origin, damage, ignore: nil, attacker_player: true, attacker: nil, inflictor: nil,
+                              deathtype: nil)
+        radius_attacker = attacker || (attacker_player ? @player_state : nil)
+        radius = damage + 40.0
+        if @player && @player_state&.alive?
+          player_center = @player.position + (ENTITY_HULL_MINS + ENTITY_HULL_MAXS) * 0.5
+          points = radius_damage_points(origin, player_center, damage, radius)
+          if points.positive? && can_radius_damage_position?(@player.position, origin)
+            points *= 0.5 if attacker_player
+            player_points = player_damage(points)
+            apply_player_damage_momentum(player_points, inflictor || origin)
+            @player_state.deathtype = deathtype if deathtype
+            damage_player(
+              player_points,
+              pain_sound: true,
+              inflictor: inflictor || origin,
+              attacker: radius_attacker,
+              apply_momentum: false
+            )
+          end
+        end
+
+        @entities.each do |ent|
+          next unless ent.damageable?
+          next if ent.instance_variable_defined?(:@solid) && ent.instance_variable_get(:@solid) == SOLID_NOT
+          next if ent.brush_entity? && !damageable_brush_entity?(ent)
+          next if ent.equal?(ignore)
+
+          damage_pos = damageable_position(ent)
+          points = radius_damage_points(origin, radius_damage_center(ent), damage, radius)
+          if points.positive? && can_radius_damage_entity?(ent, damage_pos, origin)
+            points *= 0.5 if ent.equal?(radius_attacker)
+            ent.instance_variable_set(:@deathtype, deathtype) if deathtype
+            damage_entity(
+              ent,
+              radius_attacker_damage(points, attacker_player),
+              attacker: radius_attacker,
+              inflictor: inflictor || origin
+            )
+          end
+        end
+      end
+
+      def radius_damage_points(origin, center, damage, radius)
+        distance = (origin - center).length
+        return 0.0 if distance > radius
+
+        damage - 0.5 * distance
+      end
+
+      def can_radius_damage_position?(position, origin)
+        return true unless @level
+
+        offsets = [
+          Math::Vec3::ORIGIN,
+          Math::Vec3.new(15.0, 15.0, 0.0),
+          Math::Vec3.new(-15.0, -15.0, 0.0),
+          Math::Vec3.new(-15.0, 15.0, 0.0),
+          Math::Vec3.new(15.0, -15.0, 0.0)
+        ]
+        solid_brush = @entities.select(&:brush_entity?)
+        offsets.any? do |offset|
+          trace = Physics::HullTrace.trace_world_and_entities(
+            @level, origin, position + offset, solid_brush, hull_num: 0
+          )
+          trace.fraction >= 1.0
+        end
+      end
+
+      def can_radius_damage_entity?(ent, position, origin)
+        return true unless @level
+        return can_radius_damage_position?(position, origin) unless ent.brush_entity?
+
+        solid_brush = @entities.select(&:brush_entity?)
+        trace = Physics::HullTrace.trace_world_and_entities(
+          @level, origin, position, solid_brush, hull_num: 0
+        )
+        trace.fraction >= 1.0
+      end
+
+      def player_damage(amount)
+        multiplier = if @player_state&.powerup_active?(:quad, game_time: @game_time)
+                       deathmatch.to_i == 4 ? 8.0 : 4.0
+                     else
+                       1.0
+                     end
+        amount * multiplier
+      end
+
+      def radius_attacker_damage(amount, attacker_player)
+        attacker_player ? player_damage(amount) : amount
+      end
+
+      def projectile_owner_damage(projectile, amount)
+        player_attacker?(projectile.owner) ? player_damage(amount) : amount
+      end
+
+      def projectile_deathtype(projectile)
+        projectile.kind == :super_spike ? "supernail" : "nail"
+      end
+
+      def projectile_radius_deathtype(projectile)
+        case projectile.kind
+        when :rocket then "rocket"
+        when :grenade then "grenade"
+        end
+      end
+
+      def spike_lateral_offset(weapon)
+        return 0.0 if weapon == :super_nailgun
+
+        @spike_lateral_offset ||= 4.0
+        offset = @spike_lateral_offset
+        @spike_lateral_offset = -@spike_lateral_offset
+        offset
+      end
+
+      def crandom
+        2.0 * (rand - 0.5)
+      end
+
+      def angle_forward(angles)
+        yaw = angles.y * ::Math::PI / 180.0
+        pitch = angles.x * ::Math::PI / 180.0
+        cp = ::Math.cos(pitch)
+        Math::Vec3.new(::Math.cos(yaw) * cp, ::Math.sin(yaw) * cp, -::Math.sin(pitch))
+      end
+
+      def damage_entity(ent, amount, attacker: nil, inflictor: nil)
+        if damageable_brush_runtime_entity?(ent) && @brush_game
+          return true if @brush_game.damage_brush_entity(ent, amount, activator: damage_activator(attacker))
+        end
+
+        amount = quake_damage_amount(amount, attacker, inflictor)
+        was_alive = ent.damageable?
+        protected = entity_damage_protected?(ent)
+        old_armor = ent.armorvalue
+        damage = was_alive ? ent.absorb_damage(amount, game_time: @game_time) : { take: 0.0 }
+        taken = damage[:take].to_f
+        armor_saved = old_armor - ent.armorvalue
+        record_client_damage(ent, amount, armor_saved, inflictor) if was_alive
+        apply_damage_momentum(ent, amount, inflictor, attacker) if was_alive
+        return taken if was_alive && teamplay_damage_avoided?(ent, attacker, inflictor)
+
+        ent.apply_health_damage(taken) if was_alive && taken.positive?
+        armor_absorbed_damage = armor_saved.positive?
+        if was_alive && (taken.positive? || (armor_absorbed_damage && !protected))
+          if ent.removed?
+            killed_entity(ent, attacker)
+          else
+            react_to_entity_damage(ent, attacker)
+            call_entity_pain(ent, attacker, taken)
+          end
+        end
+        explode_box(ent) if was_alive && taken.positive? && ent.removed? && explobox?(ent)
+        taken
+      end
+
+      def entity_damage_protected?(ent)
+        return true if (ent.flags & Entity::FL_GODMODE) != 0
+
+        @game_time && ent.invincible_finished.positive? && ent.invincible_finished >= @game_time.to_f
+      end
+
+      def record_client_damage(ent, amount, armor_saved, inflictor)
+        return if (ent.flags & Entity::FL_CLIENT) == 0
+
+        ent.dmg_take += (amount.to_f - armor_saved).ceil
+        ent.dmg_save += armor_saved
+        ent.dmg_inflictor = inflictor
+      end
+
+      def teamplay_damage_avoided?(ent, attacker, inflictor)
+        return false unless [1, 3].include?(teamplay.to_i)
+        return false unless attacker.respond_to?(:classname) && attacker.classname == "player"
+        return false if inflictor.respond_to?(:classname) && inflictor.classname == "door"
+
+        attacker_team = quake_info_key(attacker, "team")
+        return false if attacker_team.empty?
+        return false unless quake_info_key(ent, "team") == attacker_team
+        return false if teamplay.to_i == 3 && ent.equal?(attacker)
+
+        true
+      end
+
+      def quake_info_key(ent, key)
+        return "" unless ent
+        return ent[key].to_s if ent.respond_to?(:[]) && ent[key]
+        return ent.public_send(key).to_s if ent.respond_to?(key)
+
+        value = ent.instance_variable_get(:"@#{key}") if ent.instance_variable_defined?(:"@#{key}")
+        value.to_s
+      end
+
+      def quake_damage_amount(amount, attacker, inflictor)
+        return amount unless attacker_quad_damage_active?(attacker, inflictor)
+
+        amount.to_f * (deathmatch.to_i == 4 ? 8.0 : 4.0)
+      end
+
+      def attacker_quad_damage_active?(attacker, inflictor)
+        return false unless attacker.respond_to?(:super_damage_finished)
+        return false if @game_time.nil?
+        return false if inflictor.respond_to?(:classname) && inflictor.classname == "door"
+
+        attacker.super_damage_finished > @game_time.to_f
+      end
+
+      def damage_activator(attacker)
+        return @player if attacker.nil? || attacker.equal?(@player_state)
+
+        attacker
+      end
+
+      def apply_player_direct_damage_momentum(amount, inflictor)
+        return unless @player&.instance_variable_get(:@movetype) == MOVETYPE_WALK
+
+        apply_player_damage_momentum(amount, inflictor)
+      end
+
+      def apply_player_damage_momentum(amount, inflictor)
+        return unless @player
+        return unless inflictor
+
+        center = inflictor_damage_center(inflictor)
+        return unless center
+
+        dir = (@player.position - center).normalize
+        @player.velocity = @player.velocity + dir * amount.to_f * 8.0
+        # T_Damage adds dir*damage*rj for self-inflicted player damage
+        # (rocket jumps) when the rj server setting exceeds 1
+        return unless rj.to_f > 1.0
+
+        @player.velocity = @player.velocity + dir * amount.to_f * rj.to_f
+      end
+
+      def apply_damage_momentum(ent, amount, inflictor, attacker = nil)
+        return unless inflictor
+        return unless ent.instance_variable_get(:@movetype) == MOVETYPE_WALK
+
+        center = inflictor_damage_center(inflictor)
+        return unless center
+
+        dir = (ent.position - center).normalize
+        ent.velocity = ent.velocity + dir * amount.to_f * 8.0
+        if rocket_jump_modifier_active?(ent, attacker)
+          ent.velocity = ent.velocity + dir * amount.to_f * rj.to_f
+        end
+      end
+
+      def rocket_jump_modifier_active?(ent, attacker)
+        return false unless rj.to_f > 1.0
+        return false unless ent.classname == "player"
+        return false unless attacker.respond_to?(:classname) && attacker.classname == "player"
+
+        quake_info_key(attacker, "netname") == quake_info_key(ent, "netname")
+      end
+
+      def inflictor_damage_center(inflictor)
+        return inflictor if inflictor.is_a?(Math::Vec3)
+        return nil unless inflictor.respond_to?(:position)
+        return inflictor.position + (ENTITY_HULL_MINS + ENTITY_HULL_MAXS) * 0.5 if inflictor.equal?(@player)
+
+        if inflictor.is_a?(Entity)
+          mins, maxs = damageable_bounds(inflictor)
+          return (mins + maxs) * 0.5 if mins && maxs
+        end
+
+        inflictor.position
+      end
+
+      def killed_entity(ent, attacker)
+        movetype = ent.instance_variable_get(:@movetype)
+        if movetype == MOVETYPE_PUSH || movetype == MOVETYPE_NONE
+          call_entity_die(ent)
+          return
+        end
+
+        ent.instance_variable_set(:@enemy, attacker)
+        @killed_monsters = @killed_monsters.to_i + 1 if (ent.flags & Entity::FL_MONSTER) != 0
+        ent.instance_variable_set(:@takedamage, 0)
+        ent.instance_variable_set(:@touch, nil)
+        ent.effects = 0
+        call_entity_die(ent)
+      end
+
+      def react_to_entity_damage(ent, attacker)
+        return unless attacker
+        return unless (ent.flags & Entity::FL_MONSTER) != 0
+        return if ent.equal?(attacker)
+        return if ent.instance_variable_get(:@enemy).equal?(attacker)
+        return if same_monster_class?(ent, attacker) && ent.classname != "monster_army"
+
+        current_enemy = ent.instance_variable_get(:@enemy)
+        ent.instance_variable_set(:@oldenemy, current_enemy) if player_attacker?(current_enemy)
+        ent.instance_variable_set(:@enemy, attacker)
+        ent.instance_variable_set(:@found_target, true)
+      end
+
+      def call_entity_pain(ent, attacker, damage)
+        pain = ent.instance_variable_get(:@th_pain)
+        return unless pain
+
+        ent.instance_variable_set(:@pain_function, pain)
+        ent.instance_variable_set(:@pain_attacker, attacker)
+        ent.instance_variable_set(:@pain_damage, damage.to_f)
+      end
+
+      def call_entity_die(ent)
+        die = ent.instance_variable_get(:@th_die)
+        if die
+          ent.instance_variable_set(:@die_function, die)
+          ent.instance_variable_set(:@die_enemy, ent.instance_variable_get(:@enemy))
+        end
+      end
+
+      def same_monster_class?(ent, attacker)
+        attacker.respond_to?(:classname) && ent.classname == attacker.classname
+      end
+
+      def player_attacker?(attacker)
+        attacker.is_a?(PlayerState) ||
+          (attacker.respond_to?(:classname) && attacker.classname == "player")
+      end
+
+      def trace_damageable_entity(src, dir, max_dist, ignore: [], ignore_solid_trigger: false)
+        best_ent = nil
+        best_t = max_dist
+
+        @entities.each do |ent|
+          next unless ent.damageable?
+          next if ignore.include?(ent)
+          next if ignore_solid_trigger && ent.instance_variable_get(:@solid) == 1
+
+          mins, maxs = damageable_bounds(ent)
+          next unless mins && maxs
+
+          hit_t = ray_aabb(src, dir, mins, maxs)
+          next unless hit_t
+          next if hit_t.negative? || hit_t > best_t
+
+          best_ent = ent
+          best_t = hit_t
+        end
+
+        return nil unless best_ent
+
+        [best_ent, src + dir * best_t]
+      end
+
+      def trace_axe_touch_entity(src, dir, max_dist)
+        trace_touch_entity(src, dir, max_dist)
+      end
+
+      def trace_bullet_touch_entity(src, dir, max_dist)
+        trace_touch_entity(src, dir, max_dist)
+      end
+
+      def trace_lightning_touch_entity(src, dir, max_dist)
+        trace_touch_entity(src, dir, max_dist)
+      end
+
+      def trace_spike_touch_entity(src, dir, max_dist, ignore: nil)
+        trace_touch_entity(src, dir, max_dist, ignore: ignore)
+      end
+
+      def trace_fireball_touch_entity(src, dir, max_dist, ignore: nil)
+        trace_touch_entity(src, dir, max_dist, ignore: ignore)
+      end
+
+      def trace_missile_touch_entity(src, dir, max_dist, ignore: nil)
+        trace_touch_entity(src, dir, max_dist, ignore: ignore)
+      end
+
+      def trace_laser_touch_entity(src, dir, max_dist, ignore: nil)
+        trace_touch_entity(src, dir, max_dist, ignore: ignore)
+      end
+
+      def trace_touch_entity(src, dir, max_dist, ignore: nil)
+        best_ent = nil
+        best_t = max_dist
+
+        @entities.each do |ent|
+          next if ent.removed?
+          next if ent.equal?(ignore)
+          # Traces never collide with SOLID_TRIGGER (1) pickups -- only
+          # damageable or genuinely solid (SOLID_BBOX and up) entities
+          next unless ent.damageable? || ent.instance_variable_get(:@solid).to_i >= SOLID_BBOX
+
+          mins, maxs = damageable_bounds(ent)
+          next unless mins && maxs
+
+          hit_t = ray_aabb(src, dir, mins, maxs)
+          next unless hit_t
+          next if hit_t.negative? || hit_t > best_t
+
+          best_ent = ent
+          best_t = hit_t
+        end
+
+        return nil unless best_ent
+
+        [best_ent, src + dir * best_t]
+      end
+
+      def damageable_bounds(ent)
+        if damageable_brush_runtime_entity?(ent)
+          return nil unless damageable_brush_entity?(ent)
+
+          model = damageable_brush_model(ent)
+          return nil unless model
+
+          [ent.position + model.mins, ent.position + model.maxs]
+        elsif explobox?(ent)
+          height = ent.classname == "misc_explobox2" ? 32.0 : 64.0
+          [ent.position, ent.position + Math::Vec3.new(32.0, 32.0, height)]
+        else
+          [ent.position + ENTITY_HULL_MINS, ent.position + ENTITY_HULL_MAXS]
+        end
+      end
+
+      def damageable_position(ent)
+        if damageable_brush_runtime_entity?(ent) && damageable_brush_entity?(ent)
+          model = damageable_brush_model(ent)
+          return ent.position + (model.mins + model.maxs) * 0.5 if model
+        end
+
+        ent.position
+      end
+
+      def radius_damage_center(ent)
+        mins, maxs = damageable_bounds(ent)
+        return damageable_position(ent) unless mins && maxs
+
+        (mins + maxs) * 0.5
+      end
+
+      def damageable_brush_entity?(ent)
+        ent.classname.start_with?("trigger_") ||
+          ent.classname == "func_button" ||
+          ent.classname == "func_door" ||
+          ent.instance_variable_get(:@regular_door) ||
+          ent.instance_variable_get(:@secret_door)
+      end
+
+      def damageable_brush_runtime_entity?(ent)
+        ent.brush_entity? || !ent.instance_variable_get(:@trigger_model_index).nil?
+      end
+
+      def damageable_brush_model(ent)
+        model_index = ent.model_index || ent.instance_variable_get(:@trigger_model_index)
+        @level.models[model_index] if model_index && @level
+      end
+
+      def explobox?(ent)
+        ent.classname == "misc_explobox" || ent.classname == "misc_explobox2"
+      end
+
+      def explode_box(ent)
+        ent.instance_variable_set(:@takedamage, 0)
+        ent.classname = "explo_box"
+        apply_radius_damage(ent.position, 160.0, ignore: ent, attacker_player: false, attacker: ent, inflictor: ent)
+        play_temp_explosion_sound
+        effect_position = ent.position + Math::Vec3.new(0.0, 0.0, 32.0)
+        add_temp_explosion_dynamic_light(effect_position)
+        @particles&.explosion(effect_position)
+      end
+
+      def play_temp_explosion_sound
+        @sound_events&.on_weapon_fire(WeaponSound.new(sound: "weapons/r_exp3.wav"))
+      end
+
+      def ray_aabb(origin, dir, mins, maxs)
+        t_min = 0.0
+        t_max = Float::INFINITY
+
+        [:x, :y, :z].each do |axis|
+          o = origin.public_send(axis)
+          d = dir.public_send(axis)
+          min = mins.public_send(axis)
+          max = maxs.public_send(axis)
+
+          if d.abs < 0.000001
+            return nil if o < min || o > max
+            next
+          end
+
+          inv = 1.0 / d
+          t1 = (min - o) * inv
+          t2 = (max - o) * inv
+          t1, t2 = t2, t1 if t1 > t2
+
+          t_min = [t_min, t1].max
+          t_max = [t_max, t2].min
+          return nil if t_min > t_max
+        end
+
+        t_min
+      end
+
+      def aabb_intersect?(mins_a, maxs_a, mins_b, maxs_b)
+        mins_a.x <= maxs_b.x && maxs_a.x >= mins_b.x &&
+          mins_a.y <= maxs_b.y && maxs_a.y >= mins_b.y &&
+          mins_a.z <= maxs_b.z && maxs_a.z >= mins_b.z
+      end
     end
   end
 end