quake-rb 0.1.0 → 0.2.0

data/lib/quake/game/brush_entities.rb

@@ -5,42 +5,75 @@ module Quake
     # Manages brush entity behavior: doors, platforms, buttons, triggers.
     # Each entity has a state machine and moves between positions.
     class BrushEntities
+      BUTTON_TOUCH_RADIUS = 40.0
       # Entity states
       STATE_IDLE     = :idle
       STATE_OPENING  = :opening
       STATE_OPEN     = :open
       STATE_CLOSING  = :closing
       STATE_CLOSED   = :closed
+      PLAT_LOW_TRIGGER = 1
+      FL_FLY          = 1
+      FL_SWIM         = 2
+      FL_MONSTER      = 32
+      FL_ONGROUND     = 512
 
-      def initialize(entities, level, target_map)
+      attr_reader :total_secrets, :found_secrets
+
+      def initialize(entities, level, target_map, registered: false, sound_events: nil, serverflags: 0, worldtype: 0)
         @entities = entities
         @level = level
         @target_map = target_map
-        @brush_entities = entities.select(&:brush_entity?)
+        @registered = registered
+        @sound_events = sound_events
+        @serverflags = serverflags.to_i
+        @worldtype = worldtype.to_i
+        @time = 0.0
+        @total_secrets = 0
+        @found_secrets = 0
+        @brush_entities = entities.select { |ent| ent.brush_entity? || ent.classname == "misc_teleporttrain" }
+        @delayed_uses = []
 
+        @entities.each { |ent| init_point_trigger(ent) }
         # Initialize movement data for each brush entity
         @brush_entities.each { |ent| init_brush_entity(ent) }
+        link_doors
 
         puts "Initialized #{@brush_entities.size} brush entities"
       end
 
       # Update all brush entities. Returns entities that need rendering.
-      def update(dt, player_pos)
+      def update(dt, player_pos, player_state: nil)
+        @time_step = dt
+        @time += dt
+        update_delayed_uses(dt)
+        @entities.each { |ent| update_scheduled_remove(ent, dt) }
+
         # Save previous positions for platform-riding
         @brush_entities.each do |ent|
           ent.instance_variable_set(:@prev_pos, ent.position)
         end
 
         @brush_entities.each do |ent|
+          next if ent.instance_variable_get(:@removed)
+
+          update_trigger_cooldown(ent, dt)
+
           case ent.classname
-          when "func_door"
-            update_door(ent, dt, player_pos)
-          when "func_plat"
-            update_platform(ent, dt, player_pos)
+          when "func_door", "door"
+            if secret_door?(ent)
+              update_secret_door(ent, player_pos, player_state)
+            else
+              update_door(ent, dt, player_pos, player_state)
+            end
+          when "func_plat", "plat"
+            update_platform(ent, dt, player_pos, player_state)
           when "func_button"
-            update_button(ent, dt, player_pos)
-          when "func_train"
-            update_train(ent, dt)
+            update_button(ent, dt, player_pos, player_state)
+          when "func_train", "train", "misc_teleporttrain"
+            update_train(ent, dt, player_pos, player_state)
+          when "func_door_secret"
+            update_secret_door(ent, player_pos, player_state)
           end
         end
 
@@ -51,9 +84,11 @@ module Quake
       # position snapped to the platform's top surface (so on_ground stays
       # true and the player rides smoothly). Returns nil if not on a
       # moving platform.
+      VERTICAL_RIDER_CLASSNAMES = %w[func_plat plat func_door door].freeze
+
       def snap_to_platform(player_pos)
         @brush_entities.each do |ent|
-          next unless ent.classname == "func_plat"
+          next unless VERTICAL_RIDER_CLASSNAMES.include?(ent.classname)
           model = @level.models[ent.model_index]
           next unless model
 
@@ -61,21 +96,25 @@ module Quake
           next unless prev
 
           ent_delta_z = ent.position.z - prev.z
+          # Doors join the rider check only while actually moving
+          # vertically (elevators like e1m1's t1 are vertical func_doors --
+          # SV_PushMove carries riders for every pusher, not just plats).
+          next if ent.classname.include?("door") && ent_delta_z.zero?
 
           # Use the OLD platform position for the on_top check, since
           # player_pos hasn't been updated for this frame's movement yet.
+          # The player origin rides 24 above the surface (hull mins.z -24).
           old_top_z = prev.z + model.maxs.z
-          next unless player_pos.z >= old_top_z - 8 && player_pos.z <= old_top_z + 24
+          next unless player_pos.z >= old_top_z + 16 && player_pos.z <= old_top_z + 48
           next unless player_pos.x >= ent.position.x + model.mins.x &&
                       player_pos.x <= ent.position.x + model.maxs.x &&
                       player_pos.y >= ent.position.y + model.mins.y &&
                       player_pos.y <= ent.position.y + model.maxs.y
 
-          # Snap to the new platform top surface, slightly above so the
-          # trace-down ground check can detect it cleanly (avoid epsilon
-          # edge case at exact plane boundary).
-          new_top_z = ent.position.z + model.maxs.z + 0.5
-          return Math::Vec3.new(player_pos.x, player_pos.y, new_top_z)
+          # Snap the origin to 24 above the new top surface (feet slightly
+          # above it so the trace-down ground check detects it cleanly).
+          new_top_z = ent.position.z + model.maxs.z
+          return Math::Vec3.new(player_pos.x, player_pos.y, new_top_z + 24.5)
         end
         nil
       end
@@ -88,12 +127,18 @@ module Quake
       end
 
       # Check if player touches any trigger entities
-      def check_triggers(player_pos, player_radius: 16.0)
+      def check_triggers(player_pos, player_radius: 16.0, player_forward: nil)
         @entities.each do |ent|
           next unless ent.classname.start_with?("trigger_")
-          next unless ent.brush_entity?
+          next unless trigger_model_index(ent)
+          next if ent.instance_variable_get(:@removed)
+          next if ent.instance_variable_get(:@touch_disabled)
+          next if notouch_trigger?(ent)
+          next if health_trigger?(ent)
+          next unless trigger_facing_allowed?(ent, player_forward)
+          next if trigger_cooldown_active?(ent)
 
-          model = @level.models[ent.model_index]
+          model = @level.models[trigger_model_index(ent)]
           next unless model
 
           # Simple AABB check against player
@@ -107,40 +152,292 @@ module Quake
              player_pos.y <= origin.y + maxs.y + player_radius &&
              player_pos.z >= origin.z + mins.z - player_radius &&
              player_pos.z <= origin.z + maxs.z + player_radius
-            fire_targets(ent.target) if ent.target
             yield ent if block_given?
           end
         end
       end
 
+      # QuakeC SUB_UseTargets, limited to local entity state transitions.
+      # The engine owns side effects like changelevel and teleport movement.
+      def use_targets(source, activator: nil)
+        delay = (source["delay"] || "0").to_f
+        unless delay.zero?
+          @delayed_uses << {
+            remaining: delay,
+            message: source.message,
+            killtarget: source.killtarget,
+            target: source.target,
+            activator: activator || source
+          }
+          return
+        end
+
+        fire_use_targets(
+          source.killtarget,
+          source.target,
+          activator: activator || source,
+          message: source.message,
+          source_noise: source.instance_variable_get(:@noise)
+        )
+      end
+
+      def touch_trigger(ent, activator: nil)
+        return false if ent.instance_variable_get(:@touch_disabled)
+        return false if trigger_cooldown_active?(ent)
+
+        case ent.classname
+        when "trigger_once"
+          return false unless activator&.classname == "player"
+          return false unless trigger_touch_facing_allowed?(ent, activator)
+
+          activate_multi_trigger(ent, activator: activator)
+        when "trigger_secret"
+          return false unless trigger_touch_facing_allowed?(ent, activator)
+
+          touch_secret_trigger(ent, activator: activator)
+        when "trigger_multiple"
+          return false unless activator&.classname == "player"
+          return false unless trigger_touch_facing_allowed?(ent, activator)
+
+          activate_multi_trigger(ent, activator: activator)
+        when "trigger_onlyregistered"
+          touch_onlyregistered(ent, activator: activator)
+        when "trigger_monsterjump"
+          touch_monsterjump(ent, activator)
+        when "trigger_push"
+          touch_push(ent, activator)
+        when "trigger_hurt"
+          touch_hurt(ent, activator)
+        else
+          false
+        end
+      end
+
+      def damage_trigger(ent, amount, activator: nil)
+        damage_brush_entity(ent, amount, activator: activator)
+      end
+
+      def damage_brush_entity(ent, amount, activator: nil)
+        return damage_button(ent, amount, activator: activator) if ent.classname == "func_button"
+        return damage_door(ent, amount, activator: activator) if regular_door?(ent)
+        return damage_secret_door(ent, activator: activator) if secret_door?(ent)
+        return false unless ["trigger_once", "trigger_multiple", "trigger_secret"].include?(ent.classname)
+        return false unless ent.health.positive?
+
+        ent.instance_variable_set(:@max_health, ent.health) unless ent.instance_variable_get(:@max_health)
+        ent.health -= amount.to_f.ceil
+        return true if ent.health.positive?
+
+        ent.health = -99.0 if ent.health < -99.0
+        activate_multi_trigger(ent, activator: activator || ent)
+        true
+      end
+
       private
 
+      def activate_multi_trigger(ent, activator:)
+        return false if multi_trigger_waiting?(ent)
+        return touch_secret_trigger(ent, activator: activator) if ent.classname == "trigger_secret"
+
+        ent.instance_variable_set(:@takedamage, 0)
+        play_trigger_sound(ent)
+        use_targets(ent, activator: activator)
+        if ent.wait.negative?
+          ent.instance_variable_set(:@touch_disabled, true)
+          schedule_remove(ent, 0.1)
+        else
+          ent.instance_variable_set(:@think, :multi_wait)
+          ent.think_time = ent.wait.positive? ? ent.wait : 0.2
+        end
+        true
+      end
+
+      def init_point_trigger(ent)
+        case ent.classname
+        when "trigger_relay"
+          ent.instance_variable_set(:@use, :SUB_UseTargets)
+        when "trigger_counter"
+          ent.wait = -1.0
+          ent.count = 2 if ent.count.zero?
+          ent.instance_variable_set(:@use, :counter_use)
+        end
+      end
+
       def init_brush_entity(ent)
