Merge branch 'trick-enhancements' into trick-basket-blocking

Assembly-CSharp.csproj

@@ -55,7 +55,6 @@
     <UnityVersion>6000.3.6f1</UnityVersion>
   </PropertyGroup>
   <ItemGroup>
-    <Analyzer Include="C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\Extensions\Microsoft\Visual Studio Tools for Unity\Analyzers\Microsoft.Unity.Analyzers.dll" />
     <Analyzer Include="C:\Program Files\Unity\Hub\Editor\6000.3.6f1\Editor\Data\Tools\BuildPipeline\Unity.SourceGenerators\Unity.SourceGenerators.dll" />
     <Analyzer Include="C:\Program Files\Unity\Hub\Editor\6000.3.6f1\Editor\Data\Tools\BuildPipeline\Unity.SourceGenerators\Unity.Properties.SourceGenerator.dll" />
     <Analyzer Include="C:\Program Files\Unity\Hub\Editor\6000.3.6f1\Editor\Data\Tools\BuildPipeline\Unity.SourceGenerators\Unity.UIToolkit.SourceGenerator.dll" />

Assets/Scenes/Experiment.unity

@@ -1690,6 +1690,120 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1063739947
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1063739950}
+  - component: {fileID: 1063739949}
+  - component: {fileID: 1063739948}
+  m_Layer: 0
+  m_Name: P_Run01
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!95 &1063739948
+Animator:
+  serializedVersion: 7
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1063739947}
+  m_Enabled: 1
+  m_Avatar: {fileID: 0}
+  m_Controller: {fileID: 9100000, guid: 86632cb6b3835a44e87fb6f039478d61, type: 2}
+  m_CullingMode: 0
+  m_UpdateMode: 0
+  m_ApplyRootMotion: 0
+  m_LinearVelocityBlending: 0
+  m_StabilizeFeet: 0
+  m_AnimatePhysics: 0
+  m_WarningMessage: 
+  m_HasTransformHierarchy: 1
+  m_AllowConstantClipSamplingOptimization: 1
+  m_KeepAnimatorStateOnDisable: 0
+  m_WriteDefaultValuesOnDisable: 0
+--- !u!212 &1063739949
+SpriteRenderer:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1063739947}
+  m_Enabled: 1
+  m_CastShadows: 0
+  m_ReceiveShadows: 0
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 0
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: a97c105638bdf8b4a8650670310a4cd3, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_MaskInteraction: 0
+  m_Sprite: {fileID: 21300000, guid: c28a83d936216af40976803e59feffac, type: 3}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_FlipX: 0
+  m_FlipY: 0
+  m_DrawMode: 0
+  m_Size: {x: 2.87, y: 3.58}
+  m_AdaptiveModeThreshold: 0.5
+  m_SpriteTileMode: 0
+  m_WasSpriteAssigned: 1
+  m_SpriteSortPoint: 0
+--- !u!4 &1063739950
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1063739947}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 8.13, y: 2.32, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &908853548
 GameObject:
   m_ObjectHideFlags: 0
@@ -2080,58 +2194,6 @@ PrefabInstance:
     m_AddedGameObjects: []
     m_AddedComponents: []
   m_SourcePrefab: {fileID: 100100000, guid: 99cce68fc82caea44b5a140697be00a8, type: 3}
---- !u!1 &1466477811
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 1466477813}
-  - component: {fileID: 1466477812}
-  m_Layer: 0
-  m_Name: Treat Spawner TL
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!114 &1466477812
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1466477811}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 14b0bf07aa1abc44a8ebd00cecacd6f4, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::Spawner
-  objectToSpawn: {fileID: 262983251238298495, guid: 80c527a86ad6fc34dbc73ee80c1f2951, type: 3}
-  spawnInterval: 5
-  maxAlive: 0
-  spawnOnStart: 1
-  repeatSpawns: 1
-  launchForce: 0
-  launchRandomAngle: 0
-  spinSpeed: 0
---- !u!4 &1466477813
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1466477811}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -2.42, y: 2.93, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1654086541
 GameObject:
   m_ObjectHideFlags: 0
@@ -2383,110 +2445,6 @@ PrefabInstance:
     m_AddedGameObjects: []
     m_AddedComponents: []
   m_SourcePrefab: {fileID: 100100000, guid: 414ae949bae840c4589b38dd91c715e0, type: 3}
