K0TlK

public class Weapon : MonoBehaviour
{
    public void Hide()
    {
        gameObject.SetActive(false);
    }
}

public class PlayerInput : MonoBehaviour
{
    public event Action InteractionButtonPressed = delegate {  };

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.E))
        {
            InteractionButtonPressed();
        }
    }
}

public class PickUpArea : MonoBehaviour
{
    private readonly List<Weapon> _closeWeapons = new();

    public bool HasItemsAround => _closeWeapons.Count > 0;
        
    public void PickUp(PlayableCharacter character)
    {
        var closestWeapon = GetClosestWeapon();
        _closeWeapons.Remove(closestWeapon);
        character.Give(closestWeapon);
    }

    private Weapon GetClosestWeapon()
    {
        Weapon closest = null;
        var minDistance = float.MaxValue;

        foreach (var weapon in _closeWeapons)
        {
            var distance = (transform.position - weapon.transform.position).sqrMagnitude;
                
            if (distance < minDistance)
            {
                closest = weapon;
                minDistance = distance;
            }
        }
            
        return closest;
    }

    private void OnTriggerEnter2D(Collider2D col)
    {
        if (col.TryGetComponent(out Weapon weapon))
        {
            _closeWeapons.Add(weapon);
        }
    }

    private void OnTriggerExit2D(Collider2D other)
    {
        if (other.TryGetComponent(out Weapon weapon))
        {
            _closeWeapons.Remove(weapon);
        }
    }
}

public class PlayableCharacter : MonoBehaviour
{
    [SerializeField] private PlayerInput _input;
    [SerializeField] private PickUpArea _pickUpArea;
    [SerializeField] private List<Weapon> _weapons = new();

    private void Start()
    {
        _input.InteractionButtonPressed += TryPickUp;
    }

    private void OnDestroy()
    {
        _input.InteractionButtonPressed -= TryPickUp;
    }

    public void Give(Weapon weapon)
    {
        weapon.Hide();
        _weapons.Add(weapon);
    }

    private void TryPickUp()
    {
        if (_pickUpArea.HasItemsAround)
        {
            _pickUpArea.PickUp(this);
        }
    }
}

private void CreateDirectory()
        {
            if (Directory.Exists(_directoryPath) == false)
            {
                Directory.CreateDirectory(_directoryPath);
            }
        }

private void CreateFile()
        {
            if (File.Exists(_path)) return;
            
            var json = JsonUtility.ToJson(CompleteStatus.Locked);
                
            using (var writer = File.CreateText(_path))
            {
                writer.Write(json);
                writer.Close();
            }
        }

namespace Levels
{
    public interface ILevel : IVisualization<ILevelView>
    {
        void Load();
        void Complete(CompleteStatus status);
    }
}

namespace Levels
{
    public interface IVisualization<in TView>
    {
        void Visualize(TView view);
    }
}

namespace Levels
{
    public enum CompleteStatus
    {
        Locked,
        Uncompleted,
        OneStar,
        TwoStars,
        ThreeStars
    }
    public interface ILevelView
    {
        void DrawCompletion(CompleteStatus status);
    }
}

using System.IO;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Levels
{
    public abstract class Level : ILevel
    {
        private readonly string _name;

        private readonly string _path;

        private readonly string _directoryPath = $"{Application.persistentDataPath}/Saves";

        protected Level(string name)
        {
            _name = name;
            _path = $"{_directoryPath}/{_name}.json";
            CreateDirectory();
            CreateFile();
        }

        public void Load()
        {
            SceneManager.LoadScene(_name);
        }

        public void Complete(CompleteStatus status)
        {
            SaveStatus(status);
        }

        public void Visualize(ILevelView view)
        {
            view.DrawCompletion(LoadStatusFromJson());
        }

        private void CreateDirectory()
        {
            if (Directory.Exists(_directoryPath) == false)
            {
                Directory.CreateDirectory(_directoryPath);
            }
        }

        private void CreateFile()
        {
            if (File.Exists(_path)) return;
            
            var json = JsonUtility.ToJson(CompleteStatus.Locked);
                
            using (var writer = File.CreateText(_path))
            {
                writer.Write(json);
                writer.Close();
            }
        }
        
        private void SaveStatus(CompleteStatus status)
        {
            var json = JsonUtility.ToJson(status);
            File.WriteAllText(_path, json);
        }
        
        private CompleteStatus LoadStatusFromJson()
        {
            var file = File.ReadAllText(_path);
            return JsonUtility.FromJson<CompleteStatus>(file);
        }
        
    }
}