+        if ent.classname == "misc_teleporttrain"
+          init_moving_entity(ent, Math::Vec3::ORIGIN)
+          setup_teleport_train(ent)
+          return
+        end
+
         return unless ent.model_index
 
         model = @level.models[ent.model_index]
         return unless model
 
-        # Store the closed (original) position
-        ent.instance_variable_set(:@closed_pos, ent.position)
-        ent.instance_variable_set(:@open_pos, ent.position)
-        ent.instance_variable_set(:@move_fraction, 0.0)
+        init_moving_entity(ent, model.mins)
+        ent.instance_variable_set(:@trigger_model_index, ent.model_index) if init_trigger_class?(ent)
+        ent.instance_variable_set(:@max_health, ent.health) if health_trigger?(ent)
 
         case ent.classname
+        when "trigger_teleport"
+          setup_teleport_trigger(ent)
+        when "trigger_changelevel"
+          setup_changelevel_trigger(ent)
+        when "trigger_hurt"
+          setup_hurt_trigger(ent)
+        when "trigger_onlyregistered"
+          setup_onlyregistered_trigger(ent)
+        when "trigger_setskill"
+          remove_entity(ent)
+        when "trigger_once", "trigger_multiple"
+          setup_multi_trigger(ent)
+        when "trigger_secret"
+          setup_secret_trigger(ent)
+        when "trigger_push"
+          setup_push_trigger(ent)
+        when "trigger_monsterjump"
+          setup_monsterjump_trigger(ent)
         when "func_door"
           setup_door(ent, model)
+        when "func_door_secret"
+          setup_secret_door(ent, model)
         when "func_plat"
           setup_platform(ent, model)
         when "func_button"
           setup_button(ent, model)
+        when "func_train"
+          setup_train(ent, model)
+        when "func_wall", "func_illusionary"
+          setup_static_brush_model(ent)
+        when "func_episodegate"
+          setup_episode_gate(ent)
+        when "func_bossgate"
+          setup_boss_gate(ent)
         end
       end
 
+      def setup_teleport_trigger(ent)
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@touch, :teleport_touch)
+        ent.instance_variable_set(:@use, :teleport_use)
+        raise "no target" if ent.target.nil? || ent.target.empty?
+      end
+
+      def setup_changelevel_trigger(ent)
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@touch, :changelevel_touch)
+        raise "chagnelevel trigger doesn't have map" if ent["map"].nil? || ent["map"].empty?
+      end
+
+      def setup_hurt_trigger(ent)
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@touch, :hurt_touch)
+        ent.properties["dmg"] = "5" if ent["dmg"].nil? || ent["dmg"].to_f.zero?
+      end
+
+      def setup_onlyregistered_trigger(ent)
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@touch, :trigger_onlyregistered_touch)
+        ent.instance_variable_set(:@noise, "misc/talk.wav")
+      end
+
+      def init_moving_entity(ent, mins)
+        ent.instance_variable_set(:@closed_pos, ent.position)
+        ent.instance_variable_set(:@open_pos, ent.position)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+        ent.instance_variable_set(:@train_mins, mins)
+      end
+
       DOOR_START_OPEN = 1
+      DOOR_DONT_LINK = 4
+      DOOR_GOLD_KEY = 8
+      DOOR_SILVER_KEY = 16
+      DOOR_TOGGLE = 32
+      SECRET_NO_SHOOT = 8
+      SECRET_YES_SHOOT = 16
+
+      def setup_secret_trigger(ent)
+        @total_secrets += 1
+        ent.wait = -1.0
+        ent.message ||= "You found a secret area!"
+        ent.sounds = 1 if ent.sounds.zero?
+        case ent.sounds
+        when 1
+          ent.instance_variable_set(:@noise, "misc/secret.wav")
+        when 2
+          ent.instance_variable_set(:@noise, "misc/talk.wav")
+        end
+        setup_multi_trigger(ent)
+      end
+
+      def setup_multi_trigger(ent)
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@use, :multi_use)
+        if ent.health.positive? && (ent.spawnflags & 1) != 0
+          raise "health and notouch don't make sense"
+        end
+
+        case ent.sounds
+        when 1
+          ent.instance_variable_set(:@noise, "misc/secret.wav")
+        when 2
+          ent.instance_variable_set(:@noise, "misc/talk.wav")
+        when 3
+          ent.instance_variable_set(:@noise, "misc/trigger1.wav")
+        end
+
+        unless ent.health.positive?
+          ent.instance_variable_set(:@touch, :multi_touch) if (ent.spawnflags & 1).zero?
+          return
+        end
+
+        ent.instance_variable_set(:@takedamage, 1)
+        ent.instance_variable_set(:@solid, 2)
+        ent.instance_variable_set(:@max_health, ent.health)
+        ent.instance_variable_set(:@th_die, :multi_killed)
+      end
+
+      def setup_push_trigger(ent)
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@touch, :trigger_push_touch)
+        ent.speed = 1000.0 if ent.speed.zero?
+      end
+
+      def setup_monsterjump_trigger(ent)
+        ent.speed = 200.0 if ent.speed.zero?
+        ent.height = 200.0 if ent.height.zero?
+        if ent.angles == Math::Vec3::ORIGIN && (!ent["angle"] || ent["angle"].to_f.zero?)
+          ent.angles = Math::Vec3.new(0.0, 360.0, 0.0)
+        end
+        setup_init_trigger(ent)
+        ent.instance_variable_set(:@touch, :trigger_monsterjump_touch)
+      end
+
+      def setup_init_trigger(ent)
+        if ent.angles != Math::Vec3::ORIGIN
+          ent.move_dir = ent.forward_vector
+          ent.angles = Math::Vec3::ORIGIN
+        end
+        ent.instance_variable_set(:@solid, 1)
+        ent.instance_variable_set(:@movetype, 0)
+        ent.properties["model"] = ""
+        ent.model_index = nil
+      end
 
       def setup_door(ent, model)
-        # Calculate move direction from angle
+        setup_bsp_push(ent)
+        ent.instance_variable_set(:@blocked, :door_blocked)
+        ent.instance_variable_set(:@use, :door_use)
+        ent.instance_variable_set(:@touch, :door_touch)
+        ent.instance_variable_set(:@think, :LinkDoors)
+        ent.instance_variable_set(:@nextthink, @time + 0.1)
+        ent.properties["dmg"] = "2" if ent["dmg"].nil? || ent["dmg"].to_f.zero?
+        # QuakeC SetMovedir consumes the authored angle and clears it.
         dir = ent.forward_vector
+        ent.move_dir = dir
+        ent.angle = 0.0
+        ent.angles = Math::Vec3::ORIGIN
         size = model.maxs - model.mins
         move_dist = dir.x.abs * size.x + dir.y.abs * size.y + dir.z.abs * size.z
         move_dist -= ent.lip
@@ -159,9 +456,106 @@ module Quake
           ent.instance_variable_set(:@closed_pos, pos1)
           ent.instance_variable_set(:@open_pos, pos2)
         end
+        ent.instance_variable_set(:@max_health, ent.health) if ent.health.positive?
+        if ent.health.positive?
+          ent.instance_variable_set(:@takedamage, 1)
+          ent.instance_variable_set(:@th_die, :door_killed)
+        end
+        ent.instance_variable_set(:@regular_door, true)
+        apply_door_noise(ent)
+        apply_key_door_noise(ent)
+        ent.classname = "door"
+
+        if (spawnflags & DOOR_SILVER_KEY) != 0
+          ent.instance_variable_set(:@required_key, :silver)
+          ent.wait = -1.0
+        end
+        if (spawnflags & DOOR_GOLD_KEY) != 0
+          ent.instance_variable_set(:@required_key, :gold)
+          ent.wait = -1.0
+        end
+      end
+
+      def apply_door_noise(ent)
+        noise1, noise2 = case ent.sounds
+                         when 1
+                           ["doors/drclos4.wav", "doors/doormv1.wav"]
+                         when 2
+                           ["doors/hydro2.wav", "doors/hydro1.wav"]
+                         when 3
+                           ["doors/stndr2.wav", "doors/stndr1.wav"]
+                         when 4
+                           ["doors/ddoor2.wav", "doors/ddoor1.wav"]
+                         else
+                           ["misc/null.wav", "misc/null.wav"]
+                         end
+        ent.instance_variable_set(:@noise1, noise1)
+        ent.instance_variable_set(:@noise2, noise2)
+      end
+
+      def apply_key_door_noise(ent)
+        noise3, noise4 = case @worldtype
+                         when 1
+                           ["doors/runetry.wav", "doors/runeuse.wav"]
+                         when 2
+                           ["doors/basetry.wav", "doors/baseuse.wav"]
+                         else
+                           ["doors/medtry.wav", "doors/meduse.wav"]
+                         end
+        ent.instance_variable_set(:@noise3, noise3)
+        ent.instance_variable_set(:@noise4, noise4)
+      end
+
+      def setup_secret_door(ent, model)
+        setup_bsp_push(ent)
+        ent.sounds = 3 if ent.sounds.zero?
+        apply_secret_door_noise(ent)
+        ent.speed = 50.0
+        ent.wait = 5.0 unless ent["wait"] && ent.wait.nonzero?
+        ent.properties["dmg"] = "2" if ent["dmg"].nil? || ent["dmg"].to_f.zero?
+        ent.instance_variable_set(:@dmg, ent["dmg"].to_f)
+        ent.instance_variable_set(:@oldorigin, ent.position)
+        ent.instance_variable_set(:@mangle, ent.angles)
+        ent.angles = Math::Vec3::ORIGIN
+        ent.instance_variable_set(:@touch, :secret_touch)
+        ent.instance_variable_set(:@blocked, :secret_blocked)
+        ent.instance_variable_set(:@use, :fd_secret_use)
+        ent.instance_variable_set(:@secret_door, true)
+        ent.instance_variable_set(:@secret_size, model.maxs - model.mins)
+        ent.classname = "door"
+        return unless secret_door_shootable?(ent)
+
+        ent.health = 10_000.0
+        ent.instance_variable_set(:@max_health, 10_000.0)
+        ent.instance_variable_set(:@takedamage, 1)
+        ent.instance_variable_set(:@th_pain, :fd_secret_use)
+        ent.instance_variable_set(:@th_die, :fd_secret_use)
+      end
+
+      def apply_secret_door_noise(ent)
+        noise1, noise2, noise3 = case ent.sounds
+                                 when 1
+                                   ["doors/latch2.wav", "doors/winch2.wav", "doors/drclos4.wav"]
+                                 when 2
+                                   ["doors/airdoor2.wav", "doors/airdoor1.wav", "doors/airdoor2.wav"]
+                                 else
+                                   ["doors/basesec2.wav", "doors/basesec1.wav", "doors/basesec2.wav"]
+                                 end
+        ent.instance_variable_set(:@noise1, noise1)
+        ent.instance_variable_set(:@noise2, noise2)
+        ent.instance_variable_set(:@noise3, noise3)
       end
 
       def setup_platform(ent, model)