---- !u!1 &1759124602
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 1759124604}
-  - component: {fileID: 1759124603}
-  m_Layer: 0
-  m_Name: Treat Spawner TR
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!114 &1759124603
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1759124602}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 14b0bf07aa1abc44a8ebd00cecacd6f4, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::Spawner
-  objectToSpawn: {fileID: 262983251238298495, guid: 80c527a86ad6fc34dbc73ee80c1f2951, type: 3}
-  spawnInterval: 5
-  maxAlive: 0
-  spawnOnStart: 1
-  repeatSpawns: 1
-  launchForce: 0
-  launchRandomAngle: 0
-  spinSpeed: 0
---- !u!4 &1759124604
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1759124602}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 2.88, y: 2.69, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &1830238251
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 1830238253}
-  - component: {fileID: 1830238252}
-  m_Layer: 0
-  m_Name: Treat Spawner BR
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!114 &1830238252
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1830238251}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 14b0bf07aa1abc44a8ebd00cecacd6f4, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Assembly-CSharp::Spawner
-  objectToSpawn: {fileID: 262983251238298495, guid: 80c527a86ad6fc34dbc73ee80c1f2951, type: 3}
-  spawnInterval: 5
-  maxAlive: 0
-  spawnOnStart: 1
-  repeatSpawns: 1
-  launchForce: 0
-  launchRandomAngle: 0
-  spinSpeed: 0
---- !u!4 &1830238253
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 1830238251}
-  serializedVersion: 2
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 4.5, y: -2, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &2057686360
 GameObject:
   m_ObjectHideFlags: 0
@@ -2922,13 +2880,13 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: Assembly-CSharp::Spawner
   objectToSpawn: {fileID: 262983251238298495, guid: 80c527a86ad6fc34dbc73ee80c1f2951, type: 3}
-  spawnInterval: 5
+  spawnInterval: 1.5
   maxAlive: 0
   spawnOnStart: 1
   repeatSpawns: 1
   launchForce: 4
   launchRandomAngle: 360
-  spinSpeed: 180
+  spinSpeed: 100
 --- !u!1001 &1760117322204329348
 PrefabInstance:
   m_ObjectHideFlags: 0
@@ -3020,10 +2978,6 @@ SceneRoots:
   - {fileID: 1760117322204329348}
   - {fileID: 1277412258}
   - {fileID: 1227312797}
-  - {fileID: 1830238253}
-  - {fileID: 908853550}
-  - {fileID: 1466477813}
-  - {fileID: 1759124604}
   - {fileID: 792686806}
   - {fileID: 1685410085}
   - {fileID: 377513953}

Assets/Scripts/BasketController.cs

@@ -1,8 +1,27 @@
+using System.Collections.Generic;
 using UnityEngine;
 
 public class BasketController : MonoBehaviour
 {
     public ScoreManager scoreManager;
+    [SerializeField] private Transform basketHoldPoint;
+    [SerializeField] private LayerMask trickDetectMask = ~0;
+    [SerializeField] private float basketSpawnInterval = 3f;
+    private readonly Collider2D[] overlapHits = new Collider2D[8];
+    private BoxCollider2D basketCollider;
+    private TrickController currentTrick;
+    private float nextBasketSpawnTime;
+
+    private void Awake()
+    {
+        basketCollider = GetComponent<BoxCollider2D>();
+    }
+
+    private void FixedUpdate()
+    {
+        RefreshTricksInBasket();
+        TryBasketSpawn();
+    }
 
     private void OnCollisionEnter2D(Collision2D collision)
     {
@@ -12,12 +31,193 @@ public class BasketController : MonoBehaviour
         {
             if (collision.gameObject.GetComponent<TrickController>() != null)
             {
+                RegisterTrick(collision.gameObject);
                 return;
             }
 
+            RefreshTricksInBasket();
+        if (currentTrick != null)
+        {
+            return;
+        }
+
             scoreManager.AddPoints(1);
 
             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));
+            nextBasketSpawnTime = Time.time + basketSpawnInterval;
+        }
+    }
+
+    private void UnregisterTrick(GameObject obj)
+    {
+        if (obj == null)
+        {
+            return;
+        }
+
+        if (obj.TryGetComponent<TrickController>(out var trick))
+        {
+            if (currentTrick == trick)
+            {
+                currentTrick = null;
+                trick.SetBasketed(false);
+                nextBasketSpawnTime = 0f;
+            }
+        }
+    }
+
+    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));
+                    nextBasketSpawnTime = Time.time + basketSpawnInterval;
+                }
+
+                break;
+            }
+        }
+
+        if (currentTrick == null)
+        {
+            return;
+        }
+
+        if (currentTrick.IsCarried)
+        {
+            currentTrick.SetBasketed(false);
+            currentTrick = null;
+            nextBasketSpawnTime = 0f;
+            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;
+            nextBasketSpawnTime = 0f;
+        }
+    }
+
+    private void TryBasketSpawn()
+    {
+        if (currentTrick == null || basketSpawnInterval <= 0f)
+        {
+            return;
+        }
+
+        if (Time.time < nextBasketSpawnTime)
+        {
+            return;
+        }
+
+        TrickController.TrySpawnAt(currentTrick.transform.position);
+        nextBasketSpawnTime = Time.time + basketSpawnInterval;
+    }
+
+    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;
+    }
 }

