Assets/Scripts/RoomBuilding/UIPolygonPreviewView.cs - master - GeekNerd/ServerModelingProject

Assets/Scripts/RoomBuilding/UIPolygonPreviewView.cs
207 строк6 KB
Gorney-Alex
Init
30 май 2026, 19:05
30 май 2026, 19:053cdcc49
using System.Collections.Generic;
using DataClasses;
using Interfaces;
using UnityEngine;
using Zenject;

namespace RoomBuilding
{
    public class UIPolygonPreviewView : MonoBehaviour, IInitializable
    {
        [Header("Container")]
        [SerializeField] private RectTransform linesContainer;

        [Header("Door rect")]
        [SerializeField] private float pixelsPerGridStep = 20f;
        
        private ICustomFactory _factory;
        private PolygonDrawingService _drawingService;
        private RoomBuildingSettings _settings;

        private readonly List<ILineView> _edgeLines = new();
        private readonly List<IDoorView> _doorRects = new();
        private readonly List<ICracView> _cracCircles = new();
        private ILineView _previewLine;

        private float _pixelsPerMeter;

        [Inject]
        public void Construct(ICustomFactory factory, PolygonDrawingService drawingService, RoomBuildingSettings settings)
        {
            _factory = factory;
            _drawingService = drawingService;
            _settings = settings;
        }

        public void Initialize()
        {
            if (_settings == null || _settings.DotSpacing <= 0f)
            {
                Debug.LogError("[UIPolygonPreviewView] Invalid settings.");
                return;
            }

            _pixelsPerMeter = pixelsPerGridStep / _settings.DotSpacing;

            _drawingService.OnVerticesChanged += Refresh;
            _drawingService.OnDoorsChanged += Refresh;
            _drawingService.OnCracsChanged += Refresh;
        }

        private void OnDestroy()
        {
            if (_drawingService == null) return;
            _drawingService.OnVerticesChanged -= Refresh;
            _drawingService.OnDoorsChanged -= Refresh;
            _drawingService.OnCracsChanged -= Refresh;
        }

        private void Refresh()
        {
            var root = linesContainer != null ? linesContainer : transform as RectTransform;
            if (root == null) return;

            var verts = _drawingService.Vertices;
            bool closed = _drawingService.State == DrawingState.Closed;
            
            int edgeCount = verts.Count < 2 ? 0 : closed ? verts.Count : verts.Count - 1;

            for (int i = 0; i < edgeCount; i++)
            {
                Vector2 a = WorldToUI(verts[i]);
                Vector2 b = WorldToUI(verts[(i + 1) % verts.Count]);
                ILineView line = GetOrCreateLine(root, _edgeLines, i);
                line.SetPositions(a, b);
                line.SetActive(true);
            }
            
            SetActive(_edgeLines, edgeCount);

            bool showPreview = _drawingService.State == DrawingState.Drawing
                            && verts.Count >= 1
                            && _drawingService.PreviewCursorWorld.HasValue;

            if (showPreview)
            {
                Vector2 from = WorldToUI(verts[verts.Count - 1]);
                Vector2 to = WorldToUI(_drawingService.PreviewCursorWorld.Value);

                if (_previewLine == null)
                {
                    _previewLine = _factory.CreateLine(root);
                }

                _previewLine.SetPositions(from, to);
                _previewLine.SetActive(true);
            }
            else
            {
                if (_previewLine != null) _previewLine.SetActive(false);
            }

            var doors = _drawingService.Doors;

            for (int d = 0; d < doors.Count; d++)
            {
                var door = doors[d];

                int ei = door.EdgeIndex;
                if (ei < 0 || ei >= verts.Count)
                    continue;

                Vector2 a = verts[ei];
                Vector2 b = verts[(ei + 1) % verts.Count];

                Vector2 dir = (b - a).normalized;

                Vector2 start = a + dir * door.OffsetAlongEdge;
                Vector2 end = start + dir * door.Width;

                Vector2 uiA = WorldToUI(start);
                Vector2 uiB = WorldToUI(end);

                IDoorView doorView = GetOrCreateDoor(root, _doorRects, d, door);

                doorView.SetPositions(uiA, uiB);
                doorView.SetActive(true);
            }

            SetActive(_doorRects, doors.Count);

            var cracs = _drawingService.Cracs;
            for (int c = 0; c < cracs.Count; c++)
            {
                var crac = cracs[c];
                var cracView = GetOrCreateCrac(root, _cracCircles, c);
                cracView.SetPosition(WorldToUI(crac.Center));
                cracView.SetRadius(crac.Radius * _pixelsPerMeter);
                cracView.SetColor(crac.Color);
                cracView.SetActive(true);
            }

            SetActive(_cracCircles, cracs.Count);
        }

        private ILineView GetOrCreateLine(RectTransform root, List<ILineView> pool, int index)
        {
            while (pool.Count <= index)
            {
                ILineView line = _factory.CreateLine(root);
                line.UpdateName($"Line_{pool.Count}");
                pool.Add(line);
            }

            return pool[index];
        }
        
        private IDoorView GetOrCreateDoor(RectTransform root, List<IDoorView> pool, int index, DoorData data)
        {
            while (pool.Count <= index)
            {
                IDoorView door = _factory.CreateDoor(root);
                pool.Add(door);
            }

            IDoorView doorObject = pool[index];
            doorObject.SetColor(data.Color);

            return doorObject;
        }

        private ICracView GetOrCreateCrac(RectTransform root, List<ICracView> pool, int index)
        {
            while (pool.Count <= index)
            {
                pool.Add(_factory.CreateCrac(root));
            }

            return pool[index];
        }

        private static void SetActive(List<ILineView> pool, int activeCount)
        {
            for (int i = 0; i < pool.Count; i++)
            {
                pool[i].SetActive(i < activeCount);
            }
        }
        
        private static void SetActive(List<IDoorView> pool, int activeCount)
        {
            for (int i = 0; i < pool.Count; i++)
            {
                pool[i].SetActive(i < activeCount);
            }
        }

        private static void SetActive(List<ICracView> pool, int activeCount)
        {
            for (int i = 0; i < pool.Count; i++)
            {
                pool[i].SetActive(i < activeCount);
            }
        }

        private Vector2 WorldToUI(Vector2 world) => world * _pixelsPerMeter;
    }
}