795 lines
23 KiB
C#
795 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
using Random = UnityEngine.Random;
|
|
|
|
[RequireComponent(typeof(Rigidbody2D))]
|
|
[RequireComponent(typeof(Collider2D))]
|
|
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";
|
|
[SerializeField] private float moveSpeed = 3.5f;
|
|
[SerializeField] private float targetRefreshInterval = 0.4f;
|
|
[SerializeField] private float consumeDistance = 0.35f;
|
|
[SerializeField] private float wanderInterval = 1.2f;
|
|
[SerializeField] private float consumeCooldown = 1.5f;
|
|
[SerializeField] private TrickController trickPrefab;
|
|
[SerializeField] private float avoidPlayerRadius = 1.2f;
|
|
[SerializeField] private float treatSeekWeight = 1f;
|
|
[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()
|
|
{
|
|
body = GetComponent<Rigidbody2D>();
|
|
body.bodyType = RigidbodyType2D.Dynamic;
|
|
body.gravityScale = 1f;
|
|
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()
|
|
{
|
|
if (!ActiveTricks.Contains(this))
|
|
{
|
|
ActiveTricks.Add(this);
|
|
}
|
|
|
|
nextConsumeTime = Time.time + consumeCooldown;
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
ActiveTricks.Remove(this);
|
|
}
|
|
|
|
|
|
private void Update()
|
|
{
|
|
if (isCarried)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (isBasketed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var position = transform.position;
|
|
if (position.x < despawnMinX || position.x > despawnMaxX || position.y < despawnMinY || position.y > despawnMaxY)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
|
|
if (Time.time >= nextTargetTime)
|
|
{
|
|
target = FindNearestTreat();
|
|
if (target == null)
|
|
{
|
|
// If we can't find treats while we're tagged Interactable, keep moving.
|
|
wanderDirection = Random.insideUnitCircle.normalized;
|
|
if (wanderDirection.sqrMagnitude < 0.01f)
|
|
{
|
|
wanderDirection = Vector2.right;
|
|
}
|
|
nextWanderTime = Time.time + wanderInterval;
|
|
}
|
|
nextTargetTime = Time.time + targetRefreshInterval;
|
|
}
|
|
|
|
if (Time.time >= nextBasketTime)
|
|
{
|
|
basketTarget = FindNearestBasketAbove();
|
|
nextBasketTime = Time.time + basketRefreshInterval;
|
|
}
|
|
|
|
if (Time.time >= nextWanderTime)
|
|
{
|
|
wanderDirection = Random.insideUnitCircle.normalized;
|
|
if (wanderDirection.sqrMagnitude < 0.01f)
|
|
{
|
|
wanderDirection = Vector2.right;
|
|
}
|
|
nextWanderTime = Time.time + wanderInterval;
|
|
}
|
|
|
|
TryConsumeTreat();
|
|
}
|
|
|
|
private void FixedUpdate()
|
|
{
|
|
if (isCarried)
|
|
{
|
|
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;
|
|
}
|
|
|
|
if (!IsGrounded())
|
|
{
|
|
return;
|
|
}
|
|
|
|
Vector2 desiredVelocity;
|
|
var hasTarget = target != null;
|
|
var canConsume = Time.time >= nextConsumeTime;
|
|
|
|
var desiredX = 0f;
|
|
if (hasTarget && canConsume)
|
|
{
|
|
var direction = ((Vector2)target.position - (Vector2)transform.position).normalized;
|
|
desiredX += direction.x * treatSeekWeight;
|
|
}
|
|
else
|
|
{
|
|
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)
|
|
{
|
|
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;
|
|
desiredXVelocity = desiredVelocity.x;
|
|
velocity.x = Mathf.Lerp(velocity.x, desiredXVelocity, 0.25f);
|
|
body.linearVelocity = velocity;
|
|
|
|
var isMoving = Mathf.Abs(desiredXVelocity) > 0.1f;
|
|
TryJump(isMoving, desiredXVelocity);
|
|
}
|
|
|
|
private Transform FindNearestTreat()
|
|
{
|
|
var treats = GameObject.FindGameObjectsWithTag(treatTag);
|
|
if (treats == null || treats.Length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
Transform best = null;
|
|
var bestDistance = float.MaxValue;
|
|
var origin = transform.position;
|
|
for (var i = 0; i < treats.Length; i++)
|
|
{
|
|
var candidate = treats[i];
|
|
if (candidate == gameObject)
|
|
{
|
|
continue;
|
|
}
|
|
if (!candidate.activeInHierarchy)
|
|
{
|
|
continue;
|
|
}
|
|
if (candidate.GetComponent<TrickController>() != null)
|
|
{
|
|
continue;
|
|
}
|
|
if (candidate.GetComponent<PlayerPlatformerController>() != null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!candidate.TryGetComponent<Collider2D>(out var collider) || !collider.enabled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var distance = Vector2.Distance(origin, candidate.transform.position);
|
|
if (distance < bestDistance)
|
|
{
|
|
bestDistance = distance;
|
|
best = candidate.transform;
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Time.time < nextConsumeTime)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var hits = Physics2D.OverlapCircleAll(transform.position, consumeDistance);
|
|
for (var i = 0; i < hits.Length; i++)
|
|
{
|
|
var hit = hits[i];
|
|
if (hit == null || hit.gameObject == gameObject || !hit.CompareTag(treatTag))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var spawnPosition = hit.transform.position;
|
|
hit.enabled = false;
|
|
hit.gameObject.tag = "Untagged";
|
|
Destroy(hit.gameObject);
|
|
if (target == hit.transform)
|
|
{
|
|
target = null;
|
|
}
|
|
SpawnTrick(spawnPosition);
|
|
nextConsumeTime = Time.time + consumeCooldown;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool SpawnTrick(Vector3 position)
|
|
{
|
|
if (maxTricks > 0 && ActiveTricks.Count >= maxTricks)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (trickPrefab != null)
|
|
{
|
|
var instance = Instantiate(trickPrefab, position, Quaternion.identity);
|
|
if (instance != null)
|
|
{
|
|
instance.ResetRuntimeState(canonicalScale);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
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)
|
|
{
|
|
cachedPlayers = FindObjectsByType<PlayerPlatformerController>(FindObjectsSortMode.None);
|
|
nextPlayerCacheTime = Time.time + 0.5f;
|
|
}
|
|
|
|
var players = cachedPlayers;
|
|
if (players == null || players.Length == 0)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
Transform closest = null;
|
|
var closestDist = float.MaxValue;
|
|
var origin = transform.position;
|
|
for (var i = 0; i < players.Length; i++)
|
|
{
|
|
var candidate = players[i];
|
|
if (candidate == null || !candidate.gameObject.activeInHierarchy)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var dist = Vector2.Distance(origin, candidate.transform.position);
|
|
if (dist < closestDist)
|
|
{
|
|
closestDist = dist;
|
|
closest = candidate.transform;
|
|
}
|
|
}
|
|
|
|
if (closest == null || closestDist > avoidPlayerRadius)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
return Mathf.Sign(origin.x - closest.position.x);
|
|
}
|
|
|
|
|
|
private void TryJump(bool isMoving, float jumpDirection)
|
|
{
|
|
if (Time.time < nextJumpTime)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!IsGrounded())
|
|
{
|
|
return;
|
|
}
|
|
|
|
var wantsBasketJump = false;
|
|
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 = wantsBasketJump ? basketDir : Mathf.Sign(jumpDirection);
|
|
if (jumpDir == 0f)
|
|
{
|
|
jumpDir = Random.value < 0.5f ? -1f : 1f;
|
|
}
|
|
velocity.x = jumpDir * moveSpeed;
|
|
body.linearVelocity = velocity;
|
|
|
|
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;
|
|
}
|
|
|
|
private bool IsGrounded()
|
|
{
|
|
var collider = GetComponent<Collider2D>();
|
|
if (collider == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var filter = new ContactFilter2D();
|
|
filter.SetLayerMask(groundMask);
|
|
filter.useTriggers = false;
|
|
|
|
var hitCount = collider.Cast(Vector2.down, filter, groundHits, groundCheckDistance);
|
|
for (var i = 0; i < hitCount; i++)
|
|
{
|
|
var hitCollider = groundHits[i].collider;
|
|
if (hitCollider == null || hitCollider == collider)
|
|
{
|
|
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;
|
|
desiredXVelocity = 0f;
|
|
var velocity = body.linearVelocity;
|
|
velocity.x = 0f;
|
|
velocity.y = 0f;
|
|
body.linearVelocity = velocity;
|
|
nextJumpTime = Time.time + 0.1f;
|
|
if (TryGetComponent<Collider2D>(out var collider))
|
|
{
|
|
collider.enabled = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var velocity = body.linearVelocity;
|
|
velocity.x = 0f;
|
|
velocity.y = 0f;
|
|
body.linearVelocity = velocity;
|
|
if (TryGetComponent<Collider2D>(out var collider))
|
|
{
|
|
collider.enabled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|