+        setup_bsp_push(ent)
+        ent.sounds = 2 if ent.sounds.zero?
+        apply_platform_noise(ent)
+        ent.wait = 3.0
+        ent.instance_variable_set(:@mangle, ent.angles)
+        ent.angles = Math::Vec3::ORIGIN
+        ent.instance_variable_set(:@blocked, :plat_crush)
+        ent.classname = "plat"
+
         # In Quake, the map origin is the TOP position.
         # See plats.qc func_plat:
         #   pos1 = top (authored origin)
@@ -170,7 +564,7 @@ module Quake
         # the player steps on them. Platforms WITH a targetname start at
         # the top and go down when triggered.
         size = model.maxs - model.mins
-        height = size.z - 8.0
+        height = ent["height"].to_f.positive? ? ent["height"].to_f : (size.z - 8.0)
 
         top_pos = ent.position
         bottom_pos = Math::Vec3.new(top_pos.x, top_pos.y, top_pos.z - height)
@@ -179,108 +573,413 @@ module Quake
           # Targeted: start at top, button press lowers it
           ent.instance_variable_set(:@closed_pos, top_pos)
           ent.instance_variable_set(:@open_pos, bottom_pos)
+          ent.instance_variable_set(:@targeted_platform, true)
+          ent.instance_variable_set(:@use, :plat_use)
         else
           # Normal: start at bottom, player steps on to ride up
           ent.position = bottom_pos
           ent.instance_variable_set(:@closed_pos, bottom_pos)
           ent.instance_variable_set(:@open_pos, top_pos)
+          ent.instance_variable_set(:@use, :plat_trigger_use)
         end
       end
 
+      def apply_platform_noise(ent)
+        noise, noise1 = case ent.sounds
+                        when 1
+                          ["plats/plat1.wav", "plats/plat2.wav"]
+                        else
+                          ["plats/medplat1.wav", "plats/medplat2.wav"]
+                        end
+        ent.instance_variable_set(:@noise, noise)
+        ent.instance_variable_set(:@noise1, noise1)
+      end
+
       def setup_button(ent, model)
+        setup_bsp_push(ent)
+        ent.instance_variable_set(:@blocked, :button_blocked)
+        ent.instance_variable_set(:@use, :button_use)
         dir = ent.forward_vector
+        ent.move_dir = dir
+        ent.angle = 0.0
+        ent.angles = Math::Vec3::ORIGIN
         size = model.maxs - model.mins
         move_dist = dir.x.abs * size.x + dir.y.abs * size.y + dir.z.abs * size.z
         move_dist -= ent.lip
 
         ent.instance_variable_set(:@open_pos, ent.position + dir * move_dist)
+        ent.instance_variable_set(:@max_health, ent.health) if ent.health.positive?
+        if ent.health.positive?
+          ent.instance_variable_set(:@takedamage, 1)
+          ent.instance_variable_set(:@th_die, :button_killed)
+        else
+          ent.instance_variable_set(:@touch, :button_touch)
+        end
+        ent.instance_variable_set(:@noise, button_noise(ent.sounds))
+      end
+
+      def setup_train(ent, model)
+        raise "func_train without a target" if ent.target.nil? || ent.target.empty?
+
+        setup_bsp_push(ent)
+        ent.instance_variable_set(:@cnt, 1)
+        ent.instance_variable_set(:@blocked, :train_blocked)
+        ent.instance_variable_set(:@use, :train_use)
+        ent.properties["dmg"] = "2" if ent["dmg"].nil? || ent["dmg"].to_f.zero?
+        apply_train_noise(ent)
+        ent.instance_variable_set(:@train_mins, model.mins)
+        ent.classname = "train"
+        ent.think_time = 0.1
+        ent.instance_variable_set(:@think, :func_train_find)
+      end
+
+      def setup_teleport_train(ent)
+        raise "func_train without a target" if ent.target.nil? || ent.target.empty?
+
+        ent.instance_variable_set(:@solid, 0)
+        ent.instance_variable_set(:@movetype, 7)
+        ent.instance_variable_set(:@cnt, 1)
+        ent.instance_variable_set(:@blocked, :train_blocked)
+        ent.instance_variable_set(:@use, :train_use)
+        ent.instance_variable_set(:@noise, "misc/null.wav")
+        ent.instance_variable_set(:@noise1, "misc/null.wav")
+        ent.instance_variable_set(:@avelocity, Math::Vec3.new(100.0, 200.0, 300.0))
+        ent.properties["model"] = "progs/teleport.mdl"
+        ent.instance_variable_set(:@train_mins, Math::Vec3::ORIGIN)
+        ent.think_time = 0.1
+        ent.instance_variable_set(:@think, :func_train_find)
+      end
+
+      def link_doors
+        doors = @brush_entities.select { |ent| regular_door?(ent) }
+        doors.each do |door|
+          next if door.instance_variable_get(:@enemy)
+
+          group = collect_linked_door_chain(door, doors)
+          group.each_with_index do |member, index|
+            member.instance_variable_set(:@door_group, group)
+            member.instance_variable_set(:@owner, group.first)
+            member.instance_variable_set(:@enemy, group[(index + 1) % group.length])
+          end
+          apply_linked_door_owner_fields(group)
+        end
+      end
+
+      def apply_linked_door_owner_fields(group)
+        owner = group.first
+        group.each do |member|
+          owner.health = member.health if member.health.positive?
+          owner.targetname = member.targetname if member.targetname
+          owner.message = member.message if member.message && !member.message.empty?
+        end
+      end
+
+      def collect_linked_door_chain(door, doors)
+        return [door] if (door.spawnflags & DOOR_DONT_LINK) != 0
+
+        group = [door]
+        current = door
+        loop do
+          candidate = doors[(doors.index(current) + 1)..]&.find do |later|
+            next false unless door_bounds_touch?(current, later)
+            raise "cross connected doors" if later.instance_variable_get(:@enemy)
+
+            true
+          end
+
+          unless candidate
+            current.instance_variable_set(:@enemy, door)
+            break
+          end
+
+          current.instance_variable_set(:@enemy, candidate)
+          group << candidate
+          current = candidate
+        end
+
+        group
+      end
+
+      def door_bounds_touch?(left, right)
+        left_model = @level.models[left.model_index]
+        right_model = @level.models[right.model_index]
+        return false unless left_model && right_model
+
+        left_mins = left.position + left_model.mins
+        left_maxs = left.position + left_model.maxs
+        right_mins = right.position + right_model.mins
+        right_maxs = right.position + right_model.maxs
+
+        left_mins.x <= right_maxs.x && left_maxs.x >= right_mins.x &&
+          left_mins.y <= right_maxs.y && left_maxs.y >= right_mins.y &&
+          left_mins.z <= right_maxs.z && left_maxs.z >= right_mins.z
+      end
+
+      def apply_train_noise(ent)
+        noise, noise1 = if ent.sounds == 1
+                          ["plats/train2.wav", "plats/train1.wav"]
+                        else
+                          ["misc/null.wav", "misc/null.wav"]
+                        end
+        ent.instance_variable_set(:@noise, noise)
+        ent.instance_variable_set(:@noise1, noise1)
+      end
+
+      def setup_bsp_push(ent)
+        ent.instance_variable_set(:@solid, 4)
+        ent.instance_variable_set(:@movetype, 7)
       end
 
-      def update_door(ent, dt, player_pos)
+      def button_noise(sounds)
+        case sounds
+        when 1 then "buttons/switch21.wav"
+        when 2 then "buttons/switch02.wav"
+        when 3 then "buttons/switch04.wav"
+        else "buttons/airbut1.wav"
+        end
+      end
+
+      def setup_episode_gate(ent)
+        if (@serverflags & ent.spawnflags).zero?
+          setup_inactive_gate(ent)
+        else
+          setup_static_brush_model(ent)
+        end
+      end
+
+      def setup_boss_gate(ent)
+        if (@serverflags & 15) == 15
+          setup_inactive_gate(ent)
+        else
+          setup_static_brush_model(ent)
+        end
+      end
+
+      def setup_inactive_gate(ent)
+        ent.model_index = nil
+        ent.instance_variable_set(:@movetype, 0)
+        ent.instance_variable_set(:@solid, 0)
+      end
+
+      def setup_static_brush_model(ent)
+        ent.angle = 0.0
+        ent.angles = Math::Vec3::ORIGIN
+        if ent.classname == "func_illusionary"
+          ent.instance_variable_set(:@movetype, 0)
+          ent.instance_variable_set(:@solid, 0)
+          ent.instance_variable_set(:@static, true)
+        else
+          ent.instance_variable_set(:@movetype, 7)
+          ent.instance_variable_set(:@solid, 4)
+          ent.instance_variable_set(:@use, :func_wall_use)
+        end
+      end
+
+      def update_door(ent, dt, player_pos, player_state)
+        if toggle_door?(ent) && ent.instance_variable_get(:@triggered) &&
+           [STATE_OPENING, STATE_OPEN].include?(ent.state)
+          ent.instance_variable_set(:@triggered, false)
+          ent.instance_variable_set(:@trigger_activator, nil)
+          ent.state = STATE_CLOSING
+          ent.instance_variable_set(:@move_fraction, 0.0)
+        elsif toggle_door?(ent) && ent.instance_variable_get(:@triggered) && ent.state == STATE_CLOSING
+          activator = ent.instance_variable_get(:@trigger_activator) || player_state || ent
+          ent.instance_variable_set(:@triggered, false)
+          ent.instance_variable_set(:@trigger_activator, nil)
+          ent.state = STATE_OPENING
+          use_door_targets(ent, activator: activator)
+          clear_linked_door_messages(ent)
+          ent.instance_variable_set(:@move_fraction, 0.0)
+        end
+
         case ent.state
         when STATE_IDLE, STATE_CLOSED