Assets/Scripts/PlayerPickupController.cs

@@ -18,16 +18,25 @@ public class PlayerPickupController : MonoBehaviour
     [SerializeField] private float throwUpwardForce = 0f;
     [SerializeField] private float throwTriggerThreshold = 0.6f;
     [SerializeField] private float dropClearance = 0.2f;
+    [SerializeField] private float holdToSpawnTime = 3f;
 
     [Header("Setup")]
     public Transform holdPoint; // Empty GameObject above head
     public float pickupRange = 2.0f;
 
     public GameObject heldObject;
+    private Rigidbody2D heldBody;
+    private float heldBodyMass;
+    private float heldBodyGravity;
+    private RigidbodyType2D heldBodyType;
+    private bool heldBodySimulated;
     private PlayerPlatformerController platformerController;
     private PlayerStressController playerStressController;
     private bool isChargingThrow;
     private float throwChargeStartTime;
+    private float holdStartTime;
+    private bool spawnedDuringHold;
+    private float nextHoldSpawnTime;
 
     private void OnEnable()
     {
@@ -108,6 +117,21 @@ public class PlayerPickupController : MonoBehaviour
             return;
         }
 
+        if (Time.time >= nextHoldSpawnTime)
+        {
+            if (heldObject == null)
+            {
+                return;
+            }
+
+            if (!TrickController.TrySpawnFromPrefabAt(heldObject.transform.position))
+            {
+                TrickController.TrySpawnAt(heldObject.transform.position);
+            }
+            spawnedDuringHold = true;
+            nextHoldSpawnTime = Time.time + holdToSpawnTime;
+        }
+
         var gamepad = GetGamepad();
         if (gamepad == null)
         {
@@ -154,25 +178,36 @@ public class PlayerPickupController : MonoBehaviour
             }
 
             heldObject = col.gameObject;
+            holdStartTime = Time.time;
+            spawnedDuringHold = false;
+            nextHoldSpawnTime = holdStartTime + holdToSpawnTime;
 
             // Parent the object to the HoldPoint and reset its local position
             heldObject.transform.SetParent(holdPoint);
             heldObject.transform.localPosition = Vector3.zero;
             heldObject.transform.localRotation = Quaternion.identity;
 
-            // Disable physics so it doesn't fall or collide with the player
-            if (heldObject.TryGetComponent<Rigidbody2D>(out Rigidbody2D rb))
-            {
-                rb.bodyType = RigidbodyType2D.Kinematic;
-                rb.gravityScale = 0;
-                rb.mass = 0;
-            }
-
             if (trick != null)
             {
                 trick.SetCarried(true);
             }
 
