Unity UGUI 程序化网格 10：状态驱动的技能范围指示器

// Assets/OnPopulateMeshBook/Chapters/Chapter10_SkillRange/
// Runtime/SkillRangeIndicator.cs · 类型、字段与绑定
using OnPopulateMeshBook.Chapter04;
using OnPopulateMeshBook.Chapter08;
using OnPopulateMeshBook.Chapter09;
using UnityEngine;

namespace OnPopulateMeshBook.Chapter10
{
    public enum SkillAimPhase
    {
        Hidden,
        Aiming
    }

    public readonly struct SkillRangeViewState
    {
        public readonly bool Visible;
        public readonly float Radius;
        public readonly float InnerRadius;
        public readonly float DirectionDegrees;
        public readonly float SweepDegrees;

        public SkillRangeViewState(
            bool visible,
            float radius,
            float innerRadius,
            float directionDegrees,
            float sweepDegrees)
        {
            Visible = visible;
            Radius = radius;
            InnerRadius = innerRadius;
            DirectionDegrees = directionDegrees;
            SweepDegrees = sweepDegrees;
        }
    }
}

namespace OnPopulateMeshBook.Chapter10
{

    public sealed class SkillRangeIndicator : MonoBehaviour
    {
        [SerializeField] private SectorGraphic sector;
        [SerializeField] private RingGraphic boundary;
        [SerializeField] private RectQuadGraphic directionLine;
        [SerializeField, Min(0.01f)] private float pixelsPerUnit = 32f;

        public SkillAimPhase Phase { get; private set; } = SkillAimPhase.Hidden;
        public SkillRangeViewState Current { get; private set; }
        public int AppliedStateCount { get; private set; }
        private bool hasState;

        public void Bind(
            SectorGraphic sectorGraphic,
            RingGraphic ringGraphic,
            RectQuadGraphic lineGraphic)
        {
            sector = sectorGraphic;
            boundary = ringGraphic;
            directionLine = lineGraphic;
        }

{
  "fixedInput": "radius=5 inner=1 direction=28.811 sweep=70 ppu=32",
  "derived": "outer=160 inner=32 start=-6.189 boundaryInner=157",
  "meshes": [
    { "component": "SectorGraphic", "vertices": 22, "indices": 60 },
    { "component": "RingGraphic", "vertices": 98, "indices": 288 },
    { "component": "RectQuadGraphic", "vertices": 4, "indices": 6 }
  ],
  "total": { "vertices": 124, "indices": 354 }
}

// SkillRangeIndicator.cs · 瞄准生命周期
        public void BeginAim(
            float radius, float innerRadius, float sweepDegrees)
        {
            Phase = SkillAimPhase.Aiming;
            Apply(new SkillRangeViewState(
                true, radius, innerRadius, 0f, sweepDegrees));
        }

        public void UpdateDirection(Vector2 localDirection)
        {
            if (Phase != SkillAimPhase.Aiming ||
                localDirection.sqrMagnitude == 0f) return;

            var degrees = Mathf.Atan2(
                localDirection.y,
                localDirection.x) * Mathf.Rad2Deg;
            Apply(new SkillRangeViewState(
                true,
                Current.Radius,
                Current.InnerRadius,
                degrees,
                Current.SweepDegrees));
        }

        public void CancelAim()
        {
            Phase = SkillAimPhase.Hidden;
            Apply(new SkillRangeViewState(
                false,
                Current.Radius,
                Current.InnerRadius,
                Current.DirectionDegrees,
                Current.SweepDegrees));
        }

        public void ConfirmAim() => CancelAim();

// SkillRangeIndicator.cs · Apply
        public void Apply(SkillRangeViewState state)
        {
            if (hasState &&
                Current.Visible == state.Visible &&
                Mathf.Approximately(Current.Radius, state.Radius) &&
                Mathf.Approximately(Current.InnerRadius, state.InnerRadius) &&
                Mathf.Approximately(
                    Current.DirectionDegrees, state.DirectionDegrees) &&
                Mathf.Approximately(
                    Current.SweepDegrees, state.SweepDegrees))
                return;

            hasState = true;
            AppliedStateCount++;
            Current = state;
            var safeRadius = Mathf.Max(0f, state.Radius);
            var radiusPixels = safeRadius * pixelsPerUnit;
            var innerPixels = Mathf.Clamp(
                state.InnerRadius, 0f, safeRadius) * pixelsPerUnit;

            gameObject.SetActive(state.Visible);
            if (!state.Visible) return;

            sector.OuterRadius = radiusPixels;
            sector.InnerRadius = innerPixels;
            sector.SweepAngle = state.SweepDegrees;
            sector.StartAngle =
                state.DirectionDegrees - state.SweepDegrees * 0.5f;

            boundary.OuterRadius = radiusPixels;
            boundary.InnerRadius =
                Mathf.Max(0f, radiusPixels - 3f);

            var lineRect = directionLine.rectTransform;
            lineRect.sizeDelta = new Vector2(radiusPixels, 3f);
            lineRect.pivot = new Vector2(0f, 0.5f);
            lineRect.localRotation = Quaternion.Euler(
                0f, 0f, state.DirectionDegrees);
        }
    }
}

// Runtime/SkillRangeDemoInput.cs · 事件到局部方向
public void OnPointerDown(PointerEventData eventData)
{
    indicator.BeginAim(radius, innerRadius, sweepDegrees);
    UpdateDirection(eventData);
}

private void UpdateDirection(PointerEventData eventData)
{
    if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(
            inputPlane, eventData.position,
            eventData.pressEventCamera, out var localPoint))
        return;
    indicator.UpdateDirection(localPoint);
}

// Tests/PlayMode/SkillRangeIndicatorTests.cs · 输入生命周期断言
input.OnPointerDown(EventAt(
    eventSystem, inputRect, Vector2.right * 100f));
input.OnDrag(EventAt(
    eventSystem, inputRect, Vector2.up * 100f));
Assert.That(
    indicator.Current.DirectionDegrees,
    Is.EqualTo(90f).Within(0.001f));

input.OnPointerUp(EventAt(
    eventSystem, inputRect, Vector2.up * 100f));
Assert.That(root.activeSelf, Is.False);

input.OnPointerDown(EventAt(
    eventSystem, inputRect, Vector2.right * 100f));
Assert.That(root.activeSelf, Is.True);

"$UNITY_EDITOR" \
  -batchmode -nographics \
  -projectPath "$PROJECT_ROOT/.tmp/unity-onpopulate-mesh-lab" \
  -runTests -testPlatform PlayMode \
  -testResults "$ARTIFACTS/playmode-results.xml" \
  -logFile "$ARTIFACTS/playmode.log"
echo "process_exit_code=$?"

process_exit_code=0
total=2 passed=2 failed=0 skipped=0 duration=0.0366424s
AimLifecycle_UpdatesDirectionThenHides=Passed duration=0.026356s
negativeRadius outer=0 inner=0 aimingAppliedStateCount=5
DemoInput_DrivesAimAndCanReactivateHiddenIndicator=Passed duration=0.003488s
pointerUp active=false
secondPointerDown active=true phase=Aiming

重复快照：AppliedStateCount 应保持 1
方向 90、夹角 60：StartAngle 应为 60