-          # Check if player is near or if targeted
-          if near_entity?(ent, player_pos, 128.0) || ent.instance_variable_get(:@triggered)
-            ent.state = STATE_OPENING
-            ent.instance_variable_set(:@triggered, false)
+          # Check if player is touching the door, its generated trigger field, or if targeted.
+          door_touch = door_model_touch?(ent, player_pos)
+          trigger_touch = door_trigger_field_touch?(ent, player_pos)
+          keyed_door = linked_door_keyed?(ent)
+          key_touch = keyed_door && door_touch
+          triggered = ent.instance_variable_get(:@triggered)
+          door_touch_allowed = !door_touch || door_touch_allowed?(ent, player_state)
+          trigger_touch_allowed = !trigger_touch || door_trigger_touch_allowed?(ent)
+          touch_door_message(ent, player_state) if door_touch && door_touch_allowed
+          touch_opens = if key_touch
+                          door_touch_allowed && unlock_door?(ent, player_state)
+                        elsif trigger_touch
+                          trigger_touch_allowed && unlock_door?(ent, player_state)
+                        else
+                          false
+                        end
+          if triggered || (touch_activated_door?(ent) && touch_opens)
+            activator = ent.instance_variable_get(:@trigger_activator) || player_state || ent
+            use_door(ent, activator: activator)
           end
         when STATE_OPENING
+          if ent.instance_variable_get(:@activated_at_time) == @time
+            ent.instance_variable_set(:@activated_at_time, nil)
+            return
+          end
+
           move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+          door_blocked(ent, player_pos, player_state)
           if ent.instance_variable_get(:@move_fraction) >= 1.0
             ent.state = STATE_OPEN
             ent.think_time = ent.wait
+            play_brush_noise(ent, :@noise1)
           end
         when STATE_OPEN
+          if ent.instance_variable_get(:@triggered) && !toggle_door?(ent)
+            ent.instance_variable_set(:@triggered, false)
+            ent.instance_variable_set(:@trigger_activator, nil)
+            ent.think_time = ent.wait
+          end
           ent.think_time -= dt
-          if ent.think_time <= 0 && ent.wait >= 0
+          if ent.think_time <= 0 && ent.wait >= 0 && !toggle_door?(ent)
+            ent.health = ent.instance_variable_get(:@max_health) if shootable_door?(ent)
+            ent.instance_variable_set(:@shot_disabled, false)
+            ent.instance_variable_set(:@takedamage, 1) if shootable_door?(ent)
+            play_brush_noise(ent, :@noise2)
             ent.state = STATE_CLOSING
           end
         when STATE_CLOSING
+          if ent.instance_variable_get(:@activated_at_time) == @time
+            ent.instance_variable_set(:@activated_at_time, nil)
+            return
+          end
+
           move_toward(ent, ent.instance_variable_get(:@closed_pos), dt)
+          door_blocked(ent, player_pos, player_state)
           if ent.instance_variable_get(:@move_fraction) >= 1.0
             ent.state = STATE_CLOSED
+            play_brush_noise(ent, :@noise1)
           end
         end
       end
 
-      def update_platform(ent, dt, player_pos)
+      def update_platform(ent, dt, player_pos, player_state = nil)
         case ent.state
-        when STATE_IDLE
+        when STATE_IDLE, STATE_CLOSED
           model = @level.models[ent.model_index]
           triggered = ent.instance_variable_get(:@triggered)
-          on_top = model && on_top_of?(ent, model, player_pos)
+          center_touch = model && platform_center_touch_actor?(player_state) &&
+                         platform_center_trigger_touch?(ent, model, player_pos)
+          targeted_waiting_for_first_use = ent.targetname && ent.instance_variable_get(:@targeted_platform)
 
           # Targeted platforms only react to button triggers.
-          # Normal platforms also activate when player steps on them.
-          should_move = if ent.targetname
+          # Once lowered, they behave like normal platforms again.
+          should_move = if targeted_waiting_for_first_use
+                          if triggered && ent.instance_variable_get(:@platform_used)
+                            raise "plat_use: not in up state"
+                          end
                           triggered
                         else
-                          triggered || on_top
+                          triggered || center_touch
                         end
 
           if should_move
+            ent.instance_variable_set(:@platform_used, true) if ent.instance_variable_get(:@targeted_platform)
+            play_brush_noise(ent, :@noise)
             ent.state = STATE_OPENING
             ent.instance_variable_set(:@triggered, false)
           end
         when STATE_OPENING
+          if ent.instance_variable_get(:@activated_at_time) == @time
+            ent.instance_variable_set(:@activated_at_time, nil)
+            return
+          end
+
           move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+          platform_blocked(ent, player_pos, player_state)
           if ent.instance_variable_get(:@move_fraction) >= 1.0
-            ent.state = STATE_OPEN
-            ent.think_time = ent.wait
+            if ent.instance_variable_get(:@targeted_platform)
+              enable_normal_platform_operation(ent)
+              ent.state = STATE_CLOSED
+              ent.think_time = 0.0
+            else
+              ent.state = STATE_OPEN
+              ent.think_time = ent.wait
+            end
+            play_brush_noise(ent, :@noise1)
           end
         when STATE_OPEN
-          ent.think_time -= dt
+          model = @level.models[ent.model_index]
+          if model && on_top_of?(ent, model, player_pos)
+            ent.think_time = 1.0
+          else
+            ent.think_time -= dt
+          end
           if ent.think_time <= 0
+            play_brush_noise(ent, :@noise)
             ent.state = STATE_CLOSING
           end
         when STATE_CLOSING
+          if ent.instance_variable_get(:@activated_at_time) == @time
+            ent.instance_variable_set(:@activated_at_time, nil)
+            return
+          end
+
           move_toward(ent, ent.instance_variable_get(:@closed_pos), dt)
+          platform_blocked(ent, player_pos, player_state)
           if ent.instance_variable_get(:@move_fraction) >= 1.0
-            ent.state = STATE_IDLE
+            ent.state = STATE_CLOSED
+            play_brush_noise(ent, :@noise1)
           end
         end
       end
 
-      def update_button(ent, dt, player_pos)
+      def enable_normal_platform_operation(ent)
+        top_pos = ent.instance_variable_get(:@closed_pos)
+        bottom_pos = ent.instance_variable_get(:@open_pos)
+        ent.instance_variable_set(:@closed_pos, bottom_pos)
+        ent.instance_variable_set(:@open_pos, top_pos)
+        ent.instance_variable_set(:@targeted_platform, false)
+      end
+
+      def update_button(ent, dt, player_pos, player_state = nil)
         case ent.state
         when STATE_IDLE, STATE_CLOSED
-          if near_entity?(ent, player_pos, 64.0) || ent.instance_variable_get(:@triggered)
-            ent.state = STATE_OPENING
+          # button_touch fires on brush contact. The expansion is wider than
+          # the 16-unit player half-width because this port's wall collision
+          # can hold the player a bit off flush surfaces; still much tighter
+          # than a center-distance sphere.
+          touched = !shootable_button?(ent) && door_model_touch?(ent, player_pos, player_radius: BUTTON_TOUCH_RADIUS)
+          if touched || ent.instance_variable_get(:@triggered)
+            ent.instance_variable_set(:@button_activator, player_state) if touched && player_state
+            fire_button(ent)
             ent.instance_variable_set(:@triggered, false)
-            fire_targets(ent.target)
           end
         when STATE_OPENING
           move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
           if ent.instance_variable_get(:@move_fraction) >= 1.0
             ent.state = STATE_OPEN
             ent.think_time = ent.wait
+            activator = ent.instance_variable_get(:@button_activator) ||
+                        ent.instance_variable_get(:@trigger_activator) ||
+                        ent
+            use_targets(ent, activator: activator)
+            ent.instance_variable_set(:@button_activator, nil)
+            ent.instance_variable_set(:@trigger_activator, nil)
+            ent.frame = 1
           end
         when STATE_OPEN
           ent.think_time -= dt
+          # QC button_wait schedules the return even for wait -1 (the time is
+          # already in the past), so such buttons pop back out immediately
           if ent.think_time <= 0
             ent.state = STATE_CLOSING
+            ent.frame = 0
+            if shootable_button?(ent)
+              ent.instance_variable_set(:@shot_disabled, false)
+              ent.instance_variable_set(:@takedamage, 1)
+            end
           end
         when STATE_CLOSING
+          if !shootable_button?(ent) && door_model_touch?(ent, player_pos, player_radius: BUTTON_TOUCH_RADIUS)
+            ent.instance_variable_set(:@button_activator, player_state) if player_state
+            fire_button(ent)
+            ent.instance_variable_set(:@move_fraction, 0.0)
+            return
+          end
           move_toward(ent, ent.instance_variable_get(:@closed_pos), dt)
           if ent.instance_variable_get(:@move_fraction) >= 1.0
             ent.state = STATE_CLOSED
@@ -288,40 +987,143 @@ module Quake
         end
       end
 