+            // Disable physics so it doesn't fall or collide with the player
+            if (heldObject.TryGetComponent<Rigidbody2D>(out Rigidbody2D rb))
+            {
+                heldBody = rb;
+                heldBodyMass = rb.mass;
+                heldBodyGravity = rb.gravityScale;
+                heldBodyType = rb.bodyType;
+                heldBodySimulated = rb.simulated;
+
+                rb.simulated = false;
+                rb.bodyType = RigidbodyType2D.Kinematic;
+                rb.gravityScale = 0f;
+                rb.linearVelocity = Vector2.zero;
+                rb.angularVelocity = 0f;
+            }
+
             if (playerController != null)
             {
                 playerController.enabled = false;
@@ -195,11 +230,14 @@ public class PlayerPickupController : MonoBehaviour
     public void DropObject(bool applyThrow)
     {
         // Re-enable physics
-        if (heldObject.TryGetComponent<Rigidbody2D>(out Rigidbody2D rb))
+        if (heldBody != null)
         {
-            rb.bodyType = RigidbodyType2D.Dynamic;
+            heldBody.simulated = heldBodySimulated;
-            rb.gravityScale = 1;
+            heldBody.bodyType = heldBodyType;
-            rb.linearVelocity = Vector2.zero;
+            heldBody.gravityScale = heldBodyGravity;
+            heldBody.mass = heldBodyMass;
+            heldBody.linearVelocity = Vector2.zero;
+            heldBody.angularVelocity = 0f;
         }
         if (heldObject.TryGetComponent<TrickController>(out var trick))
         {
@@ -217,7 +255,7 @@ public class PlayerPickupController : MonoBehaviour
                 heldPickup.enabled = true;
             }
         }
-        if (applyThrow && heldObject.TryGetComponent<Rigidbody2D>(out Rigidbody2D throwBody))
+        if (applyThrow && heldBody != null)
         {
             var direction = 1f;
             if (platformerController != null && Mathf.Abs(platformerController.LastMoveX) > 0.01f)
@@ -231,8 +269,9 @@ public class PlayerPickupController : MonoBehaviour
                 charge01 = Mathf.Clamp01(heldTime / Mathf.Max(0.01f, throwChargeTime));
             }
             var throwSpeed = Mathf.Lerp(minThrowSpeed, maxThrowSpeed, charge01);
-            throwBody.linearVelocity = new Vector2(direction * throwSpeed, 0f);
+            var upwardSpeed = throwUpwardForce * charge01;
-            throwBody.angularVelocity = 0f;
+            heldBody.linearVelocity = new Vector2(direction * throwSpeed, upwardSpeed);
+            heldBody.angularVelocity = 0f;
         }
         heldObject.transform.position += Vector3.up * dropClearance;
         Collider2D col = heldObject.GetComponent<Collider2D>();
@@ -241,7 +280,10 @@ public class PlayerPickupController : MonoBehaviour
         // Unparent
         heldObject.transform.SetParent(null);
         heldObject = null;
+        heldBody = null;
         isChargingThrow = false;
+        spawnedDuringHold = false;
+        nextHoldSpawnTime = 0f;
     }
 
     private Gamepad GetGamepad()

Assets/Scripts/PlayerPlatformerController.cs

@@ -275,10 +275,22 @@ public class PlayerPlatformerController : MonoBehaviour
         for (var i = 0; i < hits.Length; i++)
         {
             var hit = hits[i];
-            if (hit != null && hit != bodyCollider)
+            if (hit == null || hit == bodyCollider || hit.isTrigger)
             {
-                return true;
+                continue;
             }
+
+            if (hit.GetComponent<PlayerPlatformerController>() != null)
+            {
+                continue;
+            }
+
+            if (hit.GetComponent<TrickController>() != null)
+            {
+                continue;
+            }
+
+            return true;
         }
 
         return false;

Assets/Scripts/TrickController.cs

@@ -11,6 +11,8 @@ public class TrickController : MonoBehaviour
     private static readonly List<TrickController> ActiveTricks = new List<TrickController>();
     private static PlayerPlatformerController[] cachedPlayers = Array.Empty<PlayerPlatformerController>();
     private static float nextPlayerCacheTime;
+    private static bool hasCanonicalScale;
+    private static Vector3 canonicalScale;
     public static int ActiveCount => ActiveTricks.Count;
 
     [SerializeField] private string treatTag = "Interactable";
@@ -25,25 +27,60 @@ public class TrickController : MonoBehaviour
     [SerializeField] private float wanderWeight = 0.4f;
     [SerializeField] private int maxTricks = 50;
     [SerializeField] private float jumpImpulse = 6f;
+    [SerializeField] private float jumpImpulseVariance = 0.25f;
     [SerializeField] private float jumpCooldown = 1f;
     [SerializeField] private float jumpChancePerSecond = 0.5f;
+    [SerializeField] private float jumpArcChance = 0.5f;
+    [SerializeField] private float jumpArcHorizontalImpulse = 2f;
+    [SerializeField] private float basketSeekRadius = 8f;
+    [SerializeField] private float basketSeekWeight = 0.9f;
+    [SerializeField] private float basketMinHeight = 0.5f;
+    [SerializeField] private float basketRefreshInterval = 0.6f;
+    [SerializeField] private float basketJumpChance = 0.35f;
+    [SerializeField] private float basketJumpHorizontalRange = 0.8f;
     [SerializeField] private LayerMask groundMask = ~0;
     [SerializeField] private float groundCheckDistance = 0.05f;
     [SerializeField] private float despawnMinX = -12f;
     [SerializeField] private float despawnMaxX = 12f;
     [SerializeField] private float despawnMinY = -10f;
