Tricks can now occupy baskets and block scoring

2026-02-01 15:13:20 -06:00
parent b09362917a
commit 2d38838efd
3 changed files with 274 additions and 5 deletions
@@ -1,8 +1,24 @@
+using System.Collections.Generic;
 using UnityEngine;

 public class BasketController : MonoBehaviour
 {
    public ScoreManager scoreManager;
+    [SerializeField] private Transform basketHoldPoint;
+    [SerializeField] private LayerMask trickDetectMask = ~0;
+    private readonly Collider2D[] overlapHits = new Collider2D[8];
+    private BoxCollider2D basketCollider;
+    private TrickController currentTrick;
+
+    private void Awake()
+    {
+        basketCollider = GetComponent<BoxCollider2D>();
+    }
+
+    private void FixedUpdate()
+    {
+        RefreshTricksInBasket();
+    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
@@ -11,6 +27,13 @@ public class BasketController : MonoBehaviour
        if (collision.gameObject.CompareTag("Interactable"))
        {
            if (collision.gameObject.GetComponent<TrickController>() != null)
+            {
+                RegisterTrick(collision.gameObject);
+                return;
+            }
+
+            RefreshTricksInBasket();
+            if (currentTrick != null)
            {
                return;
            }
@@ -20,4 +43,157 @@ public class BasketController : MonoBehaviour
            GameObject.Destroy(collision.gameObject);
        }
    }
+
+    private void OnCollisionExit2D(Collision2D collision)
+    {
+        UnregisterTrick(collision.gameObject);
+    }
+
+    private void OnTriggerEnter2D(Collider2D other)
+    {
+        if (!other.CompareTag("Interactable"))
+        {
+            return;
+        }
+
+        if (other.GetComponent<TrickController>() != null)
+        {
+            RegisterTrick(other.gameObject);
+        }
+    }
+
+    private void OnTriggerExit2D(Collider2D other)
+    {
+        UnregisterTrick(other.gameObject);
+    }
+
+    private void RegisterTrick(GameObject obj)
+    {
+        if (obj.TryGetComponent<TrickController>(out var trick))
+        {
+            if (currentTrick != null && currentTrick != trick)
+            {
+                return;
+            }
+
+            currentTrick = trick;
+            trick.SetBasketed(true, GetBasketAnchorPosition(trick));
+        }
+    }
+
+    private void UnregisterTrick(GameObject obj)
+    {
+        if (obj == null)
+        {
+            return;
+        }
+
+        if (obj.TryGetComponent<TrickController>(out var trick))
+        {
+            if (currentTrick == trick)
+            {
+                currentTrick = null;
+                trick.SetBasketed(false);
+            }
+        }
+    }
+
+    private void RefreshTricksInBasket()
+    {
+        if (basketCollider == null)
+        {
+            return;
+        }
+
+        var filter = new ContactFilter2D();
+        filter.SetLayerMask(trickDetectMask);
+        filter.useTriggers = true;
+
+        var hitCount = basketCollider.Overlap(filter, overlapHits);
+        for (var i = 0; i < hitCount; i++)
+        {
+            var hit = overlapHits[i];
+            if (hit == null || !hit.CompareTag("Interactable"))
+            {
+                continue;
+            }
+
+            if (hit.TryGetComponent<TrickController>(out var trick))
+            {
+                if (currentTrick == null)
+                {
+                    currentTrick = trick;
+                    trick.SetBasketed(true, GetBasketAnchorPosition(trick));
+                }
+
+                break;
+            }
+        }
+
+        if (currentTrick == null)
+        {
+            return;
+        }
+
+        if (currentTrick.IsCarried)
+        {
+            currentTrick.SetBasketed(false);
+            currentTrick = null;
+            return;
+        }
+
+        var stillInside = false;
+        for (var i = 0; i < hitCount; i++)
+        {
+            var hit = overlapHits[i];
+            if (hit == null || !hit.CompareTag("Interactable"))
+            {
+                continue;
+            }
+
+            if (hit.TryGetComponent<TrickController>(out var trick) && trick == currentTrick)
+            {
+                stillInside = true;
+                break;
+            }
+        }
+
+        if (!stillInside)
+        {
+            currentTrick.SetBasketed(false);
+            currentTrick = null;
+        }
+    }
+
+    private Vector2? GetBasketAnchorPosition(TrickController trick)
+    {
+        if (basketHoldPoint != null)
+        {
+            return OffsetForTrickHeight(basketHoldPoint.position, trick);
+        }
+
+        if (basketCollider != null)
+        {
+            return OffsetForTrickHeight(basketCollider.bounds.center, trick);
+        }
+
+        return null;
+    }
+
+    private Vector2 OffsetForTrickHeight(Vector2 anchor, TrickController trick)
+    {
+        if (trick == null)
+        {
+            return anchor;
+        }
+
+        var renderer = trick.GetComponent<SpriteRenderer>();
+        if (renderer == null)
+        {
+            return anchor;
+        }
+
+        anchor.y += renderer.bounds.size.y * 0.5f;
+        return anchor;
+    }
 }