HitboxDisplay lots of broken stuff

2026-11-09 02:51:36 +03:00
1 parent 9203f269db
commit f40a10912c
@@ -12,6 +12,9 @@ namespace Code.OfficeGame.BattleMode.Actions
        public NavMeshPath Path;
        public Vector3[] Corners;
        public int CurrentCornerIndex;
+        
+        public bool IsRotateOnly;
+        public int CurrentFrame;
        public override BattleActionData GetSnapshot()
        {
            Vector3[] cornersCopy = null;
@@ -11,27 +11,151 @@ namespace Code.OfficeGame.BattleMode.Actions
    {
        private const float StoppingDistance = 0.15f;
        private const float RotateDistance = 1f;
+        private const float NavMeshSampleRadius = 1.5f;
+        private const float TurnSpeedDegPerSec = 720f; // Скорость вращения на месте (градусов/сек)

        private int MoveStateHash => Animator.StringToHash("WalkBlend");
-        
+
+        public override BattleActionType ActionType => BattleActionType.Move;
+        public override DeciderType DeciderType => DeciderType.Position;
+
+        public override BattleActionData MountAndGetFrames(EntityProperties entity, BattleActionDecisionResult result)
+        {
+            MovementBattleActionData data = new();
+            var positionDecisionResult = (PositionBattleActionDeciderResult)result;
+
+            Vector3 startPos = entity.KinematicCharacterMotor.TransientPosition;
+            Vector3 targetPos = positionDecisionResult.Position;
+
+            // 1. Проверяем дистанцию в плоскости XZ
+            Vector3 toTargetXZ = targetPos - startPos;
+            toTargetXZ.y = 0f;
+            float distanceXZ = toTargetXZ.magnitude;
+
+            // ЕСЛИ ВПЛОТНУЮ: отключаем перемещение, оставляем только поворот
+            if (distanceXZ <= StoppingDistance)
+            {
+                data.IsRotateOnly = true;
+                data.Corners = null;
+
+                float angle = Quaternion.Angle(entity.KinematicCharacterMotor.TransientRotation, positionDecisionResult.Rotation);
+                
+                // Если персонаж уже смотрит в нужную сторону — 0 кадров
+                if (angle < 1f)
+                {
+                    data.TotalFrames = 0;
+                }
+                else
+                {
+                    float stepPerFrame = TurnSpeedDegPerSec * BattleTimeline.TickDelta;
+                    data.TotalFrames = Mathf.Max(2, Mathf.CeilToInt(angle / stepPerFrame));
+                }
+
+                return data;
+            }
+
+            // 2. ДВИЖЕНИЕ: проецируем точки строго на полигоны NavMesh
+            bool hasStart = NavMesh.SamplePosition(startPos, out NavMeshHit startHit, NavMeshSampleRadius, NavMesh.AllAreas);
+            bool hasTarget = NavMesh.SamplePosition(targetPos, out NavMeshHit targetHit, NavMeshSampleRadius, NavMesh.AllAreas);
+
+            if (!hasStart || !hasTarget)
+            {
+                data.TotalFrames = 0;
+                return data;
+            }
+
+            Vector3 validStart = startHit.position;
+            Vector3 validTarget = targetHit.position;
+
+            // 3. Прямая видимость: если препятствий нет, идём по идеальной прямой без квантования полигонов NavMesh
+            if (!NavMesh.Raycast(validStart, validTarget, out _, NavMesh.AllAreas))
+            {
+                data.Corners = new[] { startPos, validTarget };
+                data.CurrentCornerIndex = 1;
+                data.TotalFrames = CalculatePathFrames(data.Corners, entity.MovementController);
+                return data;
+            }
+
+            // 4. Обход препятствий: строим путь и отсекаем частичные обрубки (PathPartial)
+            NavMeshPath path = new();
+            if (NavMesh.CalculatePath(validStart, validTarget, NavMesh.AllAreas, path) 
+                && path.status == NavMeshPathStatus.PathComplete 
+                && path.corners.Length > 1)
+            {
+                // Привязываем нулевую и финальную точки к фактическим координатам
+                path.corners[0] = startPos;
+                path.corners[^1] = validTarget;
+
+                data.Corners = path.corners;
+                data.CurrentCornerIndex = 1;
+                data.TotalFrames = CalculatePathFrames(data.Corners, entity.MovementController);
+            }
+            else
+            {
+                // Если NavMesh не смог построить полный путь (PathPartial/Invalid) — не даём ходить огрызками
+                data.TotalFrames = 0;
+            }
+
+            return data;
+        }
+
        public override void Tick(
            float tickDelta, 
            EntityProperties entity, 
            BattleActionDecisionResult battleActionDecisionResult, 
            BattleActionData battleActionData)
        {
-            if(battleActionData is not MovementBattleActionData movementActionData 
+            if (battleActionData is not MovementBattleActionData movementActionData 
               || battleActionDecisionResult is not PositionBattleActionDeciderResult positionDecisionResult)
            {
                battleActionData.Finished = true;
                return;
            }

-            var entityMovementController = entity.MovementController;
+            var movementController = entity.MovementController;

+            // -------------------------------------------------------------
+            // РЕЖИМ 1: ТОЛЬКО ПОВОРОТ НА МЕСТЕ (КОГДА ПОЗИЦИЯ ВПЛОТНУЮ)
+            // -------------------------------------------------------------
+            if (movementActionData.IsRotateOnly)
+            {
+                movementActionData.CurrentFrame++;
+
+                float angle = Quaternion.Angle(movementController.Motor.TransientRotation, positionDecisionResult.Rotation);
+                int framesLeft = Mathf.Max(1, movementActionData.TotalFrames - movementActionData.CurrentFrame + 1);
+                float stepAngle = angle / framesLeft;
+
+                Quaternion nextRot = Quaternion.RotateTowards(
+                    movementController.Motor.TransientRotation,
+                    positionDecisionResult.Rotation,
+                    stepAngle
+                );
+
+                entity.KinematicCharacterMotor.SetRotation(nextRot);
+                StopMovementAndFinish(movementController);
+
+                KinematicCharacterSystem.Simulate(
+                    tickDelta,
+                    KinematicCharacterSystem.CharacterMotors,
+                    KinematicCharacterSystem.PhysicsMovers
+                );
+
+                if (movementActionData.CurrentFrame >= movementActionData.TotalFrames || angle <= 0.5f)
+                {
+                    entity.KinematicCharacterMotor.SetRotation(positionDecisionResult.Rotation);
+                    battleActionData.Finished = true;
+                }
+
+                return;
+            }
+
+            // -------------------------------------------------------------
+            // РЕЖИМ 2: ПЕРЕДВИЖЕНИЕ ПО ПУТИ
+            // -------------------------------------------------------------
            if (movementActionData.Corners == null || movementActionData.CurrentCornerIndex >= movementActionData.Corners.Length)
            {
-                StopMovementAndFinish(entityMovementController);
+                entity.KinematicCharacterMotor.SetRotation(positionDecisionResult.Rotation);
+                StopMovementAndFinish(movementController);
                battleActionData.Finished = true;
                return;
            }
@@ -39,14 +163,13 @@ namespace Code.OfficeGame.BattleMode.Actions
            if (!movementActionData.WasStarted)
            {
                movementActionData.WasStarted = true;
-                
                float transitionDurationSeconds = 10 * BattleTimeline.TickDelta;
-                
                entity.animator.CrossFadeInFixedTime(MoveStateHash, transitionDurationSeconds);
            }
-            
+
            Vector3 currentPos = entity.KinematicCharacterMotor.TransientPosition;

+            // Пропускаем пройденные углы
            while (movementActionData.CurrentCornerIndex < movementActionData.Corners.Length)
            {
                Vector3 toCorner = movementActionData.Corners[movementActionData.CurrentCornerIndex] - currentPos;
@@ -58,53 +181,50 @@ namespace Code.OfficeGame.BattleMode.Actions
                    break;
            }

+            // Если все точки пройдены до шага симуляции
            if (movementActionData.CurrentCornerIndex >= movementActionData.Corners.Length)
            {
-                StopMovementAndFinish(entity.MovementController);
+                entity.KinematicCharacterMotor.SetRotation(positionDecisionResult.Rotation);
+                StopMovementAndFinish(movementController);
                KinematicCharacterSystem.Simulate(
                    tickDelta,
                    KinematicCharacterSystem.CharacterMotors,
                    KinematicCharacterSystem.PhysicsMovers
                );
-                
+
                battleActionData.Finished = true;
                return;
            }
-            

            Vector3 targetCorner = movementActionData.Corners[movementActionData.CurrentCornerIndex];
-            
            Vector3 moveDirection = targetCorner - currentPos;
            moveDirection.y = 0f;

            float distance = moveDirection.magnitude;
            Vector3 moveNormal = distance > 0.0001f ? moveDirection / distance : Vector3.zero;

-            bool preLastPoint = movementActionData.CurrentCornerIndex >= movementActionData.Corners.Length - 1
-                                && distance < RotateDistance;
-            
-            float maxStep = entityMovementController.MaxStableMoveSpeed * tickDelta;
-            float inputMagnitude = 
-                (movementActionData.CurrentCornerIndex == movementActionData.Corners.Length - 1 
-                 && distance < maxStep 
-                 && maxStep > 0f)
-                    ? distance / maxStep
-                    : 1f;
-            
-            Quaternion lookRotation;
-            
-            if(preLastPoint) lookRotation = positionDecisionResult.Rotation;
-            else lookRotation = moveNormal.sqrMagnitude > 0.0001f
-                ? Quaternion.LookRotation(moveNormal, entityMovementController.Motor.CharacterUp)
-                : entityMovementController.Motor.TransientRotation;
-            
+            bool isLastCorner = movementActionData.CurrentCornerIndex == movementActionData.Corners.Length - 1;
+            bool preLastPoint = isLastCorner && distance < RotateDistance;
+
+            float maxStep = movementController.MaxStableMoveSpeed * tickDelta;
+
+            float inputMagnitude = (isLastCorner && distance < maxStep && maxStep > 0f)
+                ? distance / maxStep
+                : 1f;
+
+            Quaternion lookRotation = preLastPoint
+                ? positionDecisionResult.Rotation
+                : (moveNormal.sqrMagnitude > 0.0001f
+                    ? Quaternion.LookRotation(moveNormal, movementController.Motor.CharacterUp)
+                    : movementController.Motor.TransientRotation);
+
            var aiInputs = new AICharacterInputs
            {
                MoveVector = moveNormal * inputMagnitude,
                Look = lookRotation
            };

-            entityMovementController.SetInputs(ref aiInputs);
+            movementController.SetInputs(ref aiInputs);

            KinematicCharacterSystem.Simulate(
                tickDelta,
@@ -112,15 +232,15 @@ namespace Code.OfficeGame.BattleMode.Actions
                KinematicCharacterSystem.PhysicsMovers
            );

-            Vector3 postMovePos = entityMovementController.Motor.TransientPosition;
+            // Проверка достижения конечной точки после физического тика
+            Vector3 postMovePos = movementController.Motor.TransientPosition;
            Vector3 toFinal = movementActionData.Corners[^1] - postMovePos;
            toFinal.y = 0f;

-            if (movementActionData.CurrentCornerIndex >= movementActionData.Corners.Length - 1 
-                && toFinal.sqrMagnitude <= StoppingDistance * StoppingDistance)
+            if (isLastCorner && toFinal.sqrMagnitude <= StoppingDistance * StoppingDistance)
            {
                entity.KinematicCharacterMotor.SetRotation(positionDecisionResult.Rotation);
-                StopMovementAndFinish(entityMovementController);
+                StopMovementAndFinish(movementController);
                battleActionData.Finished = true;
            }
        }
@@ -136,32 +256,6 @@ namespace Code.OfficeGame.BattleMode.Actions
            movementController.Motor.BaseVelocity = Vector3.zero;
        }

-        public override BattleActionType ActionType => BattleActionType.Move;
-        public override DeciderType DeciderType => DeciderType.Position;
-
-        // TODO всегда выдаёт разное количество кадров
-        public override BattleActionData MountAndGetFrames(EntityProperties entity, BattleActionDecisionResult result)
-        {
-            MovementBattleActionData movementBattleActionData = new();
-            
-            Vector3 startPos = entity.KinematicCharacterMotor.TransientPosition;
-            
-            NavMeshPath path = new();
-            
-            var positionDecisionResult = (PositionBattleActionDeciderResult) result;
-
-            if ((positionDecisionResult.Position - startPos).sqrMagnitude > StoppingDistance * StoppingDistance
-                && NavMesh.CalculatePath(startPos, positionDecisionResult.Position, NavMesh.AllAreas, path)
-                && path.corners.Length > 0)
-            {
-                movementBattleActionData.Corners = path.corners;
-                movementBattleActionData.CurrentCornerIndex = movementBattleActionData.Corners.Length > 1 ? 1 : 0;
-                movementBattleActionData.TotalFrames = CalculatePathFrames(movementBattleActionData.Corners, entity.MovementController);
-            }
-            else movementBattleActionData.TotalFrames = 0;
-            
-            return movementBattleActionData;
-        }
        private int CalculatePathFrames(Vector3[] corners, MovementController movementController)
        {
            if (corners == null || corners.Length < 2) 
@@ -174,17 +268,15 @@ namespace Code.OfficeGame.BattleMode.Actions
                Vector3 segment = corners[i] - corners[i - 1];
                segment.y = 0f;
                totalDistanceXZ += segment.magnitude;
-                Debug.Log($"{i} corner is {segment.magnitude}");
            }

            float effectiveDistance = Mathf.Max(0f, totalDistanceXZ - StoppingDistance);
-
            float stepPerFrame = movementController.MaxStableMoveSpeed * BattleTimeline.TickDelta;

            if (stepPerFrame <= 0.0001f) 
                return 0;

-            return Mathf.CeilToInt(effectiveDistance / stepPerFrame);
-        } 
+            return Mathf.Max(1, Mathf.CeilToInt(effectiveDistance / stepPerFrame));
+        }
    }
 }
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6a7bbf0cc25b4dadb86824c49477ed47
+timeCreated: 1793990021
@@ -0,0 +1,182 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Code.OfficeGame.BattleMode.Actions
+{
+    public class EntityPreviewVisuals : MonoBehaviour
+    {
+        [Header("Материалы для MKToon")]
+        [Tooltip("Полупрозрачный материал для статичного слепка в точке снапшота")]
+        [SerializeField]
+        private Material snapshotGhostMaterial;
+
+        [Tooltip(
+            "Опционально: материал для самой движущейся модели во время превью (если null — меняется только Rim/Tint)")]
+        [SerializeField]
+        private Material activePreviewMaterial;
+
+        [Header("Настройки подсветки MKToon (если activePreviewMaterial не задан)")] [SerializeField]
+        private Color previewAlbedoTint = new Color(0.6f, 0.85f, 1f, 1f);
+
+        [SerializeField, ColorUsage(true, true)]
+        private Color previewRimColor = new Color(0f, 1.5f, 2f, 1f);
+
+        private SkinnedMeshRenderer[] _skinnedRenderers;
+        private MeshRenderer[] _meshRenderers;
+
+        // Кэш оригинальных материалов
+        private readonly Dictionary<Renderer, Material[]> _originalMaterials = new();
+
+        // Пул объектов для статичного слепка (чтобы не делать Instantiate и new Mesh каждый цикл превью)
+        private GameObject _snapshotGhostRoot;
+        private readonly List<Mesh> _bakedMeshes = new();
+        private readonly List<MeshFilter> _ghostMeshFilters = new();
+        private readonly List<MeshRenderer> _ghostMeshRenderers = new();
+
+        private MaterialPropertyBlock _propBlock;
+        private static readonly int AlbedoColorId = Shader.PropertyToID("_AlbedoColor");
+        private static readonly int RimColorId = Shader.PropertyToID("_RimColor");
+
+        private void Awake()
+        {
+            _propBlock = new MaterialPropertyBlock();
+            _skinnedRenderers = GetComponentsInChildren<SkinnedMeshRenderer>();
+            _meshRenderers = GetComponentsInChildren<MeshRenderer>();
+
+            // Сохраняем родные материалы MKToon
+            foreach (var sr in _skinnedRenderers)
+                _originalMaterials[sr] = sr.sharedMaterials;
+
+            foreach (var mr in _meshRenderers)
+                _originalMaterials[mr] = mr.sharedMaterials;
+
+            InitializeGhostPool();
+        }
+
+        private void InitializeGhostPool()
+        {
+            _snapshotGhostRoot = new GameObject($"{gameObject.name}_SnapshotGhost");
+            _snapshotGhostRoot.SetActive(false);
+
+            // Создаём легковесные меш-объекты под каждый SkinnedMeshRenderer персонажа
+            for (int i = 0; i < _skinnedRenderers.Length; i++)
+            {
+                var partGo = new GameObject($"GhostPart_{i}");
+                partGo.transform.SetParent(_snapshotGhostRoot.transform, false);
+
+                var mf = partGo.AddComponent<MeshFilter>();
+                var mr = partGo.AddComponent<MeshRenderer>();
+
+                // Отключаем тени у призрака для чистоты картинки и производительности
+                mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
+
+                var bakedMesh = new Mesh { name = $"BakedGhostMesh_{i}" };
+                mf.sharedMesh = bakedMesh;
+
+                _bakedMeshes.Add(bakedMesh);
+                _ghostMeshFilters.Add(mf);
+                _ghostMeshRenderers.Add(mr);
+            }
+        }
+
+        /// <summary>
+        /// Вызывается перед стартом цикла PreviewBattleLoopAsync (в момент снятия снапшота)
+        /// </summary>
+        public void ShowPreviewState(bool spawnStaticSnapshotGhost = true)
+        {
+            // 1. Запекаем полупрозрачную статую в текущей точке снапшота
+            if (spawnStaticSnapshotGhost && snapshotGhostMaterial != null)
+            {
+                _snapshotGhostRoot.transform.SetPositionAndRotation(transform.position, transform.rotation);
+
+                for (int i = 0; i < _skinnedRenderers.Length; i++)
+                {
+                    var sr = _skinnedRenderers[i];
+                    sr.BakeMesh(_bakedMeshes[i]); // Мгновенный снимок позы скелета!
+
+                    var ghostTransform = _ghostMeshFilters[i].transform;
+                    ghostTransform.SetPositionAndRotation(sr.transform.position, sr.transform.rotation);
+                    // ghostTransform.localScale = sr.transform.lossyScale;
+
+                    // Назначаем прозрачный материал на все саб-меши
+                    int subMeshCount = _bakedMeshes[i].subMeshCount;
+                    Material[] ghostMats = new Material[Mathf.Max(1, subMeshCount)];
+                    for (int m = 0; m < ghostMats.Length; m++)
+                        ghostMats[m] = snapshotGhostMaterial;
+
+                    _ghostMeshRenderers[i].sharedMaterials = ghostMats;
+                }
+
+                _snapshotGhostRoot.SetActive(true);
+            }
+
+            // 2. Меняем внешний вид самой модели, которая сейчас побежит в превью
+            ApplyPreviewLookToMainModel();
+        }
+
+        /// <summary>
+        /// Вызывается в блоке finally в PreviewBattleLoopAsync
+        /// </summary>
+        public void HidePreviewState()
+        {
+            if (_snapshotGhostRoot != null)
+                _snapshotGhostRoot.SetActive(false);
+
+            RestoreMainModelLook();
+        }
+
+        private void ApplyPreviewLookToMainModel()
+        {
+            foreach (var (renderer, origMats) in _originalMaterials)
+            {
+                if (renderer == null) continue;
+
+                // Способ 1: Если задан отдельный материал для превью — подменяем sharedMaterials
+                if (activePreviewMaterial != null)
+                {
+                    Material[] previewMats = new Material[origMats.Length];
+                    for (int i = 0; i < previewMats.Length; i++)
+                        previewMats[i] = activePreviewMaterial;
+
+                    renderer.sharedMaterials = previewMats;
+                }
+                // Способ 2: Иначе подкрашиваем родной MKToon через MaterialPropertyBlock (без аллокаций)
+                else
+                {
+                    renderer.GetPropertyBlock(_propBlock);
+                    _propBlock.SetColor(AlbedoColorId, previewAlbedoTint);
+                    _propBlock.SetColor(RimColorId, previewRimColor);
+                    renderer.SetPropertyBlock(_propBlock);
+                }
+            }
+        }
+
+        private void RestoreMainModelLook()
+        {
+            foreach (var (renderer, origMats) in _originalMaterials)
+            {
+                if (renderer == null) continue;
+
+                if (activePreviewMaterial != null)
+                {
+                    renderer.sharedMaterials = origMats;
+                }
+                else
+                {
+                    renderer.SetPropertyBlock(null); // Сбрасывает все переопределения PropertyBlock
+                }
+            }
+        }
+
+        private void OnDestroy()
+        {
+            foreach (var mesh in _bakedMeshes)
+            {
+                if (mesh != null) Destroy(mesh);
+            }
+
+            if (_snapshotGhostRoot != null)
+                Destroy(_snapshotGhostRoot);
+        }
+    }
+}
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 97e5f578c2c24bb7b3bd55d2b3ade97a
+timeCreated: 1793990043
@@ -13,5 +13,6 @@ namespace Code.OfficeGame.BattleMode.Actions
        public MovementController MovementController;
        public KinematicCharacterMotor KinematicCharacterMotor;
        public EntityHitBoxes EntityHitBoxes;
+        public EntityPreviewVisuals EntityPreviewVisuals;
    }
 }