+    [SerializeField] private float despawnMaxY = 20f;
     [SerializeField] private float throwControlLockTime = 0.35f;
+    [SerializeField] private float wallCheckDistance = 0.1f;
+    [SerializeField] private float wallAvoidDuration = 0.6f;
+    [SerializeField] private float wallAvoidCooldown = 0.2f;
 
     private Rigidbody2D body;
     private Transform target;
     private float nextTargetTime;
+    private Transform basketTarget;
+    private float nextBasketTime;
     private Vector2 wanderDirection;
     private float nextWanderTime;
     private bool isCarried;
+    private bool isBasketed;
     private float nextConsumeTime;
     private float desiredXVelocity;
     private float nextJumpTime;
     private float movementLockUntil;
+    private readonly RaycastHit2D[] groundHits = new RaycastHit2D[4];
+    private readonly RaycastHit2D[] wallHits = new RaycastHit2D[4];
+    private float wallAvoidUntil;
+    private float wallAvoidDirection;
+    private float nextWallAvoidTime;
+    private RigidbodyType2D basketBodyType;
+    private float basketGravityScale;
+    private bool basketSimulated;
+    private bool hasBasketAnchor;
+    private Vector2 basketAnchorPosition;
+    [SerializeField] private string basketSortingLayer = "";
+    [SerializeField] private int basketSortingOrder = -10;
+    private SpriteRenderer cachedRenderer;
+    private string originalSortingLayer;
+    private int originalSortingOrder;
+    private Vector3 originalLocalScale;
+
+    public bool IsCarried => isCarried;
+    public bool IsBasketed => isBasketed;
 
     private void Awake()
     {
@@ -53,6 +90,13 @@ public class TrickController : MonoBehaviour
         body.freezeRotation = true;
         body.collisionDetectionMode = CollisionDetectionMode2D.Continuous;
         body.interpolation = RigidbodyInterpolation2D.Interpolate;
+        cachedRenderer = GetComponent<SpriteRenderer>();
+        originalLocalScale = transform.localScale;
+        if (!hasCanonicalScale)
+        {
+            canonicalScale = transform.localScale;
+            hasCanonicalScale = true;
+        }
     }
 
     private void OnEnable()
@@ -78,8 +122,13 @@ public class TrickController : MonoBehaviour
             return;
         }
 
+        if (isBasketed)
+        {
+            return;
+        }
+
         var position = transform.position;
-        if (position.x < despawnMinX || position.x > despawnMaxX || position.y < despawnMinY)
+        if (position.x < despawnMinX || position.x > despawnMaxX || position.y < despawnMinY || position.y > despawnMaxY)
         {
             Destroy(gameObject);
             return;
@@ -101,6 +150,12 @@ public class TrickController : MonoBehaviour
             nextTargetTime = Time.time + targetRefreshInterval;
         }
 
+        if (Time.time >= nextBasketTime)
+        {
+            basketTarget = FindNearestBasketAbove();
+            nextBasketTime = Time.time + basketRefreshInterval;
+        }
+
         if (Time.time >= nextWanderTime)
         {
             wanderDirection = Random.insideUnitCircle.normalized;
@@ -121,6 +176,19 @@ public class TrickController : MonoBehaviour
             return;
         }
 
+        if (isBasketed)
+        {
+            if (hasBasketAnchor)
+            {
+                transform.position = basketAnchorPosition;
+            }
+            var held = body.linearVelocity;
+            held.x = 0f;
+            held.y = 0f;
+            body.linearVelocity = held;
+            return;
+        }
+
         if (Time.time < movementLockUntil)
         {
             return;
@@ -128,9 +196,6 @@ public class TrickController : MonoBehaviour
 
         if (!IsGrounded())
         {
-            var airborne = body.linearVelocity;
-            airborne.x = 0f;
-            body.linearVelocity = airborne;
             return;
         }
 
@@ -149,6 +214,15 @@ public class TrickController : MonoBehaviour
             desiredX += wanderDirection.x * wanderWeight;
         }
 
+        if (!hasTarget && basketTarget != null)
+        {
+            var basketDelta = (Vector2)basketTarget.position - (Vector2)transform.position;
+            if (basketDelta.y >= basketMinHeight && basketDelta.magnitude <= basketSeekRadius)
+            {
+                desiredX += Mathf.Sign(basketDelta.x) * basketSeekWeight;
+            }
+        }
+
         // No trick-avoidance bias.
 
         if (Mathf.Abs(desiredX) < 0.01f)
