Danro/Assets/Scripts/Entities/Props/EnvironmentalCollectibleBase.cs

using System;
using RR.Game2D.Behaviour;
using UnityEngine;

namespace RR.Common.Entities.Props
{
    [RequireComponent(typeof(Collider2D))]
    public abstract class EnvironmentalCollectibleBase : MonoBehaviour
    {
        [SerializeField] private int points = 1;
        [SerializeField] private string playerTag = "Player";
        [SerializeField] private bool usePooling = true;

        private bool _collected;
        private int _defaultPoints;
        private Collider2D _trigger;
        private EnvironmentalPool _ownerPool;
        private GameObject _originPrefab;
        private Vector3 _spawnPosition;

        public event Action<EnvironmentalCollectibleBase> Collected;

        public int Points => points;
        public Vector3 SpawnPosition => _spawnPosition;
        public bool UsesPooling => usePooling;

        protected virtual void Awake()
        {
            _defaultPoints = Mathf.Max(0, points);
            _trigger = GetComponent<Collider2D>();
            ValidateTrigger();
        }

        protected virtual void Update()
        {
            TickBehaviour(Time.deltaTime);
        }

        protected virtual void OnValidate()
        {
            if (points < 0) points = 0;
            _defaultPoints = points;
            ValidateTrigger();
        }

        private void OnTriggerEnter2D(Collider2D other)
        {
            // Unity 2D trigger callbacks usually require at least one of the colliding objects to have a Rigidbody2D.
            if (_collected || other == null) return;
            if (!other.CompareTag(playerTag)) return;

            Collect(other.transform);
        }

        public void InitializeForSpawn(
            EnvironmentalPool ownerPool,
            GameObject originPrefab,
            Vector3 spawnPosition,
            int? pointsOverride)
        {
            _ownerPool = ownerPool;
            _originPrefab = originPrefab;
            _spawnPosition = spawnPosition;
            points = pointsOverride.HasValue ? Mathf.Max(0, pointsOverride.Value) : _defaultPoints;

            ResetStateForReuse();
        }

        public void ResetStateForReuse()
        {
            _collected = false;
            _spawnPosition = transform.position;
            OnSpawned();
        }

        protected void Collect(Transform collector)
        {
            if (_collected) return;

            _collected = true;
            OnCollected();

            if (points > 0)
                ScoreSystem.Instance?.RegisterEnvironmentalPoints(points);

            Collected?.Invoke(this);

            if (usePooling && _ownerPool != null && _originPrefab != null)
            {
                _ownerPool.Return(_originPrefab, gameObject);
                return;
            }

            Destroy(gameObject);
        }

        protected virtual void OnSpawned()
        {
        }

        protected virtual void OnCollected()
        {
        }

        protected abstract void TickBehaviour(float dt);

        private void ValidateTrigger()
        {
            if (_trigger == null)
                _trigger = GetComponent<Collider2D>();

            if (_trigger == null)
            {
                Debug.LogError($"[{nameof(EnvironmentalCollectibleBase)}] Missing Collider2D on {name}.", this);
                return;
            }

            if (!_trigger.isTrigger)
                Debug.LogError($"[{nameof(EnvironmentalCollectibleBase)}] Collider2D on {name} must have isTrigger enabled.", this);
        }
    }
}