-      def update_train(ent, dt)
-        # Trains follow path_corner entities - basic movement only
+      def update_train(ent, dt, player_pos, player_state = nil)
+        cooldown = ent.instance_variable_get(:@blocked_cooldown).to_f
+        ent.instance_variable_set(:@blocked_cooldown, [cooldown - dt, 0.0].max) if cooldown.positive?
+
+        return if update_train_start_think(ent, dt)
+
+        if ent.state == STATE_IDLE && ent.instance_variable_get(:@triggered)
+          ent.instance_variable_set(:@triggered, false)
+          start_train_next(ent)
+        end
+
+        if ent.state == STATE_OPEN
+          ent.think_time -= dt
+          start_train_next(ent) if ent.think_time <= 0
+          return
+        end
+
         return unless ent.state == STATE_OPENING
 
         move_toward(ent, ent.instance_variable_get(:@open_pos), dt)
+        train_blocked(ent, player_pos, player_state)
         if ent.instance_variable_get(:@move_fraction) >= 1.0
-          ent.state = STATE_IDLE
+          ent.state = STATE_OPEN
+          ent.think_time = ent.wait.nonzero? ? ent.wait : 0.1
+          play_brush_noise(ent, :@noise) if ent.wait.nonzero?
+        end
+      end
+
+      def start_train_next(ent)
+        raise "train_next: no next target" if ent.target.nil? || ent.target.empty?
+
+        target = @target_map[ent.target]&.first
+        raise "train_next: no next target" unless target
+
+        ent.target = target.target
+        raise "train_next: no next target" if ent.target.nil? || ent.target.empty?
+
+        ent.wait = target.wait.nonzero? ? target.wait : 0.0
+        mins = ent.instance_variable_get(:@train_mins) || Math::Vec3::ORIGIN
+        ent.instance_variable_set(:@open_pos, target.position - mins)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+        ent.instance_variable_set(:@think, nil)
+        ent.think_time = 0.0
+        play_brush_noise(ent, :@noise1)
+        ent.state = STATE_OPENING
+      end
+
+      def update_train_start_think(ent, dt)
+        think = ent.instance_variable_get(:@think)
+        return false unless %i[func_train_find train_next].include?(think)
+        return false if think == :func_train_find && ent.instance_variable_get(:@train_found)
+
+        ent.think_time -= dt
+        return true if ent.think_time.positive?
+
+        if think == :func_train_find
+          train_find(ent)
+        else
+          start_train_next(ent)
+        end
+        true
+      end
+
+      def train_find(ent)
+        target = @target_map[ent.target]&.first
+        if target
+          mins = ent.instance_variable_get(:@train_mins) || Math::Vec3::ORIGIN
+          ent.position = target.position - mins
+          ent.target = target.target
+        else
+          ent.target = nil
         end
+        ent.instance_variable_set(:@train_found, true)
+
+        return if ent.targetname
+
+        ent.think_time = 0.1
+        ent.instance_variable_set(:@think, :train_next)
       end
 
       def move_toward(ent, target, dt)
         current = ent.position
         diff = target - current
         dist = diff.length
+        move_end = ent.instance_variable_get(:@move_end_pos)
 
-        # Already at target
         if dist < 0.1
+          unless move_end == target
+            ent.instance_variable_set(:@move_start_pos, current)
+            ent.instance_variable_set(:@move_end_pos, target)
+            ent.instance_variable_set(:@move_elapsed, 0.0)
+            ent.instance_variable_set(:@move_duration, 0.1)
+          end
+          elapsed = ent.instance_variable_get(:@move_elapsed).to_f + dt
+          duration = ent.instance_variable_get(:@move_duration).to_f
+          ent.instance_variable_set(:@move_elapsed, elapsed)
           ent.position = target
-          ent.instance_variable_set(:@move_fraction, 1.0)
+          if elapsed >= duration
+            ent.instance_variable_set(:@move_fraction, 1.0)
+            clear_move_timing(ent)
+          else
+            ent.instance_variable_set(:@move_fraction, 0.0)
+          end
           return
         end
 
-        move_amount = ent.speed * dt
-        if move_amount >= dist
-          # Snap to target
+        unless move_end == target
+          ent.instance_variable_set(:@move_start_pos, current)
+          ent.instance_variable_set(:@move_end_pos, target)
+          ent.instance_variable_set(:@move_elapsed, 0.0)
+          ent.instance_variable_set(:@move_duration, [dist / ent.speed, 0.03].max)
+        end
+
+        elapsed = ent.instance_variable_get(:@move_elapsed).to_f + dt
+        duration = ent.instance_variable_get(:@move_duration).to_f
+        fraction = duration.positive? ? elapsed / duration : 1.0
+        ent.instance_variable_set(:@move_elapsed, elapsed)
+
+        if fraction >= 1.0
           ent.position = target
           ent.instance_variable_set(:@move_fraction, 1.0)
+          clear_move_timing(ent)
         else
-          # Partial movement, not done yet
-          ent.position = current + diff * (move_amount / dist)
+          start = ent.instance_variable_get(:@move_start_pos)
+          total_diff = target - start
+          ent.position = start + total_diff * fraction
           ent.instance_variable_set(:@move_fraction, 0.0)
         end
       end
 
+      def clear_move_timing(ent)
+        ent.instance_variable_set(:@move_start_pos, nil)
+        ent.instance_variable_set(:@move_end_pos, nil)
+        ent.instance_variable_set(:@move_elapsed, 0.0)
+        ent.instance_variable_set(:@move_duration, 0.0)
+      end
+
       def near_entity?(ent, player_pos, radius)
         model = @level.models[ent.model_index]
         return false unless model
@@ -334,26 +1136,973 @@ module Quake
         (dx * dx + dy * dy + dz * dz) < radius * radius
       end
 
+      def door_trigger_field_touch?(ent, player_pos)
+        return false unless touch_activated_door?(ent)
+        return false if linked_door_keyed?(ent)
+
+        mins, maxs = linked_door_group_bounds(ent)
+        return false unless mins && maxs
+
+        player_pos.x >= mins.x - 60.0 &&
+          player_pos.x <= maxs.x + 60.0 &&
+          player_pos.y >= mins.y - 60.0 &&
+          player_pos.y <= maxs.y + 60.0 &&
+          player_pos.z >= mins.z - 8.0 &&
+          player_pos.z <= maxs.z + 8.0
+      end
+
+      def linked_door_group_bounds(ent)
+        mins = nil
+        maxs = nil
+        linked_door_group(ent).each do |member|
+          model = @level.models[member.model_index]
+          next unless model
+
+          member_mins = member.position + model.mins
+          member_maxs = member.position + model.maxs
+          mins = member_mins if mins.nil?
+          maxs = member_maxs if maxs.nil?
+          mins = Math::Vec3.new([mins.x, member_mins.x].min, [mins.y, member_mins.y].min, [mins.z, member_mins.z].min)
+          maxs = Math::Vec3.new([maxs.x, member_maxs.x].max, [maxs.y, member_maxs.y].max, [maxs.z, member_maxs.z].max)
+        end
+        [mins, maxs]
+      end
+
       def on_top_of?(ent, model, player_pos)
         # Check if player is standing on top of the platform.
         # Tolerance: -8 to +24 units above the surface (player feet within
         # one stair step of the platform top).
         top_z = ent.position.z + model.maxs.z
-        player_pos.z >= top_z - 8 && player_pos.z <= top_z + 24 &&
+        player_pos.z >= top_z + 16 && player_pos.z <= top_z + 48 &&
           player_pos.x >= ent.position.x + model.mins.x &&
           player_pos.x <= ent.position.x + model.maxs.x &&
           player_pos.y >= ent.position.y + model.mins.y &&
           player_pos.y <= ent.position.y + model.maxs.y
       end
 
-      def fire_targets(target_name)
-        return unless target_name
+      def door_model_touch?(ent, player_pos, player_radius: 16.0)
+        model = @level.models[ent.model_index]
+        return false unless model
 