@@ -156,6 +230,22 @@ public class TrickController : MonoBehaviour
             desiredX = wanderDirection.x * 0.2f;
         }
 
+        if (Time.time >= nextWallAvoidTime)
+        {
+            var wallDirection = GetWallAvoidDirection(desiredX);
+            if (wallDirection != 0f)
+            {
+                wallAvoidDirection = wallDirection;
+                wallAvoidUntil = Time.time + wallAvoidDuration;
+                nextWallAvoidTime = Time.time + wallAvoidDuration + wallAvoidCooldown;
+            }
+        }
+
+        if (Time.time < wallAvoidUntil && Mathf.Abs(wallAvoidDirection) > 0.01f)
+        {
+            desiredX = wallAvoidDirection;
+        }
+
         desiredVelocity = new Vector2(Mathf.Clamp(desiredX, -1f, 1f) * moveSpeed, 0f);
 
         var velocity = body.linearVelocity;
@@ -189,6 +279,14 @@ public class TrickController : MonoBehaviour
             {
                 continue;
             }
+            if (candidate.GetComponent<TrickController>() != null)
+            {
+                continue;
+            }
+            if (candidate.GetComponent<PlayerPlatformerController>() != null)
+            {
+                continue;
+            }
 
             if (!candidate.TryGetComponent<Collider2D>(out var collider) || !collider.enabled)
             {
@@ -206,6 +304,48 @@ public class TrickController : MonoBehaviour
         return best;
     }
 
+    private Transform FindNearestBasketAbove()
+    {
+        var baskets = FindObjectsByType<BasketController>(FindObjectsSortMode.None);
+        if (baskets == null || baskets.Length == 0)
+        {
+            return null;
+        }
+
+        Transform best = null;
+        var bestDistance = float.MaxValue;
+        var origin = transform.position;
+        for (var i = 0; i < baskets.Length; i++)
+        {
+            var basket = baskets[i];
+            if (basket == null || !basket.gameObject.activeInHierarchy)
+            {
+                continue;
+            }
+
+            var basketPos = basket.transform.position;
+            var delta = (Vector2)basketPos - (Vector2)origin;
+            if (delta.y < basketMinHeight)
+            {
+                continue;
+            }
+
+            var distance = delta.magnitude;
+            if (distance > basketSeekRadius)
+            {
+                continue;
+            }
+
+            if (distance < bestDistance)
+            {
+                bestDistance = distance;
+                best = basket.transform;
+            }
+        }
+
+        return best;
+    }
+
     private void TryConsumeTreat()
     {
         if (isCarried)
@@ -241,22 +381,130 @@ public class TrickController : MonoBehaviour
         }
     }
 
-    private void SpawnTrick(Vector3 position)
+    private bool SpawnTrick(Vector3 position)
     {
         if (maxTricks > 0 && ActiveTricks.Count >= maxTricks)
         {
-            return;
+            return false;
         }
 
         if (trickPrefab != null)
         {
-            Instantiate(trickPrefab, position, Quaternion.identity);
+            var instance = Instantiate(trickPrefab, position, Quaternion.identity);
-            return;
+            if (instance != null)
+            {
+                instance.ResetRuntimeState(canonicalScale);
+            }
+            return true;
         }
 
-        Instantiate(gameObject, position, Quaternion.identity);
+        var clone = Instantiate(gameObject, position, Quaternion.identity);
+        if (clone.TryGetComponent<TrickController>(out var spawned))
+        {
+            spawned.ResetRuntimeState(canonicalScale);
+        }
+        return true;
     }
 
