using System;
using System.Collections.Generic;
using System.Linq;
using RimWorld;
using UnityEngine;
using Verse;
using Verse.AI;
using Verse.Sound;

namespace WulaFallenEmpire
{
    /// <summary>
    /// 高速移动撞击组件
    /// </summary>
    public class CompHighSpeedCollision : ThingComp
    {
        // === 运行时状态 ===
        private enum SpeedStage
        {
            Stage0, // 0阶段：不移动
            Stage1, // 1阶段：低速碰撞
            Stage2  // 2阶段：高速击飞
        }
        
        private SpeedStage currentStage = SpeedStage.Stage0;
        private int stageTransitionCooldown = 0;
        
        // 用于计算速度的帧历史
        private Queue<float> speedHistory = new Queue<float>();
        private IntVec3 lastPosition = IntVec3.Invalid;
        private int lastPositionTick = -1;
        
        // 已处理的敌人记录（避免同一帧重复处理）
        private HashSet<Pawn> processedPawnsThisTick = new HashSet<Pawn>();
        
        // === 缓存 ===
        private CellRect collisionAreaCache = default;
        private int lastAreaRecalculationTick = -1;

        // === 地形阻挡相关 ===
        private float currentTerrainBlockSeverity = 0f;
        private int lastTerrainCheckTick = -1;

        public CompProperties_HighSpeedCollision Props => (CompProperties_HighSpeedCollision)props;
        
        public override void PostSpawnSetup(bool respawningAfterLoad)
        {
            base.PostSpawnSetup(respawningAfterLoad);
            
            // 初始化速度历史
            speedHistory.Clear();
            for (int i = 0; i < Props.speedHistoryFrameCount; i++)
            {
                speedHistory.Enqueue(0f);
            }
            
            lastPosition = parent.Position;
            lastPositionTick = Find.TickManager.TicksGame;
        }


        public override void CompTick()
        {
            base.CompTick();

            if (!parent.Spawned || parent.Destroyed)
                return;

            Pawn pawn = parent as Pawn;
            if (pawn == null || pawn.Dead || pawn.Downed)
            {
                ResetToStage0();
                return;
            }

            // 每帧更新
            ProcessFrame(pawn);

            // 地形阻挡检查（降低频率）
            if (Props.narrowTerrainBlocked &&
                (Find.TickManager.TicksGame - lastTerrainCheckTick >= Props.terrainCheckInterval))
            {
                UpdateTerrainBlockStatus(pawn);
                lastTerrainCheckTick = Find.TickManager.TicksGame;
            }
        }
        /// <summary>
        /// 更新地形阻挡状态
        /// </summary>
        private void UpdateTerrainBlockStatus(Pawn pawn)
        {
            if (!Props.narrowTerrainBlocked || Props.maxBlockPenalty <= 0f)
            {
                currentTerrainBlockSeverity = 0f;
                UpdateBlockedHediff(pawn, 0f);
                return;
            }
            // 获取碰撞区域
            CellRect collisionArea = GetCollisionArea(pawn);
            // 统计空闲格子和被占据格子
            int totalCells = 0;
            int occupiedCells = 0;
            foreach (IntVec3 cell in collisionArea)
            {
                if (!cell.InBounds(pawn.Map))
                    continue;
                totalCells++;
                // 检查是否被不可通行建筑占据
                if (IsCellBlockedByImpassable(cell, pawn.Map))
                {
                    occupiedCells++;
                }
            }
            // 计算阻挡严重度
            float blockSeverity = CalculateBlockSeverity(totalCells, occupiedCells);
            // 立即设置阻挡严重度（移除平滑过渡）
            currentTerrainBlockSeverity = blockSeverity;
            // 更新Hediff
            UpdateBlockedHediff(pawn, currentTerrainBlockSeverity);
            // 调试日志
            if (Props.enableDebugLogging && currentTerrainBlockSeverity > 0.01f)
            {
                Log.Message($"[HighSpeedCollision] Terrain Block: {pawn.Label}, " +
                           $"Occupied: {occupiedCells}/{totalCells}, " +
                           $"Severity: {currentTerrainBlockSeverity:P0}");
            }
        }

