Stash work

Assets/Scripts/Minigames/FortFight/Projectiles/ProjectileBase.cs

@@ -0,0 +1,250 @@
+using System;
+using Core;
+using Core.Lifecycle;
+using Minigames.FortFight.Fort;
+using UnityEngine;
+
+namespace Minigames.FortFight.Projectiles
+{
+    /// <summary>
+    /// Base class for all projectile types in Fort Fight.
+    /// Handles physics, collision, and basic damage dealing.
+    /// Subclasses override ActivateAbility() and OnHit() for unique behaviors.
+    /// </summary>
+    [RequireComponent(typeof(Rigidbody2D), typeof(Collider2D))]
+    public abstract class ProjectileBase : ManagedBehaviour
+    {
+        #region Inspector Properties
+        
+        [Header("Projectile Stats")]
+        [Tooltip("Base damage dealt on impact")]
+        [SerializeField] protected float damage = 20f;
+        
+        [Tooltip("Mass for physics (affects trajectory)")]
+        [SerializeField] protected float mass = 1f;
+        
+        [Header("Visuals")]
+        [Tooltip("Sprite renderer for projectile")]
+        [SerializeField] protected SpriteRenderer spriteRenderer;
+        
+        [Header("Effects")]
+        [Tooltip("Particle effect on impact (optional)")]
+        [SerializeField] protected GameObject impactEffectPrefab;
+        
+        #endregion
+
+        #region Events
+        
+        /// <summary>
+        /// Fired when projectile is launched. Parameters: (ProjectileBase projectile)
+        /// </summary>
+        public event Action<ProjectileBase> OnLaunched;
+        
+        /// <summary>
+        /// Fired when projectile hits something. Parameters: (ProjectileBase projectile, Collider2D hit)
+        /// </summary>
+        public event Action<ProjectileBase, Collider2D> OnImpact;
+        
+        /// <summary>
+        /// Fired when projectile is destroyed. Parameters: (ProjectileBase projectile)
+        /// </summary>
+        public event Action<ProjectileBase> OnDestroyed;
+        
+        #endregion
+
+        #region Properties
+        
+        public float Damage => damage;
+        public bool IsLaunched { get; protected set; }
+        public bool AbilityActivated { get; protected set; }
+        public Vector2 LaunchDirection { get; protected set; }
+        public float LaunchForce { get; protected set; }
+        
+        #endregion
+
+        #region Components
+        
+        protected Rigidbody2D rb2D;
+        protected Collider2D projectileCollider;
+        
+        #endregion
+
+        #region Lifecycle
+        
+        internal override void OnManagedAwake()
+        {
+            base.OnManagedAwake();
+            
+            // Cache components
+            rb2D = GetComponent<Rigidbody2D>();
+            projectileCollider = GetComponent<Collider2D>();
+            
+            if (spriteRenderer == null)
+            {
+                spriteRenderer = GetComponent<SpriteRenderer>();
+            }
+            
+            // Configure rigidbody
+            if (rb2D != null)
+            {
+                rb2D.mass = mass;
+                rb2D.gravityScale = 1f;
+                rb2D.collisionDetectionMode = CollisionDetectionMode2D.Continuous;
+            }
+        }
+        
+        #endregion
+
+        #region Launch
+        
+        /// <summary>
+        /// Launch the projectile with given direction and force.
+        /// Called by SlingshotController.
+        /// </summary>
+        public virtual void Launch(Vector2 direction, float force)
+        {
+            if (IsLaunched)
+            {
+                Logging.Warning($"[ProjectileBase] {gameObject.name} already launched!");
+                return;
+            }
+            
+            LaunchDirection = direction.normalized;
+            LaunchForce = force;
+            IsLaunched = true;
+            
+            // Apply physics impulse
+            if (rb2D != null)
+            {
+                rb2D.AddForce(LaunchDirection * LaunchForce, ForceMode2D.Impulse);
+                Logging.Debug($"[ProjectileBase] Launched {gameObject.name} with force {LaunchForce} in direction {LaunchDirection}");
+            }
+            
+            // Fire event
+            OnLaunched?.Invoke(this);
+        }
+        
+        #endregion
+
+        #region Ability
+        
+        /// <summary>
+        /// Activate projectile's special ability (mid-flight).
+        /// Override in subclasses for unique behaviors.
+        /// Called when player taps screen during flight.
+        /// </summary>
+        public virtual void ActivateAbility()
+        {
+            if (!IsLaunched)
+            {
+                Logging.Warning($"[ProjectileBase] Cannot activate ability - projectile not launched yet!");
+                return;
+            }
+            
+            if (AbilityActivated)
+            {
+                Logging.Warning($"[ProjectileBase] Ability already activated!");
+                return;
+            }
+            
+            AbilityActivated = true;
+            Logging.Debug($"[ProjectileBase] {gameObject.name} ability activated");
+            
+            // Subclasses override this for special behavior
+        }
+        
+        #endregion
+
+        #region Collision
+        
+        private void OnCollisionEnter2D(Collision2D collision)
+        {
+            if (!IsLaunched) return;
+            
+            Logging.Debug($"[ProjectileBase] {gameObject.name} hit {collision.gameObject.name}");
+            
+            // Check if hit a fort block
+            FortBlock block = collision.gameObject.GetComponent<FortBlock>();
+            if (block != null)
+            {
+                // Deal damage to block
+                block.TakeDamage(damage);
+                Logging.Debug($"[ProjectileBase] Dealt {damage} damage to {block.gameObject.name}");
+            }
+            
+            // Spawn impact effect
+            SpawnImpactEffect(collision.contacts[0].point);
+            
+            // Fire impact event
+            OnImpact?.Invoke(this, collision.collider);
+            
+            // Call subclass-specific hit behavior
+            OnHit(collision.collider);
+            
+            // Destroy projectile after hit (subclasses can override)
+            DestroyProjectile();
+        }
+        
+        /// <summary>
+        /// Called when projectile hits something.
+        /// Override in subclasses for projectile-specific behavior.
+        /// </summary>
+        protected virtual void OnHit(Collider2D hit)
+        {
+            // Subclasses override for special behavior
+            // e.g., Vacuum continues sliding, TrashBag splits, etc.
+        }
+        
+        #endregion
+
+        #region Effects
+        
+        /// <summary>
+        /// Spawn impact particle effect
+        /// </summary>
+        protected void SpawnImpactEffect(Vector2 position)
+        {
+            if (impactEffectPrefab != null)
+            {
+                GameObject effect = Instantiate(impactEffectPrefab, position, Quaternion.identity);
+                Destroy(effect, 2f); // Auto-cleanup
+            }
+        }
+        
+        #endregion
+
+        #region Destruction
+        
+        /// <summary>
+        /// Destroy the projectile.
+        /// Can be overridden by subclasses for delayed destruction.
+        /// </summary>
+        protected virtual void DestroyProjectile()
+        {
+            Logging.Debug($"[ProjectileBase] Destroying {gameObject.name}");
+            
+            // Fire destroyed event
+            OnDestroyed?.Invoke(this);
+            
+            // Destroy GameObject
+            Destroy(gameObject);
+        }
+        
+        #endregion
+
+        #region Debug
+        
+        private void OnDrawGizmos()
+        {
+            if (IsLaunched && Application.isPlaying)
+            {
+                // Draw launch direction
+                Gizmos.color = Color.yellow;
+                Gizmos.DrawLine(transform.position, transform.position + (Vector3)(LaunchDirection * 2f));
+            }
+        }
+        
+        #endregion
+    }
+}
+