+    private void ResetRuntimeState(Vector3? forcedScale = null)
+    {
+        isCarried = false;
+        isBasketed = false;
+        hasBasketAnchor = false;
+        movementLockUntil = 0f;
+        wallAvoidUntil = 0f;
+        wallAvoidDirection = 0f;
+        if (forcedScale.HasValue)
+        {
+            transform.localScale = forcedScale.Value;
+        }
+        if (cachedRenderer != null)
+        {
+            if (!string.IsNullOrWhiteSpace(basketSortingLayer))
+            {
+                cachedRenderer.sortingLayerName = originalSortingLayer;
+            }
+            cachedRenderer.sortingOrder = originalSortingOrder;
+        }
+
+        body.simulated = true;
+        body.bodyType = RigidbodyType2D.Dynamic;
+        body.gravityScale = 1f;
+        body.linearVelocity = Vector2.zero;
+        body.angularVelocity = 0f;
+        if (TryGetComponent<Collider2D>(out var collider))
+        {
+            collider.enabled = true;
+        }
+    }
+
+    public static bool TrySpawnAt(Vector3 position)
+    {
+        if (ActiveTricks.Count == 0)
+        {
+            return false;
+        }
+
+        TrickController candidate = null;
+        TrickController fallback = null;
+        for (var i = 0; i < ActiveTricks.Count; i++)
+        {
+            var trick = ActiveTricks[i];
+            if (trick == null)
+            {
+                continue;
+            }
+
+            if (fallback == null)
+            {
+                fallback = trick;
+            }
+
+            if (!trick.isCarried && !trick.isBasketed)
+            {
+                if (trick.TryGetComponent<Collider2D>(out var collider) && collider.enabled)
+                {
+                    candidate = trick;
+                    break;
+                }
+            }
+        }
+
+        if (candidate == null)
+        {
+            candidate = fallback;
+        }
+
+        return candidate != null && candidate.SpawnTrick(position);
+    }
+
+    public static bool TrySpawnFromPrefabAt(Vector3 position)
+    {
+        if (ActiveTricks.Count == 0)
+        {
+            return false;
+        }
+
+        for (var i = 0; i < ActiveTricks.Count; i++)
+        {
+            var trick = ActiveTricks[i];
+            if (trick == null)
+            {
+                continue;
+            }
+
+            if (trick.trickPrefab == null)
+            {
+                continue;
+            }
+
+            return trick.SpawnTrick(position);
+        }
+
+        return false;
+    }
+
+
     private float GetAvoidPlayerDirection()
     {
         if (Time.time >= nextPlayerCacheTime)
@@ -301,7 +549,7 @@ public class TrickController : MonoBehaviour
 
     private void TryJump(bool isMoving, float jumpDirection)
     {
-        if (!isMoving || Time.time < nextJumpTime)
+        if (Time.time < nextJumpTime)
         {
             return;
         }
@@ -311,22 +559,60 @@ public class TrickController : MonoBehaviour
             return;
         }
 
-        var chance = jumpChancePerSecond * Time.fixedDeltaTime;
+        var wantsBasketJump = false;
-        if (Random.value > chance)
+        var basketDir = 0f;
+        if (basketTarget != null)
+        {
+            var delta = (Vector2)basketTarget.position - (Vector2)transform.position;
+            if (delta.y >= basketMinHeight && Mathf.Abs(delta.x) <= basketJumpHorizontalRange)
+            {
+                if (Random.value < basketJumpChance)
+                {
+                    wantsBasketJump = true;
+                    basketDir = Mathf.Sign(delta.x);
+                }
+            }
+        }
+
+        if (!wantsBasketJump)
+        {
+            if (!isMoving)
+            {
+                return;
+            }
+
+            var chance = jumpChancePerSecond * Time.fixedDeltaTime;
+            if (Random.value > chance)
+            {
+                return;
+            }
+        }
+
+        if (body.linearVelocity.y > 0.01f)
         {
             return;
         }
 
         var velocity = body.linearVelocity;
         velocity.y = 0f;
-        var jumpDir = Mathf.Sign(jumpDirection);
+        var jumpDir = wantsBasketJump ? basketDir : Mathf.Sign(jumpDirection);
         if (jumpDir == 0f)
         {
             jumpDir = Random.value < 0.5f ? -1f : 1f;
         }
         velocity.x = jumpDir * moveSpeed;
         body.linearVelocity = velocity;
-        body.AddForce(Vector2.up * jumpImpulse, ForceMode2D.Impulse);
+
+        var minImpulse = Mathf.Max(0f, jumpImpulse * (1f - jumpImpulseVariance));
+        var maxImpulse = Mathf.Max(minImpulse, jumpImpulse * (1f + jumpImpulseVariance));
+        var jumpImpulseActual = Random.Range(minImpulse, maxImpulse);
+        body.AddForce(Vector2.up * jumpImpulseActual, ForceMode2D.Impulse);
+
+        if (Random.value < jumpArcChance && jumpArcHorizontalImpulse > 0f)
+        {
+            var arcDir = Random.value < 0.5f ? -1f : 1f;
+            body.AddForce(Vector2.right * arcDir * jumpArcHorizontalImpulse, ForceMode2D.Impulse);
+        }
         nextJumpTime = Time.time + jumpCooldown;
     }
 
@@ -338,26 +624,86 @@ public class TrickController : MonoBehaviour
             return false;
         }
 