        /// <summary>
        /// 检查单元格是否被不可通行建筑占据
        /// </summary>
        private bool IsCellBlockedByImpassable(IntVec3 cell, Map map)
        {
            // 获取单元格内的所有建筑
            var things = cell.GetThingList(map);
            foreach (var thing in things)
            {
                if (thing is Building building)
                {
                    // 检查是否可通行
                    if (building.def.passability == Traversability.Impassable)
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// 计算阻挡严重度
        /// </summary>
        private float CalculateBlockSeverity(int totalCells, int occupiedCells)
        {
            if (totalCells == 0 || occupiedCells == 0)
                return 0f;

            int freeCells = totalCells - occupiedCells;
            float freeRatio = (float)freeCells / totalCells;

            // 使用公式：(1 - maxBlockPenalty) + maxBlockPenalty * (空闲格子/(空闲格子+被占据格子))
            // 简化后：1 - maxBlockPenalty + maxBlockPenalty * (freeCells / totalCells)
            // 但实际上，我们应该计算减速比例，然后转换为严重度
            float speedMultiplier = (1f - Props.maxBlockPenalty) +
                                   Props.maxBlockPenalty * (freeRatio);

            // 严重度 = 1 - 速度乘数
            return 1f - speedMultiplier;
        }

        /// <summary>
        /// 平滑过渡
        /// </summary>
        private float SmoothTransition(float current, float target, float speed)
        {
            if (Mathf.Abs(current - target) < 0.01f)
                return target;

            return Mathf.Lerp(current, target, speed);
        }

        /// <summary>
        /// 更新阻挡Hediff
        /// </summary>
        private void UpdateBlockedHediff(Pawn pawn, float severity)
        {
            if (Props.blockedHediff == null)
                return;

            // 获取或添加Hediff
            Hediff hediff = pawn.health.hediffSet.GetFirstHediffOfDef(Props.blockedHediff);

            if (severity <= 0.01f)
            {
                // 移除Hediff
                if (hediff != null)
                {
                    pawn.health.RemoveHediff(hediff);
                }
                return;
            }

            // 添加或更新Hediff
            if (hediff == null)
            {
                hediff = HediffMaker.MakeHediff(Props.blockedHediff, pawn);
                pawn.health.AddHediff(hediff);
            }

            // 更新严重度
            hediff.Severity = severity;
        }

        /// <summary>
        /// 获取当前地形阻挡严重度（供HediffComp使用）
        /// </summary>
        public float GetCurrentTerrainBlockSeverity()
        {
            return currentTerrainBlockSeverity;
        }

        /// <summary>
        /// 处理每帧逻辑
        /// </summary>
        private void ProcessFrame(Pawn pawn)
        {
            int currentTick = Find.TickManager.TicksGame;
            
            // 1. 计算当前速度
            float currentSpeed = CalculateCurrentSpeed(pawn, currentTick);
            
            // 2. 更新速度历史
            UpdateSpeedHistory(currentSpeed);
            
            // 3. 计算平均速度
            float averageSpeed = GetAverageSpeed();
            
            // 4. 确定阶段
            DetermineSpeedStage(averageSpeed);
            
            // 5. 根据阶段应用效果
            ApplyStageEffects(pawn);
            
            // 6. 清理每帧记录
            processedPawnsThisTick.Clear();
            
            // 7. 更新冷却
            if (stageTransitionCooldown > 0)
                stageTransitionCooldown--;
            
            // 8. 调试绘制
            if (Props.enableDebugVisuals && DebugSettings.godMode)
                DrawDebugVisuals(pawn);
        }
        
        /// <summary>
        /// 计算当前速度（每秒格数）
        /// </summary>
        private float CalculateCurrentSpeed(Pawn pawn, int currentTick)
        {
            // 如果没有上次位置记录，无法计算速度
            if (lastPositionTick < 0 || lastPosition == IntVec3.Invalid)
            {
                lastPosition = pawn.Position;
                lastPositionTick = currentTick;
                return 0f;
            }
            
            // 计算时间差（秒）
            float timeDelta = (currentTick - lastPositionTick) / 60f;
            if (timeDelta <= 0f)
                return 0f;
            
            // 计算距离（格数）
            float distance = pawn.Position.DistanceTo(lastPosition);
            
            // 计算速度（格/秒）
            float speed = distance / timeDelta;
            
            // 更新记录
            lastPosition = pawn.Position;
            lastPositionTick = currentTick;
            
            return speed;
        }
        
        /// <summary>
        /// 更新速度历史
        /// </summary>
        private void UpdateSpeedHistory(float currentSpeed)
        {
            speedHistory.Enqueue(currentSpeed);
            while (speedHistory.Count > Props.speedHistoryFrameCount)
            {
                speedHistory.Dequeue();
            }
        }
        
        /// <summary>
        /// 获取平均速度
        /// </summary>
        private float GetAverageSpeed()
        {
            if (speedHistory.Count == 0)
                return 0f;
            
            float sum = 0f;
            foreach (float speed in speedHistory)
            {
                sum += speed;
            }
            
            return sum / speedHistory.Count;
        }
        
        /// <summary>
        /// 确定速度阶段
        /// </summary>
        private void DetermineSpeedStage(float averageSpeed)
        {
            // 如果有冷却，保持当前阶段
            if (stageTransitionCooldown > 0)
                return;
            
            SpeedStage newStage;
            
            if (averageSpeed <= Props.minSpeedForStage1)
            {
                newStage = SpeedStage.Stage0;
            }
            else if (averageSpeed >= Props.minSpeedForStage2)
            {
                newStage = SpeedStage.Stage2;
            }
            else
            {
                newStage = SpeedStage.Stage1;
            }
            
            // 阶段变化时设置冷却
            if (newStage != currentStage)
            {
                currentStage = newStage;
                stageTransitionCooldown = Props.stageTransitionCooldownTicks;
                
                if (Props.enableDebugLogging)
                {
                    Log.Message($"[HighSpeedCollision] {parent.Label} transitioned to Stage {(int)currentStage} " +
                               $"at speed {averageSpeed:F2} cells/sec");
                }
            }
        }
        
        /// <summary>
        /// 应用阶段效果
        /// </summary>
        private void ApplyStageEffects(Pawn pawn)
        {
            if (currentStage == SpeedStage.Stage0)
                return;
            
            // 获取碰撞区域内的所有敌人
            List<Pawn> enemiesInArea = GetEnemiesInCollisionArea(pawn);
            
            foreach (Pawn enemy in enemiesInArea)
            {
                if (enemy == null || enemy.Destroyed || enemy.Dead || processedPawnsThisTick.Contains(enemy))
                    continue;
                
                switch (currentStage)
                {
                    case SpeedStage.Stage1:
                        ApplyStage1Effects(pawn, enemy);
                        break;
                    case SpeedStage.Stage2:
                        ApplyStage2Effects(pawn, enemy);
                        break;
                }
                
                processedPawnsThisTick.Add(enemy);
            }
        }
        
        /// <summary>
        /// 应用阶段1效果（伤害+hediff）
        /// </summary>
        private void ApplyStage1Effects(Pawn attacker, Pawn target)
        {
            // 检查目标是否已有hediff
            bool alreadyHasHediff = target.health.hediffSet.HasHediff(Props.stage1Hediff);
            
            // 如果已有hediff，不造成伤害
            if (alreadyHasHediff && Props.stage1HediffPreventsDamage)
                return;
            
            // 造成伤害
            if (Props.stage1DamageAmount > 0f)
            {
                ApplyDamage(attacker, target, Props.stage1DamageAmount, Props.stage1DamageDef);
            }
            
            // 应用hediff
            if (Props.stage1Hediff != null)
            {
                Hediff hediff = HediffMaker.MakeHediff(Props.stage1Hediff, target);
                if (Props.stage1HediffDurationTicks > 0)
                {
                    hediff.Severity = 1f;
                    hediff.TryGetComp<HediffComp_Disappears>()?.CompPostMake();
                }
                target.health.AddHediff(hediff);
            }
            
            // 播放效果
            PlayStage1Effects(attacker, target);
            
            if (Props.enableDebugLogging)
            {
                Log.Message($"[HighSpeedCollision] Stage1: {attacker.Label} -> {target.Label}, " +
                           $"Damage: {Props.stage1DamageAmount}, Hediff: {Props.stage1Hediff?.defName}");
            }
        }
        
        /// <summary>
        /// 应用阶段2效果（伤害+击飞）
        /// </summary>
        private void ApplyStage2Effects(Pawn attacker, Pawn target)
        {
            // 造成伤害
            if (Props.stage2DamageAmount > 0f)
            {
                ApplyDamage(attacker, target, Props.stage2DamageAmount, Props.stage2DamageDef);
            }
            
            // 执行击飞
            PerformKnockback(attacker, target);
            
            // 播放效果
            PlayStage2Effects(attacker, target);
            
            if (Props.enableDebugLogging)
            {
                Log.Message($"[HighSpeedCollision] Stage2: {attacker.Label} -> {target.Label}, " +
                           $"Damage: {Props.stage2DamageAmount}, Knockback");
            }
        }
        
        /// <summary>
        /// 执行击飞（参考CompAbilityEffect_FanShapedStunKnockback）
        /// </summary>
        private void PerformKnockback(Pawn attacker, Pawn target)
        {
            if (target == null || target.Destroyed || target.Dead || attacker.Map == null)
                return;
            
            // 计算击飞方向（从攻击者指向目标）
            IntVec3 knockbackDirection = CalculateKnockbackDirection(attacker, target.Position);
            
            // 寻找击飞位置
            IntVec3 knockbackDestination = FindKnockbackDestination(attacker, target, knockbackDirection);
            
            // 如果找到有效位置，执行击飞
            if (knockbackDestination.IsValid && knockbackDestination != target.Position)
            {
                CreateKnockbackFlyer(attacker, target, knockbackDestination);
            }
        }
        
        /// <summary>
        /// 计算击飞方向
        /// </summary>
        private IntVec3 CalculateKnockbackDirection(Pawn attacker, IntVec3 targetPosition)
        {
            IntVec3 direction = targetPosition - attacker.Position;
            
            // 标准化方向
            if (direction.x != 0 || direction.z != 0)
            {
                if (Mathf.Abs(direction.x) > Mathf.Abs(direction.z))
                {
                    return new IntVec3(Mathf.Sign(direction.x) > 0 ? 1 : -1, 0, 0);
                }
                else
                {
                    return new IntVec3(0, 0, Mathf.Sign(direction.z) > 0 ? 1 : -1);
                }
            }
            
            // 如果攻击者和目标在同一位置，使用随机方向
            return new IntVec3(Rand.Value > 0.5f ? 1 : -1, 0, 0);
        }
        
        /// <summary>
        /// 寻找击飞位置
        /// </summary>
        private IntVec3 FindKnockbackDestination(Pawn attacker, Pawn target, IntVec3 direction)
        {
            Map map = attacker.Map;
            IntVec3 currentPos = target.Position;
            
            // 从最大距离开始向回找
            for (int distance = Props.stage2KnockbackDistance; distance >= 1; distance--)
            {
                IntVec3 testPos = currentPos + (direction * distance);
                
                if (!IsValidKnockbackDestination(testPos, map, target, attacker))
                    continue;
                
                return testPos;
            }
            
            return currentPos;
        }
        
        /// <summary>
        /// 检查击飞位置是否有效
        /// </summary>
        private bool IsValidKnockbackDestination(IntVec3 destination, Map map, Pawn victim, Pawn attacker)
        {
            if (!destination.IsValid || !destination.InBounds(map))
                return false;
            
            if (!destination.Standable(map))
                return false;
            
            // 检查是否有其他pawn
            Pawn existingPawn = destination.GetFirstPawn(map);
            if (existingPawn != null && existingPawn != victim)
                return false;
            
            // 检查视线
            if (Props.requireLineOfSightForKnockback && !GenSight.LineOfSight(victim.Position, destination, map))
                return false;
            
            return true;
        }
        
        /// <summary>
        /// 创建击飞飞行器
        /// </summary>
        private void CreateKnockbackFlyer(Pawn attacker, Pawn target, IntVec3 destination)
        {
            try
            {
                Map map = attacker.Map;
                
                // 使用自定义飞行器或默认飞行器
                ThingDef flyerDef = Props.knockbackFlyerDef ?? ThingDefOf.PawnFlyer;
                
                // 创建飞行器
                PawnFlyer flyer = PawnFlyer.MakeFlyer(
                    flyerDef,
                    target,
                    destination,
                    Props.flightEffecterDef,
                    Props.landingSound,
                    false,
                    null,
                    null,
                    new LocalTargetInfo(destination)
                );
                
                if (flyer != null)
                {
                    GenSpawn.Spawn(flyer, destination, map);
                }
            }
            catch (Exception ex)
            {
                Log.Error($"[HighSpeedCollision] Exception creating PawnFlyer: {ex}");
            }
        }
        
        /// <summary>
        /// 应用伤害
        /// </summary>
        private void ApplyDamage(Pawn attacker, Pawn target, float amount, DamageDef damageDef)
        {
            if (amount <= 0f || damageDef == null)
                return;
            
            DamageInfo damageInfo = new DamageInfo(
                damageDef,
                amount,
                Props.armorPenetration,
                -1f,
                attacker,
                null
            );
            
            target.TakeDamage(damageInfo);
        }
        
        /// <summary>
        /// 播放阶段1效果
        /// </summary>
        private void PlayStage1Effects(Pawn attacker, Pawn target)
        {
            if (Props.stage1Effecter != null && attacker.Map != null)
            {
                Effecter effect = Props.stage1Effecter.Spawn();
                effect.Trigger(new TargetInfo(attacker.Position, attacker.Map), 
                             new TargetInfo(target.Position, attacker.Map));
                effect.Cleanup();
            }
            
            if (Props.stage1Sound != null && attacker.Map != null)
            {
                Props.stage1Sound.PlayOneShot(new TargetInfo(target.Position, attacker.Map));
            }
        }
        
        /// <summary>
        /// 播放阶段2效果
        /// </summary>
        private void PlayStage2Effects(Pawn attacker, Pawn target)
        {
            if (Props.stage2Effecter != null && attacker.Map != null)
            {
                Effecter effect = Props.stage2Effecter.Spawn();
                effect.Trigger(new TargetInfo(attacker.Position, attacker.Map), 
                             new TargetInfo(target.Position, attacker.Map));
                effect.Cleanup();
            }
            
            if (Props.stage2Sound != null && attacker.Map != null)
            {
                Props.stage2Sound.PlayOneShot(new TargetInfo(target.Position, attacker.Map));
            }
        }
        
        /// <summary>
        /// 获取碰撞区域内的所有敌人
        /// </summary>
        private List<Pawn> GetEnemiesInCollisionArea(Pawn pawn)
        {
            List<Pawn> enemies = new List<Pawn>();
            
            // 获取碰撞区域
            CellRect collisionArea = GetCollisionArea(pawn);
            
            // 检查区域内的每个单元格
            foreach (IntVec3 cell in collisionArea)
            {
                if (!cell.InBounds(pawn.Map))
                    continue;
                
                // 获取单元格内的所有pawn
                List<Thing> things = cell.GetThingList(pawn.Map);
                foreach (Thing thing in things)
                {
                    if (thing is Pawn otherPawn && otherPawn != pawn)
                    {
                        // 检查是否为敌人
                        if (IsValidTarget(pawn, otherPawn))
                        {
                            enemies.Add(otherPawn);
                        }
                    }
                }
            }
            
            return enemies;
        }
        
        /// <summary>
        /// 获取碰撞区域
        /// </summary>
        private CellRect GetCollisionArea(Pawn pawn)
        {
            int currentTick = Find.TickManager.TicksGame;
            
            // 每10帧重新计算一次区域，或当位置变化时
            if (currentTick - lastAreaRecalculationTick > 10 || 
                pawn.Position != collisionAreaCache.CenterCell)
            {
                int radius = Props.collisionAreaRadius;
                IntVec3 center = pawn.Position;
                
                collisionAreaCache = new CellRect(
                    center.x - radius,
                    center.z - radius,
                    radius * 2 + 1,
                    radius * 2 + 1
                );
                
                collisionAreaCache.ClipInsideMap(pawn.Map);
                lastAreaRecalculationTick = currentTick;
            }
            
            return collisionAreaCache;
        }
        
        /// <summary>
        /// 检查是否是有效目标
        /// </summary>
        private bool IsValidTarget(Pawn attacker, Pawn target)
        {
            if (target == null || target.Destroyed || target.Dead)
                return false;
            
            // 检查是否为敌人
            if (Props.onlyAffectEnemies && !target.HostileTo(attacker))
                return false;
            
            // 检查是否排除友方
            if (Props.excludeAlliedPawns && target.Faction == attacker.Faction)
                return false;
            
            // 检查是否排除中立
            if (Props.excludeNeutralPawns && !target.HostileTo(attacker))
                return false;
            
            return true;
        }
        
        /// <summary>
        /// 检查Pawn是否可以移动
        /// </summary>
        private bool CanMove(Pawn pawn)
        {
            if (pawn.Downed || pawn.Dead || pawn.InMentalState)
                return false;
            
            if (pawn.stances?.stunner?.Stunned ?? false)
                return false;
            
            return true;
        }
        
        /// <summary>
        /// 重置到阶段0
        /// </summary>
        private void ResetToStage0()
        {
            currentStage = SpeedStage.Stage0;
            
            // 清空速度历史
            speedHistory.Clear();
            for (int i = 0; i < Props.speedHistoryFrameCount; i++)
            {
                speedHistory.Enqueue(0f);
            }
        }
        
        /// <summary>
        /// 绘制调试视觉效果
        /// </summary>
        private void DrawDebugVisuals(Pawn pawn)
        {
            if (!pawn.Spawned)
                return;
            
            // 绘制碰撞区域
            CellRect area = GetCollisionArea(pawn);
            GenDraw.DrawFieldEdges(area.Cells.ToList(), GetStageColor(currentStage));
            
            // 绘制速度指示器
            float averageSpeed = GetAverageSpeed();
            string speedText = $"Speed: {averageSpeed:F1} cells/sec\nStage: {(int)currentStage}";
            
            Vector3 drawPos = pawn.DrawPos + new Vector3(0, 0, 1f);
            GenMapUI.DrawText(drawPos, speedText, GetStageColor(currentStage));
        }

        /// <summary>
        /// 获取阶段颜色
        /// </summary>
        private Color GetStageColor(SpeedStage stage)
        {
            switch (stage)
            {
                case SpeedStage.Stage0: return Color.gray;
                case SpeedStage.Stage1: return Color.yellow;
                case SpeedStage.Stage2: return Color.red;
                default: return Color.white;
            }
        }
        
        /// <summary>
        /// 获取调试信息
        /// </summary>
        public string GetDebugInfo()
        {
            float averageSpeed = GetAverageSpeed();
            
            return $"HighSpeedCollision Debug Info:\n" +
                   $"Current Stage: {(int)currentStage}\n" +
                   $"Average Speed: {averageSpeed:F2} cells/sec\n" +
                   $"Stage 1 Threshold: {Props.minSpeedForStage1:F2}\n" +
                   $"Stage 2 Threshold: {Props.minSpeedForStage2:F2}\n" +
                   $"Speed History: {speedHistory.Count} frames\n" +
                   $"Stage Cooldown: {stageTransitionCooldown} ticks";
        }
        
        public override void PostExposeData()
        {
            base.PostExposeData();
            
            Scribe_Values.Look(ref currentStage, "currentStage", SpeedStage.Stage0);
            Scribe_Values.Look(ref stageTransitionCooldown, "stageTransitionCooldown", 0);
            Scribe_Values.Look(ref lastPosition, "lastPosition", IntVec3.Invalid);
            Scribe_Values.Look(ref lastPositionTick, "lastPositionTick", -1);
            
            // 保存速度历史
            if (Scribe.mode == LoadSaveMode.Saving)
            {
                List<float> speedList = speedHistory.ToList();
                Scribe_Collections.Look(ref speedList, "speedHistory", LookMode.Value);
            }
            else if (Scribe.mode == LoadSaveMode.LoadingVars)
            {
                List<float> speedList = null;
                Scribe_Collections.Look(ref speedList, "speedHistory", LookMode.Value);
                
                speedHistory.Clear();
                if (speedList != null)
                {
                    foreach (float speed in speedList)
                    {
                        speedHistory.Enqueue(speed);
                    }
                }
                
                // 确保有足够的历史数据
                while (speedHistory.Count < Props.speedHistoryFrameCount)
                {
                    speedHistory.Enqueue(0f);
                }
            }
        }
    }
    
    /// <summary>
    /// 高速移动撞击组件属性
    /// </summary>
    public class CompProperties_HighSpeedCollision : CompProperties
    {
        // === 速度阈值配置 ===
        
        /// <summary>
        /// 进入阶段1所需的最小速度（格/秒）
        /// </summary>
        public float minSpeedForStage1 = 3f;
        
        /// <summary>
        /// 进入阶段2所需的最小速度（格/秒）
        /// </summary>
        public float minSpeedForStage2 = 6f;
        
        /// <summary>
        /// 速度历史帧数（用于计算平均速度）
        /// </summary>
        public int speedHistoryFrameCount = 10;
        
        /// <summary>
        /// 阶段转换冷却时间（tick）
        /// </summary>
        public int stageTransitionCooldownTicks = 5;
        
        // === 碰撞区域配置 ===
        
        /// <summary>
        /// 碰撞区域半径（以pawn为中心的正方形）
        /// </summary>
        public int collisionAreaRadius = 1;
        
        // === 目标过滤 ===
        
        /// <summary>
        /// 只影响敌人
        /// </summary>
        public bool onlyAffectEnemies = true;
        
        /// <summary>
        /// 排除友方单位
        /// </summary>
        public bool excludeAlliedPawns = true;
        
        /// <summary>
        /// 排除中立单位
        /// </summary>
        public bool excludeNeutralPawns = false;
        
        // === 阶段1效果配置 ===
        
        /// <summary>
        /// 阶段1伤害类型
        /// </summary>
        public DamageDef stage1DamageDef = DamageDefOf.Blunt;
        
        /// <summary>
        /// 阶段1伤害量
        /// </summary>
        public float stage1DamageAmount = 5f;
        
        /// <summary>
        /// 阶段1护甲穿透
        /// </summary>
        public float armorPenetration = 0f;
        
        /// <summary>
        /// 阶段1应用的hediff
        /// </summary>
        public HediffDef stage1Hediff;
        
        /// <summary>
        /// 阶段1hediff持续时间（tick）
        /// </summary>
        public int stage1HediffDurationTicks = 60;
        
        /// <summary>
        /// 拥有hediff的目标是否免疫伤害
        /// </summary>
        public bool stage1HediffPreventsDamage = true;
        
        /// <summary>
        /// 阶段1效果器
        /// </summary>
        public EffecterDef stage1Effecter;
        
        /// <summary>
        /// 阶段1音效
        /// </summary>
        public SoundDef stage1Sound;
        
        // === 阶段2效果配置 ===
        
        /// <summary>
        /// 阶段2伤害类型
        /// </summary>
        public DamageDef stage2DamageDef = DamageDefOf.Blunt;
        
        /// <summary>
        /// 阶段2伤害量
        /// </summary>
        public float stage2DamageAmount = 10f;
        
        /// <summary>
        /// 阶段2击退距离
        /// </summary>
        public int stage2KnockbackDistance = 3;
        
        /// <summary>
        /// 击退是否需要视线
        /// </summary>
        public bool requireLineOfSightForKnockback = true;
        
        /// <summary>
        /// 阶段2效果器
        /// </summary>
        public EffecterDef stage2Effecter;
        
        /// <summary>
        /// 阶段2音效
        /// </summary>
        public SoundDef stage2Sound;
        
        // === 击飞配置 ===
        
        /// <summary>
        /// 击退飞行器定义
        /// </summary>
        public ThingDef knockbackFlyerDef;
        
        /// <summary>
        /// 飞行效果器
        /// </summary>
        public EffecterDef flightEffecterDef;
        
        /// <summary>
        /// 落地音效
        /// </summary>
        public SoundDef landingSound;
        
        // === 调试配置 ===
        
        /// <summary>
        /// 启用调试日志
        /// </summary>
        public bool enableDebugLogging = false;
        
        /// <summary>
        /// 启用调试视觉效果
        /// </summary>
        public bool enableDebugVisuals = false;
        
        /// <summary>
        /// 绘制速度历史图
        /// </summary>
        public bool debugDrawSpeedHistory = false;

        // === 狭窄地形阻挡配置 ===
        /// <summary>
        /// 是否启用狭窄地形阻挡
        /// </summary>
        public bool narrowTerrainBlocked = false;

        /// <summary>
        /// 最高阻挡减益值（0-1之间）
        /// </summary>
        public float maxBlockPenalty = 0.5f;

        /// <summary>
        /// 地形检查间隔（ticks）
        /// </summary>
        public int terrainCheckInterval = 60;

        /// <summary>
        /// 阻挡减益Hediff定义
        /// </summary>
        public HediffDef blockedHediff;

        public CompProperties_HighSpeedCollision()
        {
            compClass = typeof(CompHighSpeedCollision);
        }
    }
}