namespace Levels
{
    public class SecondLevel : Level
    {
        public SecondLevel() : base(nameof(SecondLevel))
        {
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.UI;

namespace Levels
{
    public class LevelView : MonoBehaviour, ILevelView
    {
        [SerializeField] private Image _firstStar, _secondStar, _thirdStar;
        [SerializeField] private Button _button;
        [SerializeField] private Color _inactiveStarColor, _activeStarColor;
        
        public void DrawCompletion(CompleteStatus status)
        {
            switch (status)
            {
                case CompleteStatus.Locked:
                    _firstStar.color = _inactiveStarColor;
                    _secondStar.color = _inactiveStarColor;
                    _thirdStar.color = _inactiveStarColor;
                    _button.interactable = false;
                    break;
                case CompleteStatus.Uncompleted:
                    _button.interactable = true;
                    _firstStar.color = _inactiveStarColor;
                    _secondStar.color = _inactiveStarColor;
                    _thirdStar.color = _inactiveStarColor;
                    break;
                case CompleteStatus.OneStar:
                    _button.interactable = true;
                    _firstStar.color = _activeStarColor;
                    _secondStar.color = _inactiveStarColor;
                    _thirdStar.color = _inactiveStarColor;
                    break;
                case CompleteStatus.TwoStars:
                    _button.interactable = true;
                    _firstStar.color = _activeStarColor;
                    _secondStar.color = _activeStarColor;
                    _thirdStar.color = _inactiveStarColor;
                    break;
                case CompleteStatus.ThreeStars:
                    _button.interactable = true;
                    _firstStar.color = _activeStarColor;
                    _secondStar.color = _activeStarColor;
                    _thirdStar.color = _activeStarColor;
                    break;
                default: throw new ArgumentException();
            }
        }
    }
}

using System.Collections.Generic;
using UnityEngine;

namespace Levels
{
    public class LevelList : MonoBehaviour
    {
        [SerializeField] private LevelView _levelViewPrefab;
        [SerializeField] private Transform _levelsParent;

        private ILevel[] _levels;
        
        private void Awake()
        {
            var first = new FirstLevel();
            var second = new SecondLevel();
            var third = new ThirdLevel();
            var fourth = new FourthLevel();
            var fifth = new FifthLevel();
            
            _levels = new ILevel[]
            {
                first, second, third, fourth, fifth
            };

            //test
            first.Complete(CompleteStatus.OneStar);
            second.Complete(CompleteStatus.TwoStars);
            third.Complete(CompleteStatus.ThreeStars);
            fourth.Complete(CompleteStatus.Uncompleted);
            fifth.Complete(CompleteStatus.Locked);

            VisualizeLevels(_levels);
        }

        private void VisualizeLevels(IEnumerable<ILevel> levels)
        {
            foreach (var level in levels)
            {
                var view = Instantiate(_levelViewPrefab, _levelsParent);
                level.Visualize(view);
            }
        }
    }
}

namespace Coroutines
{
    public interface IHealth
    {
        bool IsOver { get; }
        void Lose(float amount);
        void Restore(float amount);
    }
}

using System;
using UnityEngine;

namespace Coroutines
{
    public class Health : IHealth
    {
        private readonly float _max;
        private readonly float _min;
        private float _current;

        public Health(float max, float min = 0)
        {
            _max = max;
            _min = min;
            _current = _max;
        }

        public bool IsOver => _current <= _min;
        
        public void Lose(float amount)
        {
            if (amount <= 0) throw new ArgumentException();
            
            SetCurrent(_current - amount);
        }

        public void Restore(float amount)
        {
            if (amount <= 0) throw new ArgumentException();

            SetCurrent(_current + amount);
        }

        private void SetCurrent(float amount)
        {
            _current = Mathf.Clamp(amount, _min, _max);
        }
    }
}

namespace Coroutines
{
    public interface IDamageable
    {
        bool IsDead { get; }
        void ApplyDamage(float amount);
    }
}

using UnityEngine;

namespace Coroutines
{
    public class Character : MonoBehaviour, IDamageable
    {
        [SerializeField] private float _maxHp = 100f;

        private IHealth _health;

        public bool IsDead => _health.IsOver;

        private void Awake()
        {
            _health = new Health(_maxHp);
        }

        public void ApplyDamage(float amount) => _health.Lose(amount);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace Coroutines
{
    public class Trap : MonoBehaviour
    {
        [SerializeField] private float _damage = 10f;
        [SerializeField] private float _delay = 2f;
        
        private readonly Dictionary<IDamageable, Coroutine> _targets = new();

        private void OnTriggerEnter2D(Collider2D other)
        {
            if (other.TryGetComponent(out IDamageable damageable))
            {
                var coroutine = StartCoroutine(Damaging(damageable));
                _targets.Add(damageable, coroutine);
            }
        }

        private void OnTriggerExit2D(Collider2D other)
        {
            if (other.TryGetComponent(out IDamageable damageable))
            {
                var coroutine = _targets[damageable];
                StopCoroutine(coroutine);
                _targets.Remove(damageable);
            }
        }

        private IEnumerator Damaging(IDamageable target)
        {
            while (target.IsDead == false)
            {
                target.ApplyDamage(_damage);
                yield return new WaitForSeconds(_delay);
            }
        }

    }
}

using UnityEngine;

namespace Bullets
{
    [RequireComponent(typeof(Rigidbody2D), typeof(Collider2D))]
    public class Bullet : MonoBehaviour, IBullet
    {
        [SerializeField] private float _speed = 5f;
        [SerializeField] private int _damage = 10;
        [SerializeField] private int _maxReflections = 5;

        private Rigidbody2D _rigidbody;
        private Vector2 _direction = Vector2.zero;

        private void Awake()
        {
            _rigidbody = GetComponent<Rigidbody2D>();
            _rigidbody.isKinematic = true;
            _rigidbody.useFullKinematicContacts = true;
        }
        
        public void Shoot(Vector2 direction)
        {
            _direction = direction.normalized;
        }

        private void FixedUpdate()
        {
            if (_direction == Vector2.zero) return;

            var deltaMovement = _direction * _speed * Time.deltaTime;

            _rigidbody.MovePosition(_rigidbody.position + deltaMovement);
        }

        private void OnCollisionEnter2D(Collision2D other)
        {
            if (other.transform.TryGetComponent(out IDamageable damageable))
            {
                damageable.ApplyDamage(_damage);
                Destroy();
                return;
            }

            var normal = other.GetContact(0).normal;
            Reflect(normal);
        }

        private void Destroy()
        {
            Destroy(gameObject);
        }

        private void Reflect(Vector2 normal)
        {
            if (_maxReflections - 1 == 0) Destroy();

            _maxReflections--;
            _direction = Vector2.Reflect(_direction, normal).normalized;
        }
    }
}

using UnityEngine;

namespace Bullets
{
    public class SomeGun : MonoBehaviour
    {
        [SerializeField] private Bullet _bulletPrefab;
        [SerializeField] private Transform _bulletOrigin;
        [SerializeField] private Camera _camera;

        private void Update()
        {
            LookAtMouse(Input.mousePosition);

            if (Input.GetKeyDown(KeyCode.Mouse0))
            {
                Shoot();
            }
        }

        private void LookAtMouse(Vector3 mousePosition)
        {
            var gunScreenPosition = _camera.WorldToScreenPoint(transform.position);
            
            var direction = mousePosition - gunScreenPosition;

            direction.Scale(new Vector3(1, 1, 0));

            transform.up = direction;
        }

        private void Shoot()
        {
            var bullet = Instantiate(_bulletPrefab, _bulletOrigin.position, Quaternion.identity);

            bullet.Shoot(transform.up);
        }
    }
}