Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

alo

  1. User

    alo

  2. Assistant

    Hello! How can I assist you today?

  3. User

    using System; using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.UI; using Input; using Map.MapEditor.Action; using TMPro;

    namespace Map.MapEditor { public class MapEditorController : MonoBehaviour { private GameObject _selectedModel; private GameObject _modelToPlaceInstance; private GameObject _selectedModelInstance; private bool _isPlacingModel; private bool _isErasing; private bool _isDrawing;

        private Vector3? _lastPlacedPosition;
        private Layer _currentLayer = Layer.Background;
    
        public float gridSize = 3f;
        public Transform parent;
        public GridGenerator gridGenerator;
        public Button removeObjectButton;
        public Button brushObjectButton;
        public Button eraserObjectButton;
        public Button undoButton;
        public Button redoButton;
        public TMP_Dropdown dropdownLayer;
    
        public InputProvider inputProvider;
    
        private readonly Stack<IAction> _undoStack = new();
        private readonly Stack<IAction> _redoStack = new();
    
        private void Start()
        {
            removeObjectButton.onClick.AddListener(OnPressRemoveObject);
            brushObjectButton.onClick.AddListener(OnPressBrushObject);
            eraserObjectButton.onClick.AddListener(OnPressEraserObject);
            undoButton.onClick.AddListener(OnPressUndoButton);
            redoButton.onClick.AddListener(OnPressRedoButton);
    
            InitializeDropdownLayer();
            dropdownLayer.onValueChanged.AddListener(OnDropdownLayerChanged);
    
            inputProvider.Undo += OnPressUndoButton;
            inputProvider.Redo += OnPressRedoButton;
        }
    
        private void InitializeDropdownLayer()
        {
            dropdownLayer.ClearOptions();
            
            var options = (from Layer layer in Enum.GetValues(typeof(Layer)) select layer.ToString()).ToList();
    
            dropdownLayer.AddOptions(options);
            dropdownLayer.value = (int)_currentLayer;
        }
    
        private void OnDropdownLayerChanged(int index)
        {
            _currentLayer = (Layer)index;
        }
    
        private void OnPressRemoveObject()
        {
            DeleteSelectedModel();
        }
    
        private void OnPressBrushObject()
        {
            _isDrawing ^= true;
            _isErasing = false;
            CancelPlacement();
    
            SetButtonColor(brushObjectButton, _isDrawing ? Color.green : Color.white);
            SetButtonColor(eraserObjectButton, Color.white);
        }
    
        private void OnPressEraserObject()
        {
            _isErasing ^= true;
            _isDrawing = false;
            CancelPlacement();
    
            SetButtonColor(eraserObjectButton, _isErasing ? Color.red : Color.white);
            SetButtonColor(brushObjectButton, Color.white);
        }
    
        private void SetButtonColor(Button button, Color color)
        {
            var colors = button.colors;
            colors.normalColor = color;
            colors.highlightedColor = color;
            colors.pressedColor = color;
            colors.selectedColor = color;
            button.colors = colors;
        }
    
        private void Update()
        {
            if (_isDrawing && _modelToPlaceInstance != null)
            {
                MoveModelToMousePosition(_modelToPlaceInstance);
    
                if (inputProvider.IsActionButton)
                    PlaceModel();
            }
            else if (_isErasing && inputProvider.IsActionButton)
            {
                EraseModel();
            }
    
            if (!_isPlacingModel)
            {
                if (inputProvider.IsActionButton)
                    SelectModel();
    
                if (inputProvider.Delete)
                    DeleteSelectedModel();
            }
        }
    
        public void SetSelectedModel(GameObject model)
        {
            if (_isErasing || !_isDrawing) return;
    
            _selectedModel = model;
            StartPlacingModel();
        }
    
        private void StartPlacingModel()
        {
            if (_modelToPlaceInstance != null)
            {
                Destroy(_modelToPlaceInstance);
            }
    
            _modelToPlaceInstance = Instantiate(_selectedModel);
            _isPlacingModel = true;
            _lastPlacedPosition = null;
        }
    
        private void MoveModelToMousePosition(GameObject modelInstance)
        {
            var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
            Debug.DrawRay(ray.origin, ray.direction * 1000, Color.red);
    
            var plane = new Plane(Vector3.up, Vector3.zero);
            if (plane.Raycast(ray, out var hit))
            {
                var point = ray.GetPoint(hit);
                var gridPosition = GetNearestGridPosition(point);
                modelInstance.transform.position = gridPosition;
            }
        }
    
        private Vector3 GetNearestGridPosition(Vector3 hitPoint)
        {
            var x = Mathf.Round(hitPoint.x / gridSize) * gridSize;
            var y = Mathf.Round(hitPoint.y / gridSize) * gridSize;
            var z = Mathf.Round(hitPoint.z / gridSize) * gridSize;
    
            return new Vector3(x, y, z);
        }
    
        private void PlaceModel()
        {
            var gridPosition = GetNearestGridPosition(_modelToPlaceInstance.transform.position);
            var modelBounds = GetModelBounds(_modelToPlaceInstance);
    
            var adjustedPosition = new Vector3(gridPosition.x, gridPosition.y, gridPosition.z);
    
            if (IsPositionWithinGrid(adjustedPosition, modelBounds) &&
                !(_lastPlacedPosition.HasValue && _lastPlacedPosition.Value == adjustedPosition))
            {
                var placedModel = Instantiate(_selectedModel, adjustedPosition, _modelToPlaceInstance.transform.rotation,
                    parent);
                gridGenerator.SetObjectAtCell(adjustedPosition, placedModel, _currentLayer);
    
                AddAction(_selectedModel, adjustedPosition, placedModel);
    
                foreach (Transform child in placedModel.transform)
                {
                    child.gameObject.AddComponent<MeshCollider>();
                }
    
                _lastPlacedPosition = adjustedPosition;
            }
            else
            {
                Debug.LogWarning("Model placement is outside grid bounds or already placed at this position.");
            }
        }
        private Bounds GetModelBounds(GameObject model)
        {
            var rendererComponent = model.GetComponent<Renderer>();
            if (rendererComponent != null)
            {
                return rendererComponent.bounds;
            }
    
            var colliderComponent = model.GetComponent<Collider>();
            if (colliderComponent != null)
            {
                return colliderComponent.bounds;
            }
    
            return new Bounds(model.transform.position, Vector3.one * gridSize);
        }
    
        private bool IsPositionWithinGrid(Vector3 position, Bounds modelBounds)
        {
            var halfSize = modelBounds.size / 2;
            var min = gridGenerator.GridMin + halfSize;
            var max = gridGenerator.GridMax - halfSize;
    
            return position.x >= min.x && position.x <= max.x && position.z >= min.z && position.z <= max.z;
        }
    
        private void CancelPlacement()
        {
            _isPlacingModel = false;
            if (_modelToPlaceInstance != null)
            {
                Destroy(_modelToPlaceInstance);
                _modelToPlaceInstance = null;
            }
        }
    
        private void SelectModel()
        {
            var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
            if (Physics.Raycast(ray, out var hit))
            {
                if (_selectedModelInstance != null &&
                    _selectedModelInstance.TryGetComponent<Outline>(out var component))
                {
                    Destroy(component);
                }
    
                var selectedObject = hit.collider.gameObject;
                selectedObject.AddComponent<Outline>();
    
                _selectedModelInstance = selectedObject;
            }
        }
    
        private void DeleteSelectedModel()
        {
            if (_selectedModelInstance != null)
            {
                var position = _selectedModelInstance.transform.position;
                gridGenerator.RemoveObjectAtCell(position, _currentLayer);
    
                AddAction(_selectedModelInstance, position);
    
                Destroy(_selectedModelInstance);
                _selectedModelInstance = null;
            }
        }
    
        private void EraseModel()
        {
            var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
            if (Physics.Raycast(ray, out var hit))
            {
                var selectedObject = hit.collider.gameObject;
                var position = GetNearestGridPosition(selectedObject.transform.position);
                
                if (gridGenerator.RemoveObjectAtCell(position, _currentLayer))
                {
                    AddAction(selectedObject, position);
                    Destroy(selectedObject);
                }
            }
        }
        
        private void AddAction(GameObject model, Vector3 position, GameObject instance = null)
        {
            var action = new Action.Action(model, position, parent, _currentLayer, gridGenerator);
    
            if (instance is not null)
                action.SetInstance(instance);
    
            _undoStack.Push(action);
            _redoStack.Clear();
        }
    
        private void OnPressUndoButton()
        {
            if (_undoStack.Count <= 0) return;
    
            var action = _undoStack.Pop();
            action.Undo();
            _redoStack.Push(action);
        }
    
        private void OnPressRedoButton()
        {
            if (_redoStack.Count <= 0) return;
    
            var action = _redoStack.Pop();
            action.Redo();
            _undoStack.Push(action);
        }
    }
    

    }

    мне нужно сделать так, что елси у меня зажат шифт и я выделяю, то она выделяет несколько типо понял? и еще нужно чтобы когда я с зажатым шифтом выделял, и потом например с ним же тыкал по уже выделенным, они отменяли выделения но токк если шифт

  4. Assistant

    Для реализации функциональности множественного выделения с помощью клавиши Shift, нужно изменить логику выбора модели и добавления логики для отмены выбора при повторном клике с зажатым Shift. Вот, что вы можете сделать:

    1. Добавьте список для хранения выделенных объектов.
    2. Измените метод SelectModel для работы с множественным выделением.
    3. Добавьте проверку на зажатие клавиши Shift.

    Вот пример обновленного кода:

    // Список для хранения выделенных объектов
    private readonly List<GameObject> _selectedModels = new List<GameObject>();
    
    private void Update()
    {
        ...
        // Отметим, что если _isDrawing или _isErasing, множественное выделение не будет работать
        if (!_isPlacingModel && !(_isDrawing || _isErasing))
        {
            if (inputProvider.IsActionButton)
            {
                SelectModel(inputProvider.IsShiftPressed);
            }
    
            if (inputProvider.Delete)
            {
                DeleteSelectedModels();
            }
        }
        ...
    }
    
    private void SelectModel(bool isShiftPressed)
    {
        var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
        if (Physics.Raycast(ray, out var hit))
        {
            var selectedObject = hit.collider.gameObject;
    
            if (isShiftPressed)
            {
                // Снять выделение, если выделено и Shift зажат
                if (_selectedModels.Contains(selectedObject))
                {
                    _selectedModels.Remove(selectedObject);
                    if (selectedObject.TryGetComponent<Outline>(out var component))
                    {
                        Destroy(component);
                    }
                }
                // Добавить выделение
                else
                {
                    selectedObject.AddComponent<Outline>();
                    _selectedModels.Add(selectedObject);
                }
            }
            else
            {
                // Очистить предыдущие выделения
                ClearSelection();
    
                selectedObject.AddComponent<Outline>();
                _selectedModels.Add(selectedObject);
            }
        }
    }
    
    // Метод для снятия выделения со всех объектов
    private void ClearSelection()
    {
        foreach (var model in _selectedModels)
        {
            if (model.TryGetComponent<Outline>(out var component))
            {
                Destroy(component);
            }
        }
        _selectedModels.Clear();
    }
    
    // Метод для удаления всех выделенных объектов
    private void DeleteSelectedModels()
    {
        foreach (var model in _selectedModels)
        {
            var position = model.transform.position;
            gridGenerator.RemoveObjectAtCell(position, _currentLayer);
    
            AddAction(model, position);
    
            Destroy(model);
        }
        _selectedModels.Clear();
    }
    
    // Метод для добавления действий в стеки действий
    private void AddAction(GameObject model, Vector3 position, GameObject instance = null)
    {
        var action = new Action.Action(model, position, parent, _currentLayer, gridGenerator);
    
        if (instance is not null)
            action.SetInstance(instance);
    
        _undoStack.Push(action);
        _redoStack.Clear();
    }
    

    Теперь при зажатом Shift можно будет выделить несколько объектов и снять выделение, если объекты были выделены ранее.

    Обратите внимание, что обработка множественного выделения может потребовать дополнительного тестирования и доработки, чтобы учесть все возможные сценарии использования.

  5. User

    using System; using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.UI; using Input; using Map.MapEditor.Action; using TMPro;

    namespace Map.MapEditor { public class MapEditorController : MonoBehaviour { private GameObject _selectedModel; private GameObject _modelToPlaceInstance; private GameObject _selectedModelInstance; private bool _isPlacingModel; private bool _isErasing; private bool _isDrawing;

        private Vector3? _lastPlacedPosition;
        private Layer _currentLayer = Layer.Background;
    
        public float gridSize = 3f;
        public Transform parent;
        public GridGenerator gridGenerator;
        public Button removeObjectButton;
        public Button brushObjectButton;
        public Button eraserObjectButton;
        public Button undoButton;
        public Button redoButton;
        public TMP_Dropdown dropdownLayer;
    
        public InputProvider inputProvider;
    
        private readonly List<GameObject> _selectedModels = new();
        private readonly Stack<IAction> _undoStack = new();
        private readonly Stack<IAction> _redoStack = new();
    
        private void Start()
        {
            removeObjectButton.onClick.AddListener(OnPressRemoveObject);
            brushObjectButton.onClick.AddListener(OnPressBrushObject);
            eraserObjectButton.onClick.AddListener(OnPressEraserObject);
            undoButton.onClick.AddListener(OnPressUndoButton);
            redoButton.onClick.AddListener(OnPressRedoButton);
    
            InitializeDropdownLayer();
            dropdownLayer.onValueChanged.AddListener(OnDropdownLayerChanged);
    
            inputProvider.Undo += OnPressUndoButton;
            inputProvider.Redo += OnPressRedoButton;
        }
    
        private void InitializeDropdownLayer()
        {
            dropdownLayer.ClearOptions();
            
            var options = (from Layer layer in Enum.GetValues(typeof(Layer)) select layer.ToString()).ToList();
    
            dropdownLayer.AddOptions(options);
            dropdownLayer.value = (int)_currentLayer;
        }
    
        private void OnDropdownLayerChanged(int index)
        {
            _currentLayer = (Layer)index;
        }
    
        private void OnPressRemoveObject()
        {
            DeleteSelectedModels();
        }
    
        private void OnPressBrushObject()
        {
            _isDrawing ^= true;
            _isErasing = false;
            CancelPlacement();
    
            SetButtonColor(brushObjectButton, _isDrawing ? Color.green : Color.white);
            SetButtonColor(eraserObjectButton, Color.white);
        }
    
        private void OnPressEraserObject()
        {
            _isErasing ^= true;
            _isDrawing = false;
            CancelPlacement();
    
            SetButtonColor(eraserObjectButton, _isErasing ? Color.red : Color.white);
            SetButtonColor(brushObjectButton, Color.white);
        }
    
        private void SetButtonColor(Button button, Color color)
        {
            var colors = button.colors;
            colors.normalColor = color;
            colors.highlightedColor = color;
            colors.pressedColor = color;
            colors.selectedColor = color;
            button.colors = colors;
        }
    
        private void Update()
        {
            if (_isDrawing && _modelToPlaceInstance != null)
            {
                MoveModelToMousePosition(_modelToPlaceInstance);
    
                if (inputProvider.IsActionButton)
                    PlaceModel();
            }
            else if (_isErasing && inputProvider.IsActionButton)
            {
                EraseModel();
            }
    
            if (!_isPlacingModel && !(_isDrawing || _isErasing))
            {
                if (inputProvider.IsActionButton)
                {
                    SelectModel(inputProvider.IsShiftPressed);
                }
    
                if (inputProvider.Delete)
                {
                    DeleteSelectedModels();
                }
            }
        }
    
        public void SetSelectedModel(GameObject model)
        {
            if (_isErasing || !_isDrawing) return;
    
            _selectedModel = model;
            StartPlacingModel();
        }
    
        private void StartPlacingModel()
        {
            if (_modelToPlaceInstance != null)
            {
                Destroy(_modelToPlaceInstance);
            }
    
            _modelToPlaceInstance = Instantiate(_selectedModel);
            _isPlacingModel = true;
            _lastPlacedPosition = null;
        }
    
        private void MoveModelToMousePosition(GameObject modelInstance)
        {
            var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
            Debug.DrawRay(ray.origin, ray.direction * 1000, Color.red);
    
            var plane = new Plane(Vector3.up, Vector3.zero);
            if (plane.Raycast(ray, out var hit))
            {
                var point = ray.GetPoint(hit);
                var gridPosition = GetNearestGridPosition(point);
                modelInstance.transform.position = gridPosition;
            }
        }
    
        private Vector3 GetNearestGridPosition(Vector3 hitPoint)
        {
            var x = Mathf.Round(hitPoint.x / gridSize) * gridSize;
            var y = Mathf.Round(hitPoint.y / gridSize) * gridSize;
            var z = Mathf.Round(hitPoint.z / gridSize) * gridSize;
    
            return new Vector3(x, y, z);
        }
    
        private void PlaceModel()
        {
            var gridPosition = GetNearestGridPosition(_modelToPlaceInstance.transform.position);
            var modelBounds = GetModelBounds(_modelToPlaceInstance);
    
            var adjustedPosition = new Vector3(gridPosition.x, gridPosition.y, gridPosition.z);
    
            if (IsPositionWithinGrid(adjustedPosition, modelBounds) &&
                !(_lastPlacedPosition.HasValue && _lastPlacedPosition.Value == adjustedPosition))
            {
                var placedModel = Instantiate(_selectedModel, adjustedPosition, _modelToPlaceInstance.transform.rotation,
                    parent);
                gridGenerator.SetObjectAtCell(adjustedPosition, placedModel, _currentLayer);
    
                AddAction(_selectedModel, adjustedPosition, placedModel);
    
                foreach (Transform child in placedModel.transform)
                {
                    child.gameObject.AddComponent<MeshCollider>();
                }
    
                _lastPlacedPosition = adjustedPosition;
            }
            else
            {
                Debug.LogWarning("Model placement is outside grid bounds or already placed at this position.");
            }
        }
        private Bounds GetModelBounds(GameObject model)
        {
            var rendererComponent = model.GetComponent<Renderer>();
            if (rendererComponent != null)
            {
                return rendererComponent.bounds;
            }
    
            var colliderComponent = model.GetComponent<Collider>();
            if (colliderComponent != null)
            {
                return colliderComponent.bounds;
            }
    
            return new Bounds(model.transform.position, Vector3.one * gridSize);
        }
    
        private bool IsPositionWithinGrid(Vector3 position, Bounds modelBounds)
        {
            var halfSize = modelBounds.size / 2;
            var min = gridGenerator.GridMin + halfSize;
            var max = gridGenerator.GridMax - halfSize;
    
            return position.x >= min.x && position.x <= max.x && position.z >= min.z && position.z <= max.z;
        }
    
        private void CancelPlacement()
        {
            _isPlacingModel = false;
            if (_modelToPlaceInstance != null)
            {
                Destroy(_modelToPlaceInstance);
                _modelToPlaceInstance = null;
            }
        }
    
        private void SelectModel(bool isShiftPressed)
        {
            var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
            if (Physics.Raycast(ray, out var hit))
            {
                var selectedObject = hit.collider.gameObject;
    
                if (isShiftPressed)
                {
                    if (_selectedModels.Contains(selectedObject))
                    {
                        _selectedModels.Remove(selectedObject);
                        if (selectedObject.TryGetComponent<Outline>(out var component))
                        {
                            Destroy(component);
                        }
                    }
                    else
                    {
                        selectedObject.AddComponent<Outline>();
                        _selectedModels.Add(selectedObject);
                    }
                }
                else
                {
                    ClearSelection();
    
                    selectedObject.AddComponent<Outline>();
                    _selectedModels.Add(selectedObject);
                }
            }
        }
        
        private void ClearSelection()
        {
            foreach (var model in _selectedModels)
            {
                if (model.TryGetComponent<Outline>(out var component))
                {
                    Destroy(component);
                }
            }
            _selectedModels.Clear();
        }
    
        private void DeleteSelectedModels()
        {
            foreach (var model in _selectedModels)
            {
                var position = model.transform.position;
                gridGenerator.RemoveObjectAtCell(position, _currentLayer);
    
                AddAction(model, position);
    
                Destroy(model);
            }
            _selectedModels.Clear();
        }
        
    
        private void EraseModel()
        {
            var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
            if (Physics.Raycast(ray, out var hit))
            {
                var selectedObject = hit.collider.gameObject;
                var position = GetNearestGridPosition(selectedObject.transform.position);
                
                if (gridGenerator.RemoveObjectAtCell(position, _currentLayer))
                {
                    AddAction(selectedObject, position);
                    Destroy(selectedObject);
                }
            }
        }
        
        private void AddAction(GameObject model, Vector3 position, GameObject instance = null)
        {
            var action = new Action.Action(model, position, parent, _currentLayer, gridGenerator);
    
            if (instance is not null)
                action.SetInstance(instance);
    
            _undoStack.Push(action);
            _redoStack.Clear();
        }
    
        private void OnPressUndoButton()
        {
            if (_undoStack.Count <= 0) return;
    
            var action = _undoStack.Pop();
            action.Undo();
            _redoStack.Push(action);
        }
    
        private void OnPressRedoButton()
        {
            if (_redoStack.Count <= 0) return;
    
            var action = _redoStack.Pop();
            action.Redo();
            _undoStack.Push(action);
        }
    }
    

    }

    есть проблема, если я нажимаю оно срабатывает много раз, и он выделяет и сразу же убирает

  6. Assistant

    Проблема, с которой вы столкнулись, скорее всего вызвана тем, что IsActionButton возвращает true при каждом кадре, когда кнопка нажата. Это означает, что код в SelectModel выполняется многократно в течение одного нажатия, что приводит к многократному выделению и снятию выделения.

    Для решения этой проблемы можно отслеживать, когда кнопка была нажата и когда была отпущена, чтобы выполнять действие только один раз на нажатие. Это можно сделать, например, с использованием флагов состояния кнопок.

    Давайте внесем соответствующие изменения в код:

    1. Добавим переменные для отслеживания состояния кнопок.
    2. Изменим логику в методе Update.

    Вот обновленный код:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.UI;
    using Input;
    using Map.MapEditor.Action;
    using TMPro;
    
    namespace Map.MapEditor
    {
        public class MapEditorController : MonoBehaviour
        {
            private GameObject _selectedModel;
            private GameObject _modelToPlaceInstance;
            private GameObject _selectedModelInstance;
            private bool _isPlacingModel;
            private bool _isErasing;
            private bool _isDrawing;
    
            private Vector3? _lastPlacedPosition;
            private Layer _currentLayer = Layer.Background;
    
            public float gridSize = 3f;
            public Transform parent;
            public GridGenerator gridGenerator;
            public Button removeObjectButton;
            public Button brushObjectButton;
            public Button eraserObjectButton;
            public Button undoButton;
            public Button redoButton;
            public TMP_Dropdown dropdownLayer;
    
            public InputProvider inputProvider;
    
            private readonly List<GameObject> _selectedModels = new();
            private readonly Stack<IAction> _undoStack = new();
            private readonly Stack<IAction> _redoStack = new();
    
            private bool _wasActionButtonPressed = false;  // Добавленная переменная
            private bool _wasDeleteKeyPressed = false;     // Добавленная переменная
    
            private void Start()
            {
                removeObjectButton.onClick.AddListener(OnPressRemoveObject);
                brushObjectButton.onClick.AddListener(OnPressBrushObject);
                eraserObjectButton.onClick.AddListener(OnPressEraserObject);
                undoButton.onClick.AddListener(OnPressUndoButton);
                redoButton.onClick.AddListener(OnPressRedoButton);
    
                InitializeDropdownLayer();
                dropdownLayer.onValueChanged.AddListener(OnDropdownLayerChanged);
    
                inputProvider.Undo += OnPressUndoButton;
                inputProvider.Redo += OnPressRedoButton;
            }
    
            private void InitializeDropdownLayer()
            {
                dropdownLayer.ClearOptions();
                
                var options = (from Layer layer in Enum.GetValues(typeof(Layer)) select layer.ToString()).ToList();
                dropdownLayer.AddOptions(options);
                dropdownLayer.value = (int)_currentLayer;
            }
    
            private void OnDropdownLayerChanged(int index)
            {
                _currentLayer = (Layer)index;
            }
    
            private void OnPressRemoveObject()
            {
                DeleteSelectedModels();
            }
    
            private void OnPressBrushObject()
            {
                _isDrawing ^= true;
                _isErasing = false;
                CancelPlacement();
    
                SetButtonColor(brushObjectButton, _isDrawing ? Color.green : Color.white);
                SetButtonColor(eraserObjectButton, Color.white);
            }
    
            private void OnPressEraserObject()
            {
                _isErasing ^= true;
                _isDrawing = false;
                CancelPlacement();
    
                SetButtonColor(eraserObjectButton, _isErasing ? Color.red : Color.white);
                SetButtonColor(brushObjectButton, Color.white);
            }
    
            private void SetButtonColor(Button button, Color color)
            {
                var colors = button.colors;
                colors.normalColor = color;
                colors.highlightedColor = color;
                colors.pressedColor = color;
                colors.selectedColor = color;
                button.colors = colors;
            }
    
            private void Update()
            {
                // Проверка нажатия для рисования и стирания
                if (_isDrawing && _modelToPlaceInstance != null)
                {
                    MoveModelToMousePosition(_modelToPlaceInstance);
    
                    if (inputProvider.IsActionButton)
                        PlaceModel();
                }
                else if (_isErasing && inputProvider.IsActionButton)
                {
                    EraseModel();
                }
    
                // Проверка состояния кнопок для выбора и удаления
                bool isActionButtonPressed = inputProvider.IsActionButton;
                bool isDeleteKeyPressed = inputProvider.Delete;
    
                if (!_wasActionButtonPressed && isActionButtonPressed)
                {
                    if (!_isPlacingModel && !(_isDrawing || _isErasing))
                    {
                        SelectModel(inputProvider.IsShiftPressed);
                    }
                }
    
                if (!_wasDeleteKeyPressed && isDeleteKeyPressed)
                {
                    if (!_isPlacingModel && !(_isDrawing || _isErasing))
                    {
                        DeleteSelectedModels();
                    }
                }
    
                // Обновление состояний кнопок
                _wasActionButtonPressed = isActionButtonPressed;
                _wasDeleteKeyPressed = isDeleteKeyPressed;
            }
    
            public void SetSelectedModel(GameObject model)
            {
                if (_isErasing || !_isDrawing) return;
    
                _selectedModel = model;
                StartPlacingModel();
            }
    
            private void StartPlacingModel()
            {
                if (_modelToPlaceInstance != null)
                {
                    Destroy(_modelToPlaceInstance);
                }
    
                _modelToPlaceInstance = Instantiate(_selectedModel);
                _isPlacingModel = true;
                _lastPlacedPosition = null;
            }
    
            private void MoveModelToMousePosition(GameObject modelInstance)
            {
                var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
                Debug.DrawRay(ray.origin, ray.direction * 1000, Color.red);
    
                var plane = new Plane(Vector3.up, Vector3.zero);
                if (plane.Raycast(ray, out var hit))
                {
                    var point = ray.GetPoint(hit);
                    var gridPosition = GetNearestGridPosition(point);
                    modelInstance.transform.position = gridPosition;
                }
            }
    
            private Vector3 GetNearestGridPosition(Vector3 hitPoint)
            {
                var x = Mathf.Round(hitPoint.x / gridSize) * gridSize;
                var y = Mathf.Round(hitPoint.y / gridSize) * gridSize;
                var z = Mathf.Round(hitPoint.z / gridSize) * gridSize;
    
                return new Vector3(x, y, z);
            }
    
            private void PlaceModel()
            {
                var gridPosition = GetNearestGridPosition(_modelToPlaceInstance.transform.position);
                var modelBounds = GetModelBounds(_modelToPlaceInstance);
                var adjustedPosition = new Vector3(gridPosition.x, gridPosition.y, gridPosition.z);
    
                if (IsPositionWithinGrid(adjustedPosition, modelBounds) &&
                    !(_lastPlacedPosition.HasValue && _lastPlacedPosition.Value == adjustedPosition))
                {
                    var placedModel = Instantiate(_selectedModel, adjustedPosition, _modelToPlaceInstance.transform.rotation, parent);
                    gridGenerator.SetObjectAtCell(adjustedPosition, placedModel, _currentLayer);
    
                    AddAction(_selectedModel, adjustedPosition, placedModel);
    
                    foreach (Transform child in placedModel.transform)
                    {
                        child.gameObject.AddComponent<MeshCollider>();
                    }
    
                    _lastPlacedPosition = adjustedPosition;
                }
                else
                {
                    Debug.LogWarning("Model placement is outside grid bounds or already placed at this position.");
                }
            }
    
            private Bounds GetModelBounds(GameObject model)
            {
                var rendererComponent = model.GetComponent<Renderer>();
                if (rendererComponent != null)
                {
                    return rendererComponent.bounds;
                }
    
                var colliderComponent = model.GetComponent<Collider>();
                if (colliderComponent != null)
                {
                    return colliderComponent.bounds;
                }
    
                return new Bounds(model.transform.position, Vector3.one * gridSize);
            }
    
            private bool IsPositionWithinGrid(Vector3 position, Bounds modelBounds)
            {
                var halfSize = modelBounds.size / 2;
                var min = gridGenerator.GridMin + halfSize;
                var max = gridGenerator.GridMax - halfSize;
    
                return position.x >= min.x && position.x <= max.x && position.z >= min.z && position.z <= max.z;
            }
    
            private void CancelPlacement()
            {
                _isPlacingModel = false;
                if (_modelToPlaceInstance != null)
                {
                    Destroy(_modelToPlaceInstance);
                    _modelToPlaceInstance = null;
                }
            }
    
            private void SelectModel(bool isShiftPressed)
            {
                var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
                if (Physics.Raycast(ray, out var hit))
                {
                    var selectedObject = hit.collider.gameObject;
    
                    if (isShiftPressed)
                    {
                        if (_selectedModels.Contains(selectedObject))
                        {
                            _selectedModels.Remove(selectedObject);
                            if (selectedObject.TryGetComponent<Outline>(out var component))
                            {
                                Destroy(component);
                            }
                        }
                        else
                        {
                            selectedObject.AddComponent<Outline>();
                            _selectedModels.Add(selectedObject);
                        }
                    }
                    else
                    {
                        ClearSelection();
    
                        selectedObject.AddComponent<Outline>();
                        _selectedModels.Add(selectedObject);
                    }
                }
            }
            
            private void ClearSelection()
            {
                foreach (var model in _selectedModels)
                {
                    if (model.TryGetComponent<Outline>(out var component))
                    {
                        Destroy(component);
                    }
                }
                _selectedModels.Clear();
            }
    
            private void DeleteSelectedModels()
            {
                foreach (var model in _selectedModels)
                {
                    var position = model.transform.position;
                    gridGenerator.RemoveObjectAtCell(position, _currentLayer);
    
                    AddAction(model, position);
    
                    Destroy(model);
                }
                _selectedModels.Clear();
            }
    
            private void EraseModel()
            {
                var ray = Camera.main!.ScreenPointToRay(inputProvider.PlacePosition);
                if (Physics.Raycast(ray, out var hit))
                {
                    var selectedObject = hit.collider.gameObject;
                    var position = GetNearestGridPosition(selectedObject.transform.position);
                    
                    if (gridGenerator.RemoveObjectAtCell(position, _currentLayer))
                    {
                        AddAction(selectedObject, position);
                        Destroy(selectedObject);
                    }
                }
            }
            
            private void AddAction(GameObject model, Vector3 position, GameObject instance = null)
            {
                var action = new Action.Action(model, position, parent, _currentLayer, gridGenerator);
    
                if (instance is not null)
                    action.SetInstance(instance);
    
                _undoStack.Push(action);
                _redoStack.Clear();
            }
    
            private void OnPressUndoButton()
            {
                if (_undoStack.Count <= 0) return;
    
                var action = _undoStack.Pop();
                action.Undo();
                _redoStack.Push(action);
            }
    
            private void OnPressRedoButton()
            {
                if (_redoStack.Count <= 0) return;
    
                var action = _redoStack.Pop();
                action.Redo();
                _undoStack.Push(action);
            }
        }
    }
    

    Теперь логика SelectModel будет срабатывать только один раз при нажатии кнопки. Аналогично, метод удаления будет выполняться только один раз при нажатии клавиши удаления.

  7. User

    как назвать коммит где вот это добавлено?

  8. Assistant

    Для названия коммита важно придерживаться краткости и конкретики, чтобы было легко понять, какие изменения внесены. В вашем случае, добавлены улучшения для множественного выделения с помощью Shift и предотвращено многократное выполнение при одном нажатии кнопки.

    Предлагаемое название коммита может быть следующим:

    feat: add multi-selection with Shift and debounce action
    

    Объяснение:

    • feat: Тип коммита, указывающий на добавление новой функции (feature).
    • add multi-selection with Shift: Описание основной добавленной функциональности.
    • debounce action: Краткое упоминание о решении проблемы многократного выполнения действий при одном нажатии.

    Такое название коммита поможет вам (и вашей команде) быстро понять, что было сделано, просто прочитав запись в истории коммитов.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.