-        targets = @target_map[target_name]
-        targets.each do |ent|
-          ent.instance_variable_set(:@triggered, true)
-          # Reset movement fraction for re-triggering
-          ent.instance_variable_set(:@move_fraction, 0.0)
+        player_pos.x >= ent.position.x + model.mins.x - player_radius &&
+          player_pos.x <= ent.position.x + model.maxs.x + player_radius &&
+          player_pos.y >= ent.position.y + model.mins.y - player_radius &&
+          player_pos.y <= ent.position.y + model.maxs.y + player_radius &&
+          player_pos.z >= ent.position.z + model.mins.z - player_radius &&
+          player_pos.z <= ent.position.z + model.maxs.z + player_radius
+      end
+
+      def platform_center_trigger_touch?(ent, model, player_pos)
+        lower_origin_z, upper_origin_z = [
+          ent.instance_variable_get(:@closed_pos).z,
+          ent.instance_variable_get(:@open_pos).z
+        ].minmax
+        bottom_top_z = lower_origin_z + model.maxs.z
+        top_trigger_z = if (ent.spawnflags & PLAT_LOW_TRIGGER) != 0
+                          bottom_top_z + 8.0
+                        else
+                          upper_origin_z + model.maxs.z + 8.0
+                        end
+
+        return false unless player_pos.z >= bottom_top_z
+        return false unless player_pos.z <= top_trigger_z
+
+        mins = ent.position + model.mins
+        maxs = ent.position + model.maxs
+        size = model.maxs - model.mins
+        min_x = mins.x + 25.0
+        max_x = maxs.x - 25.0
+        min_y = mins.y + 25.0
+        max_y = maxs.y - 25.0
+
+        if size.x <= 50.0
+          min_x = (mins.x + maxs.x) / 2.0
+          max_x = min_x + 1.0
+        end
+        if size.y <= 50.0
+          min_y = (mins.y + maxs.y) / 2.0
+          max_y = min_y + 1.0
+        end
+
+        player_pos.x >= min_x && player_pos.x <= max_x &&
+          player_pos.y >= min_y && player_pos.y <= max_y
+      end
+
+      def platform_center_touch_actor?(player_state)
+        return true unless player_state
+
+        player_state.classname == "player" && player_state.alive?
+      end
+
+      def door_blocked(ent, player_pos, player_state)
+        return unless player_state&.alive?
+        # A player standing on top rides the pusher (SV_PushMove), same as
+        # for plats -- vertical doors are Quake's elevators.
+        return if riding_on_top?(ent, player_pos)
+        return unless player_blocking_brush?(ent, player_pos)
+
+        damage = (ent["dmg"] || "2").to_f
+        player_state.deathtype = "squish" if player_state.respond_to?(:deathtype=)
+        player_state.take_damage(damage)
+        return if ent.wait.negative?
+
+        ent.state = ent.state == STATE_CLOSING ? STATE_OPENING : STATE_CLOSING
+        play_brush_noise(ent, :@noise2)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+      end
+
+      def platform_blocked(ent, player_pos, player_state)
+        return unless player_state&.alive?
+        # A player standing on top is a rider carried with the pusher
+        # (SV_PushMove), not a blocker. player_pos is pre-carry here, so
+        # judge "on top" against the platform's pre-move position.
+        return if riding_on_top?(ent, player_pos)
+        return unless player_blocking_brush?(ent, player_pos)
+
+        player_state.deathtype = "squish" if player_state.respond_to?(:deathtype=)
+        player_state.take_damage(1)
+        ent.state = ent.state == STATE_CLOSING ? STATE_OPENING : STATE_CLOSING
+        play_brush_noise(ent, :@noise)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+      end
+
+      def riding_on_top?(ent, player_pos)
+        model = @level.models[ent.model_index]
+        return false unless model
+
+        prev = ent.instance_variable_get(:@prev_pos) || ent.position
+        old_top_z = prev.z + model.maxs.z
+        # Rider origins sit ~24 above the surface; a player squeezed from
+        # the side has an origin below the top
+        player_pos.z >= old_top_z + 16 &&
+          player_pos.x >= ent.position.x + model.mins.x &&
+          player_pos.x <= ent.position.x + model.maxs.x &&
+          player_pos.y >= ent.position.y + model.mins.y &&
+          player_pos.y <= ent.position.y + model.maxs.y
+      end
+
+      def train_blocked(ent, player_pos, player_state)
+        return unless player_state&.alive?
+        return unless player_blocking_brush?(ent, player_pos)
+        return if ent.instance_variable_get(:@blocked_cooldown).to_f.positive?
+
+        damage = (ent["dmg"] || "2").to_f
+        player_state.deathtype = "squish" if player_state.respond_to?(:deathtype=)
+        player_state.take_damage(damage)
+        ent.instance_variable_set(:@blocked_cooldown, 0.5)
+      end
+
+      def player_blocking_brush?(ent, player_pos)
+        model = @level.models[ent.model_index]
+        return false unless model
+
+        player_pos.x >= ent.position.x + model.mins.x &&
+          player_pos.x <= ent.position.x + model.maxs.x &&
+          player_pos.y >= ent.position.y + model.mins.y &&
+          player_pos.y <= ent.position.y + model.maxs.y &&
+          player_pos.z >= ent.position.z + model.mins.z &&
+          player_pos.z <= ent.position.z + model.maxs.z
+      end
+
+      def unlock_door?(ent, player_state)
+        required_key = ent.instance_variable_get(:@required_key)
+        return true unless required_key
+        unless player_state&.has_key?(required_key)
+          centerprint_key_required(player_state, required_key)
+          play_brush_noise(ent, :@noise3)
+          return false
+        end
+
+        player_state.consume_key(required_key)
+        disable_key_door_touch(ent)
+        true
+      end
+
+      def disable_key_door_touch(ent)
+        ent.instance_variable_set(:@touch, :sub_null)
+        enemy = ent.instance_variable_get(:@enemy)
+        enemy.instance_variable_set(:@touch, :sub_null) if enemy
+      end
+
+      def door_touch_allowed?(ent, player_state)
+        return true unless player_state&.classname == "player"
+        owner = linked_door_owner(ent)
+        return false if owner.instance_variable_get(:@attack_finished).to_f > @time
+
+        owner.instance_variable_set(:@attack_finished, @time + 2.0)
+        true
+      end
+
+      def door_trigger_touch_allowed?(ent)
+        owner = linked_door_owner(ent)
+        return false if owner.instance_variable_get(:@trigger_attack_finished).to_f > @time
+
+        owner.instance_variable_set(:@trigger_attack_finished, @time + 1.0)
+        true
+      end
+
+      def centerprint_key_required(player_state, required_key)
+        return unless player_state
+
+        player_state.instance_variable_set(:@centerprint, key_required_message(required_key))
+      end
+
+      def touch_door_message(ent, player_state)
+        return unless player_state&.classname == "player"
+        message = linked_door_owner(ent).message
+        return if message.nil? || message.empty?
+        player_state.instance_variable_set(:@centerprint, message)
+        play_default_message_sound
+      end
+
+      def key_required_message(required_key)
+        key_name = case [required_key, @worldtype]
+                   when [:silver, 1] then "silver runekey"
+                   when [:silver, 2] then "silver keycard"
+                   when [:gold, 1] then "gold runekey"
+                   when [:gold, 2] then "gold keycard"
+                   when [:gold, 0] then "gold key"
+                   else "silver key"
+                   end
+        "You need the #{key_name}"
+      end
+
+      def update_trigger_cooldown(ent, dt)
+        return unless ["trigger_multiple", "trigger_hurt"].include?(ent.classname)
+        return unless ent.think_time.positive?
+
+        previous = ent.think_time
+        ent.think_time = [ent.think_time - dt, 0.0].max
+        ent.think_time = 0.0 if ent.think_time <= 0.000001
+        return unless previous.positive? && ent.think_time.zero?
+
+        if ent.classname == "trigger_hurt"
+          ent.instance_variable_set(:@touch_disabled, false)
+          ent.instance_variable_set(:@solid, 1)
+          ent.think_time = -1.0
+        end
+        restore_health_trigger(ent)
+      end
+
+      def update_scheduled_remove(ent, dt)
+        return unless ent.instance_variable_get(:@think) == :sub_remove
+        return unless ent.think_time.positive?
+
+        ent.think_time = [ent.think_time - dt, 0.0].max
+        remove_entity(ent) if ent.think_time <= 0.000001
+      end
+
+      def schedule_remove(ent, delay)
+        ent.instance_variable_set(:@think, :sub_remove)
+        ent.think_time = delay
+      end
+
+      def update_delayed_uses(dt)
+        return if @delayed_uses.empty?
+
+        ready, waiting = @delayed_uses.partition do |delayed_use|
+          delayed_use[:remaining] -= dt
+          delayed_use[:remaining] <= 0.000001
+        end
+        @delayed_uses = waiting
+
+        ready.each do |delayed_use|
+          fire_use_targets(
+            delayed_use[:killtarget],
+            delayed_use[:target],
+            activator: delayed_use[:activator],
+            message: delayed_use[:message],
+            source_noise: nil
+          )
+        end
+      end
+
+      def use_door_targets(ent, activator:)
+        delay = (ent["delay"] || "0").to_f
+        unless delay.zero?
+          @delayed_uses << {
+            remaining: delay,
+            message: nil,
+            killtarget: ent.killtarget,
+            target: ent.target,
+            activator: activator,
+            source_noise: nil
+          }
+          return
+        end
+
+        fire_use_targets(ent.killtarget, ent.target, activator: activator, message: nil, source_noise: nil)
+      end
+
+      def touch_onlyregistered(ent, activator:)
+        return false unless activator&.classname == "player"
+        return true if ent.instance_variable_get(:@attack_finished).to_f > @time
+
+        ent.instance_variable_set(:@attack_finished, @time + 2.0)
+        unless @registered
+          unless ent.message.nil? || ent.message.empty?
+            centerprint_use_message(activator, ent.message, source_noise: ent.instance_variable_get(:@noise))
+            play_trigger_sound(ent)
+          end
+          return true
+        end
+
+        ent.message = ""
+        use_targets(ent, activator: activator)
+        remove_entity(ent)
+        true
+      end
+
+      def touch_monsterjump(ent, activator)
+        return false unless activator
+        return false unless (activator.flags & (FL_MONSTER | FL_FLY | FL_SWIM)) == FL_MONSTER
+
+        movedir = trigger_movedir(ent)
+        activator.velocity = Math::Vec3.new(
+          movedir.x * ent.speed,
+          movedir.y * ent.speed,
+          activator.velocity.z
+        )
+
+        return true if (activator.flags & FL_ONGROUND).zero?
+
+        activator.flags -= FL_ONGROUND
+        activator.velocity = Math::Vec3.new(
+          activator.velocity.x,
+          activator.velocity.y,
+          ent.height
+        )
+        true
+      end
+
+      def touch_push(ent, activator)
+        pushed = false
+        if activator&.classname == "grenade" || activator&.health&.positive?
+          activator.velocity = trigger_movedir(ent) * ent.speed * 10.0
+          play_push_player_sound(activator) if activator.classname == "player"
+          pushed = true
+        end
+        remove_entity(ent) if (ent.spawnflags & 1) != 0
+        pushed
+      end
+
+      def play_push_player_sound(activator)
+        return unless activator.instance_variable_get(:@fly_sound).to_f < @time
+
+        activator.instance_variable_set(:@fly_sound, @time + 1.5)
+        @sound_events&.on_trigger_push_player
+      end
+
+      def touch_hurt(ent, activator)
+        return false unless activator_takedamage?(activator)
+
+        ent.instance_variable_set(:@solid, 0)
+        damage_takedamage_activator(activator, (ent["dmg"] || "5").to_f)
+        ent.instance_variable_set(:@think, :hurt_on)
+        ent.instance_variable_set(:@touch_disabled, true)
+        ent.think_time = 1.0
+        true
+      end
+
+      def touch_secret_trigger(ent, activator:)
+        return false unless activator&.classname == "player"
+
+        ent.instance_variable_set(:@takedamage, 0)
+        @found_secrets += 1
+        play_trigger_sound(ent)
+        use_targets(ent, activator: activator)
+        ent.instance_variable_set(:@touch_disabled, true)
+        schedule_remove(ent, 0.1)
+        true
+      end
+
+      def play_trigger_sound(ent)
+        return unless ent.instance_variable_get(:@noise)
+        return unless @sound_events
+
+        if @sound_events.respond_to?(:on_trigger)
+          @sound_events.on_trigger(ent)
+        elsif @sound_events.respond_to?(:on_trigger_secret)
+          @sound_events.on_trigger_secret(ent)
+        end
+      end
+
+      def play_brush_noise(ent, ivar)
+        sound = ent.instance_variable_get(ivar)
+        return if sound.nil? || sound.empty?
+        return if sound == "misc/null.wav"
+        return unless @sound_events&.respond_to?(:on_trigger)
+
+        event = Object.new
+        event.instance_variable_set(:@noise, sound)
+        @sound_events.on_trigger(event)
+      end
+
+      def trigger_cooldown_active?(ent)
+        ["trigger_multiple", "trigger_hurt"].include?(ent.classname) && ent.think_time.positive?
+      end
+
+      def multi_trigger?(ent)
+        ["trigger_once", "trigger_multiple", "trigger_secret"].include?(ent.classname)
+      end
+
+      def multi_trigger_waiting?(ent)
+        return false unless multi_trigger?(ent)
+
+        ent.think_time.positive?
+      end
+
+      def notouch_trigger?(ent)
+        multi_trigger?(ent) && (ent.spawnflags & 1) != 0
+      end
+
+      def trigger_facing_allowed?(ent, player_forward)
+        return true unless multi_trigger?(ent)
+        return true unless player_forward
+        return true unless trigger_has_angle_restriction?(ent)
+
+        player_forward.dot(trigger_movedir(ent)) >= 0.0
+      end
+
+      def trigger_touch_facing_allowed?(ent, activator)
+        trigger_facing_allowed?(ent, activator_forward_vector(activator))
+      end
+
+      def activator_forward_vector(activator)
+        return activator.forward_flat if activator.respond_to?(:forward_flat)
+        return activator.forward_vector if activator.respond_to?(:forward_vector)
+
+        nil
+      end
+
+      def trigger_has_angle_restriction?(ent)
+        return true if ent.move_dir != Math::Vec3::ORIGIN
+        return true if ent["angles"] && ent["angles"].split.map(&:to_f) != [0.0, 0.0, 0.0]
+        return false unless ent["angle"]
+
+        ent["angle"].to_f != 0.0
+      end
+
+      def health_trigger?(ent)
+        multi_trigger?(ent) && ent.health.positive?
+      end
+
+      def restore_health_trigger(ent)
+        return unless ent.classname == "trigger_multiple"
+        max_health = ent.instance_variable_get(:@max_health)
+        return unless max_health
+        return unless ent.health <= 0.0
+
+        ent.health = max_health
+        ent.instance_variable_set(:@takedamage, 1)
+        ent.instance_variable_set(:@solid, 2)
+      end
+
+      def shootable_button?(ent)
+        ent.classname == "func_button" && ent.instance_variable_get(:@max_health).to_f.positive?
+      end
+
+      def shootable_door?(ent)
+        regular_door?(ent) && ent.instance_variable_get(:@max_health).to_f.positive?
+      end
+
+      def toggle_door?(ent)
+        regular_door?(ent) && (ent.spawnflags & DOOR_TOGGLE) != 0
+      end
+
+      def touch_activated_door?(ent)
+        regular_door?(ent) && !linked_door_targetname?(ent) && !linked_door_shootable?(ent)
+      end
+
+      def linked_door_keyed?(ent)
+        linked_door_group(ent).any? { |door| door.instance_variable_get(:@required_key) }
+      end
+
+      def regular_door?(ent)
+        ent.classname == "func_door" || ent.instance_variable_get(:@regular_door)
+      end
+
+      def linked_door_targetname?(ent)
+        linked_door_group(ent).any? { |door| door.targetname }
+      end
+
+      def linked_door_shootable?(ent)
+        linked_door_group(ent).any? { |door| shootable_door?(door) }
+      end
+
+      def linked_door_group(ent)
+        ent.instance_variable_get(:@door_group) || [ent]
+      end
+
+      def linked_door_owner(ent)
+        ent.instance_variable_get(:@owner) || ent
+      end
+
+      def damage_button(ent, amount, activator: nil)
+        return false unless shootable_button?(ent)
+        return true if ent.instance_variable_get(:@shot_disabled)
+
+        ent.health -= amount.to_f.ceil
+        return true if ent.health.positive?
+
+        ent.health = ent.instance_variable_get(:@max_health)
+        ent.instance_variable_set(:@shot_disabled, true)
+        ent.instance_variable_set(:@takedamage, 0)
+        ent.instance_variable_set(:@button_activator, activator) if activator
+        fire_button(ent)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+        true
+      end
+
+      def damage_door(ent, amount, activator: nil)
+        return false unless shootable_door?(ent)
+        return true if ent.instance_variable_get(:@shot_disabled)
+
+        ent.health -= amount.to_f.ceil
+        return true if ent.health.positive?
+
+        ent.health = ent.instance_variable_get(:@max_health)
+        ent.instance_variable_set(:@shot_disabled, true)
+        ent.instance_variable_set(:@takedamage, 0)
+        open_linked_doors_now(ent, activator: activator || ent)
+        true
+      end
+
+      def damage_secret_door(ent, activator:)
+        return false unless secret_door_shootable?(ent)
+        return false if ent.instance_variable_get(:@takedamage).to_i.zero?
+
+        use_secret_door(ent, activator: activator || ent)
+        true
+      end
+
+      def update_secret_door(ent, player_pos, player_state = nil)
+        if ent.instance_variable_get(:@triggered)
+          ent.instance_variable_set(:@triggered, false)
+          use_secret_door(ent, activator: ent)
+        end
+
+        case ent.state
+        when STATE_IDLE, STATE_CLOSED
+          touch_door_message(ent, player_state) if near_entity?(ent, player_pos, 128.0)
+        when STATE_OPENING
+          move_toward(ent, ent.instance_variable_get(:@open_pos), @time_step)
+          secret_door_blocked(ent, player_pos, player_state)
+          advance_secret_door(ent) if ent.instance_variable_get(:@move_fraction) >= 1.0
+        when :secret_pause1
+          ent.think_time -= @time_step
+          start_secret_move(ent, :move2, ent.instance_variable_get(:@secret_dest2)) if ent.think_time <= 0.0
+        when STATE_OPEN
+          return if (ent.spawnflags & 1) != 0
+
+          ent.think_time -= @time_step
+          start_secret_move(ent, :move3, ent.instance_variable_get(:@secret_dest1)) if ent.think_time <= 0.0
+        when :secret_pause2
+          ent.think_time -= @time_step
+          start_secret_move(ent, :move4, ent.instance_variable_get(:@oldorigin)) if ent.think_time <= 0.0
+        end
+      end
+
+      def use_secret_door(ent, activator:)
+        return if ent.position != ent.instance_variable_get(:@oldorigin)
+
+        ent.health = 10_000.0
+        ent.message = nil
+        use_targets(ent, activator: activator)
+        unless (ent.spawnflags & SECRET_NO_SHOOT) != 0
+          ent.instance_variable_set(:@shot_disabled, true)
+          ent.instance_variable_set(:@takedamage, 0)
+          ent.instance_variable_set(:@th_pain, :sub_null)
+        end
+        calculate_secret_door_destinations(ent)
+        play_brush_noise(ent, :@noise1)
+        start_secret_move(ent, :move1, ent.instance_variable_get(:@secret_dest1))
+      end
+
+      def secret_door_blocked(ent, player_pos, player_state)
+        return unless player_state&.alive?
+        return unless player_blocking_brush?(ent, player_pos)
+        return if ent.instance_variable_get(:@attack_finished).to_f > @time
+
+        ent.instance_variable_set(:@attack_finished, @time + 0.5)
+        player_state.deathtype = "squish" if player_state.respond_to?(:deathtype=)
+        player_state.take_damage((ent["dmg"] || "2").to_f)
+      end
+
+      def calculate_secret_door_destinations(ent)
+        return if ent.instance_variable_get(:@secret_dest1)
+
+        forward, right, up = secret_door_vectors(ent)
+        size = ent.instance_variable_get(:@secret_size)
+        width = ent["t_width"]&.to_f
+        width = nil if width&.zero?
+        width ||= if (ent.spawnflags & 4) != 0
+                    up.dot(size).abs
+                  else
+                    right.dot(size).abs
+                  end
+        length = ent["t_length"]&.to_f
+        length = nil if length&.zero?
+        length ||= forward.dot(size).abs
+
+        left_sign = (ent.spawnflags & 2) != 0 ? -1.0 : 1.0
+        dest1 = if (ent.spawnflags & 4) != 0
+                  ent.position - up * width
+                else
+                  ent.position + right * (width * left_sign)
+                end
+        ent.instance_variable_set(:@secret_dest1, dest1)
+        ent.instance_variable_set(:@secret_dest2, dest1 + forward * length)
+      end
+
+      def secret_door_vectors(ent)
+        mangle = ent.instance_variable_get(:@mangle)
+        yaw = if mangle && mangle != Math::Vec3::ORIGIN
+                mangle.y
+              elsif ent.angles != Math::Vec3::ORIGIN
+                ent.angles.y
+              else
+                ent.angle
+              end
+        rad = yaw * ::Math::PI / 180.0
+        forward = Math::Vec3.new(::Math.cos(rad), ::Math.sin(rad), 0.0)
+        right_rad = (yaw - 90.0) * ::Math::PI / 180.0
+        right = Math::Vec3.new(::Math.cos(right_rad), ::Math.sin(right_rad), 0.0)
+        [forward, right, Math::Vec3.new(0.0, 0.0, 1.0)]
+      end
+
+      def start_secret_move(ent, phase, target)
+        ent.instance_variable_set(:@secret_phase, phase)
+        ent.instance_variable_set(:@open_pos, target)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+        play_brush_noise(ent, :@noise2)
+        ent.state = STATE_OPENING
+      end
+
+      def advance_secret_door(ent)
+        case ent.instance_variable_get(:@secret_phase)
+        when :move1
+          ent.state = :secret_pause1
+          ent.think_time = 1.0
+          play_brush_noise(ent, :@noise3)
+        when :move2
+          ent.state = STATE_OPEN
+          ent.think_time = ent.wait
+          play_brush_noise(ent, :@noise3)
+        when :move3
+          ent.state = :secret_pause2
+          ent.think_time = 1.0
+          play_brush_noise(ent, :@noise3)
+        when :move4
+          ent.state = STATE_CLOSED
+          if secret_door_shootable?(ent)
+            ent.health = 10_000.0
+            ent.instance_variable_set(:@takedamage, 1)
+            ent.instance_variable_set(:@th_pain, :fd_secret_use)
+            ent.instance_variable_set(:@th_die, :fd_secret_use)
+            ent.instance_variable_set(:@shot_disabled, false)
+          end
+          play_brush_noise(ent, :@noise3)
+        end
+      end
+
+      def secret_door?(ent)
+        ent.classname == "func_door_secret" || ent.instance_variable_get(:@secret_door)
+      end
+
+      def secret_door_shootable?(ent)
+        !ent.targetname || (ent.spawnflags & SECRET_YES_SHOOT) != 0
+      end
+
+      def remove_killtargets(target_name)
+        @entities.each do |ent|
+          next unless ent.targetname == target_name
+
+          remove_entity(ent)
+        end
+      end
+
+      def remove_entity(ent)
+        ent.instance_variable_set(:@removed, true)
+        ent.instance_variable_set(:@touch_disabled, true)
+      end
+
+      def fire_use_targets(killtarget, target, activator:, message: nil, source_noise: nil)
+        centerprint_use_message(activator, message, source_noise: source_noise)
+        if killtarget && !killtarget.empty?
+          remove_killtargets(killtarget)
+          return
+        end
+        fire_targets(target, activator: activator) if target
+      end
+
+      def centerprint_use_message(activator, message, source_noise: nil)
+        return unless activator.respond_to?(:classname)
+        return unless activator&.classname == "player"
+        return if message.nil? || message.empty?
+
+        activator.instance_variable_set(:@centerprint, message)
+        play_default_message_sound if source_noise.nil? || source_noise.empty?
+      end
+
+      def play_default_message_sound
+        return unless @sound_events&.respond_to?(:on_trigger)
+
+        entity = Object.new
+        entity.instance_variable_set(:@noise, "misc/talk.wav")
+        @sound_events.on_trigger(entity)
+      end
+
+      def fire_targets(target_name, activator:)
+        return unless target_name
+
+        targets = @target_map[target_name]
+        return unless targets
+
+        targets.each do |ent|
+          next if ent.instance_variable_get(:@removed)
+
+          if ent.classname == "trigger_counter"
+            use_counter(ent, activator: activator)
+            next
+          end
+
+          if ent.classname == "trigger_relay"
+            use_targets(ent, activator: activator)
+            next
+          end
+
+          if multi_trigger?(ent)
+            activate_multi_trigger(ent, activator: activator)
+            next
+          end
+
+          if ent.classname == "trigger_teleport"
+            ent.think_time = @time + 0.2
+            ent.instance_variable_set(:@think, :sub_null)
+            next
+          end
+
+          if toggle_frame_bmodel?(ent)
+            ent.frame = 1 - ent.frame
+            next
+          end
+
+          if toggle_light?(ent)
+            toggle_light(ent)
+            next
+          end
+
+          if ent.classname == "func_button"
+            use_button(ent, activator: activator)
+            next
+          end
+
+          if regular_door?(ent)
+            use_door(ent, activator: activator)
+            next
+          end
+
+          if secret_door?(ent)
+            use_secret_door(ent, activator: activator)
+            next
+          end
+
+          if train_entity?(ent)
+            use_train(ent)
+            next
+          end
+
+          if platform_entity?(ent)
+            use_platform(ent)
+            next
+          end
+        end
+      end
+
+      def use_door(ent, activator:)
+        owner = linked_door_owner(ent)
+        play_brush_noise(owner, :@noise4) if owner.instance_variable_get(:@required_key)
+        if toggle_door?(owner) && [STATE_OPENING, STATE_OPEN].include?(owner.state)
+          linked_door_group(owner).each do |member|
+            member.instance_variable_set(:@triggered, false)
+            member.instance_variable_set(:@trigger_activator, nil)
+            member.instance_variable_set(:@move_fraction, 0.0)
+            member.instance_variable_set(:@activated_at_time, @time)
+            play_brush_noise(member, :@noise2)
+            member.state = STATE_CLOSING
+          end
+          clear_linked_door_messages(owner)
+          return
+        end
+
+        linked_door_group(owner).each do |member|
+          member.instance_variable_set(:@triggered, false)
+          member.instance_variable_set(:@trigger_activator, activator)
+          if member.state == STATE_OPENING
+            next
+          elsif member.state == STATE_OPEN
+            member.think_time = member.wait
+            next
+          end
+
+          member.instance_variable_set(:@move_fraction, 0.0)
+          member.instance_variable_set(:@activated_at_time, @time)
+          play_brush_noise(member, :@noise2)
+          member.state = STATE_OPENING
+
+          use_door_targets(member, activator: activator)
+        end
+        clear_linked_door_messages(owner)
+      end
+
+      def train_entity?(ent)
+        ["train", "misc_teleporttrain"].include?(ent.classname)
+      end
+
+      def platform_entity?(ent)
+        ent.classname == "plat" || ent.classname == "func_plat"
+      end
+
+      def use_train(ent)
+        return unless ent.state == STATE_IDLE
+
+        ent.instance_variable_set(:@triggered, false)
+        start_train_next(ent)
+      end
+
+      def use_platform(ent)
+        return if ent.instance_variable_get(:@use) == :sub_null
+
+        if ent.instance_variable_get(:@targeted_platform)
+          ent.instance_variable_set(:@use, :sub_null)
+          raise "plat_use: not in up state" unless ent.state == STATE_IDLE
+
+          ent.instance_variable_set(:@platform_used, true)
+          ent.instance_variable_set(:@triggered, false)
+          ent.instance_variable_set(:@move_fraction, 0.0)
+          ent.instance_variable_set(:@activated_at_time, @time)
+          play_brush_noise(ent, :@noise)
+          ent.state = STATE_OPENING
+          return
+        end
+
+        return unless ent.state == STATE_IDLE || ent.state == STATE_CLOSED
+
+        ent.instance_variable_set(:@triggered, false)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+        ent.instance_variable_set(:@activated_at_time, @time)
+        play_brush_noise(ent, :@noise)
+        ent.state = STATE_CLOSING
+      end
+
+      def open_linked_doors_now(ent, activator:)
+        linked_door_group(ent).each do |member|
+          next if [STATE_OPENING, STATE_OPEN].include?(member.state)
+
+          member.instance_variable_set(:@trigger_activator, activator)
+          member.instance_variable_set(:@move_fraction, 0.0)
+          member.instance_variable_set(:@activated_at_time, @time)
+          play_brush_noise(member, :@noise2)
+          member.state = STATE_OPENING
+          use_door_targets(member, activator: activator)
+        end
+        clear_linked_door_messages(ent)
+      end
+
+      def clear_linked_door_messages(ent)
+        linked_door_group(ent).each { |member| member.message = nil }
+      end
+
+      def toggle_frame_bmodel?(ent)
+        ent.instance_variable_get(:@use) == :func_wall_use
+      end
+
+      def toggle_light?(ent)
+        ["light", "light_fluoro"].include?(ent.classname) && ent.style >= 32
+      end
+
+      def toggle_light(ent)
+        ent.instance_variable_set(:@use, :light_use)
+        if (ent.spawnflags & 1) != 0
+          ent.lightstyle = "m"
+          ent.spawnflags -= 1
+        else
+          ent.lightstyle = "a"
+          ent.spawnflags += 1
+        end
+      end
+
+      def use_button(ent, activator:)
+        return if [STATE_OPENING, STATE_OPEN].include?(ent.state)
+
+        ent.instance_variable_set(:@button_activator, activator)
+        ent.instance_variable_set(:@triggered, false)
+        ent.instance_variable_set(:@move_fraction, 0.0)
+        fire_button(ent)
+      end
+
+      def fire_button(ent)
+        return if [STATE_OPENING, STATE_OPEN].include?(ent.state)
+
+        play_trigger_sound(ent)
+        ent.state = STATE_OPENING
+      end
+
+      def use_counter(ent, activator:)
+        ent.count -= 1
+        return if ent.count.negative?
+        unless ent.count.zero?
+          centerprint_counter_message(ent, activator, counter_remaining_message(ent.count))
+          return
+        end
+
+        centerprint_counter_message(ent, activator, "Sequence completed!")
+        ent.instance_variable_set(:@enemy, activator)
+        activate_multi_trigger(ent, activator: activator)
+      end
+
+      def centerprint_counter_message(ent, activator, message)
+        return unless activator&.classname == "player"
+        return if (ent.spawnflags & 1) != 0
+
+        activator.instance_variable_set(:@centerprint, message)
+      end
+
+      def trigger_movedir(ent)
+        return ent.move_dir if ent.move_dir != Math::Vec3::ORIGIN
+        return ent.forward_vector if ent["angles"] && ent["angles"].split.map(&:to_f) != [0.0, 0.0, 0.0]
+        return ent.forward_vector if ent["angle"] && ent["angle"].to_f != 0.0
+
+        Math::Vec3::ORIGIN
+      end
+
+      def trigger_model_index(ent)
+        ent.instance_variable_get(:@trigger_model_index)
+      end
+
+      def activator_takedamage?(activator)
+        activator && activator.instance_variable_get(:@takedamage).to_i != 0
+      end
+
+      def damage_takedamage_activator(activator, damage)
+        if activator.respond_to?(:damageable?) && activator.damageable?
+          activator.take_damage(damage)
+        else
+          activator.health -= damage.to_f.ceil if activator.respond_to?(:health) && activator.respond_to?(:health=)
+        end
+      end
+
+      def init_trigger_class?(ent)
+        ent.classname.start_with?("trigger_")
+      end
+
+      def counter_remaining_message(count)
+        case count
+        when 3 then "Only 3 more to go..."
+        when 2 then "Only 2 more to go..."
+        when 1 then "Only 1 more to go..."
+        else "There are more to go..."
         end
       end
     end