-        var bounds = collider.bounds;
+        var filter = new ContactFilter2D();
-        var checkSize = new Vector2(bounds.size.x * 0.9f, groundCheckDistance * 2f);
+        filter.SetLayerMask(groundMask);
-        var checkCenter = new Vector2(bounds.center.x, bounds.min.y - groundCheckDistance);
+        filter.useTriggers = false;
-        var hits = Physics2D.OverlapBoxAll(checkCenter, checkSize, 0f, groundMask);
+
-        for (var i = 0; i < hits.Length; i++)
+        var hitCount = collider.Cast(Vector2.down, filter, groundHits, groundCheckDistance);
+        for (var i = 0; i < hitCount; i++)
         {
-            var hit = hits[i];
+            var hitCollider = groundHits[i].collider;
-            if (hit != null && hit != collider)
+            if (hitCollider == null || hitCollider == collider)
             {
-                return true;
+                continue;
             }
+
+            if (hitCollider.GetComponent<TrickController>() != null)
+            {
+                continue;
+            }
+
+            if (hitCollider.GetComponent<PlayerPlatformerController>() != null)
+            {
+                continue;
+            }
+
+            return true;
         }
 
         return false;
     }
 
+    private float GetWallAvoidDirection(float desiredX)
+    {
+        if (Mathf.Abs(desiredX) < 0.01f)
+        {
+            return 0f;
+        }
+
+        var collider = GetComponent<Collider2D>();
+        if (collider == null)
+        {
+            return 0f;
+        }
+
+        var filter = new ContactFilter2D();
+        filter.SetLayerMask(groundMask);
+        filter.useTriggers = false;
+
+        var dir = Mathf.Sign(desiredX);
+        var hitCount = collider.Cast(Vector2.right * dir, filter, wallHits, wallCheckDistance);
+        for (var i = 0; i < hitCount; i++)
+        {
+            var hitCollider = wallHits[i].collider;
+            if (hitCollider == null || hitCollider == collider)
+            {
+                continue;
+            }
+
+            if (hitCollider.GetComponent<TrickController>() != null)
+            {
+                continue;
+            }
+
+            if (hitCollider.GetComponent<PlayerPlatformerController>() != null)
+            {
+                continue;
+            }
+
+            return -dir;
+        }
+
+        return 0f;
+    }
+
 
     public void SetCarried(bool carried)
     {
         isCarried = carried;
+        if (carried && isBasketed)
+        {
+            SetBasketed(false);
+        }
         if (carried)
         {
             target = null;
@@ -385,6 +731,62 @@ public class TrickController : MonoBehaviour
         }
     }
 
+    public void SetBasketed(bool basketed, Vector2? anchorPosition = null)
+    {
+        if (isBasketed == basketed)
+        {
+            return;
+        }
+
+        isBasketed = basketed;
+        if (basketed)
+        {
+            if (cachedRenderer != null)
+            {
+                originalSortingLayer = cachedRenderer.sortingLayerName;
+                originalSortingOrder = cachedRenderer.sortingOrder;
+                if (!string.IsNullOrWhiteSpace(basketSortingLayer))
+                {
+                    cachedRenderer.sortingLayerName = basketSortingLayer;
+                }
+                cachedRenderer.sortingOrder = basketSortingOrder;
+            }
+            if (anchorPosition.HasValue)
+            {
+                hasBasketAnchor = true;
+                basketAnchorPosition = anchorPosition.Value;
+            }
+            else
+            {
+                hasBasketAnchor = false;
+            }
+            basketBodyType = body.bodyType;
+            basketGravityScale = body.gravityScale;
+            basketSimulated = body.simulated;
+            body.simulated = true;
+            body.bodyType = RigidbodyType2D.Kinematic;
+            body.gravityScale = 0f;
+            body.linearVelocity = Vector2.zero;
+            body.angularVelocity = 0f;
+            nextJumpTime = Time.time + 0.1f;
+        }
+        else
+        {
+            if (cachedRenderer != null)
+            {
+                if (!string.IsNullOrWhiteSpace(basketSortingLayer))
+                {
+                    cachedRenderer.sortingLayerName = originalSortingLayer;
+                }
+                cachedRenderer.sortingOrder = originalSortingOrder;
+            }
+            hasBasketAnchor = false;
+            body.simulated = basketSimulated;
+            body.bodyType = basketBodyType;
+            body.gravityScale = basketGravityScale;
+        }
+    }
+
     public void OnThrown()
     {
         movementLockUntil = Time.time + throwControlLockTime;