SHADE_Y3/Assets/Scripts/Gameplay/Player/SC_PickAndThrow.cs

496 lines
16 KiB
C#
Raw Normal View History

2023-03-25 15:52:22 +08:00
using SHADE;
2022-11-21 00:12:09 +08:00
using SHADE_Scripting;
2023-02-03 19:37:18 +08:00
using SHADE_Scripting.Audio;
2022-11-02 00:25:43 +08:00
using System;
using System.Collections.Generic;
2022-11-02 00:25:43 +08:00
using static PlayerController;
2022-11-23 20:26:53 +08:00
using static Item;
2022-11-02 00:25:43 +08:00
public class PickAndThrow : Script
{
public Vector3 throwForce = new Vector3(10.0f, 8.0f, 10.0f);
public Vector3 cameraArmOffSet = new Vector3(0.0f, 0.25f, 0.0f);
public GameObject item { get; set; }
2022-11-21 00:12:09 +08:00
public float delayTimer = 1.0f;
public float aimingLength = 1.5f;
private float timer;
private PlayerController pc;
private Transform itemTransform;
private RigidBody itemRidigBody;
private Collider itemCollider;
2022-11-23 20:26:53 +08:00
private Item itemScript;
private Transform raccoonHoldLocation;
2023-03-05 15:35:57 +08:00
public ThirdPersonCamera tpc { get; set; }
private float lastXDir;
private float lastZDir;
private bool inRange = false;
public bool throwItem = false;
2023-03-05 15:35:57 +08:00
public Vector3 prevTargetOffSet { get; set; }
[Tooltip("Lenght of ray")]
public float rayDistance = 1;
2022-11-21 00:12:09 +08:00
2023-02-04 16:02:59 +08:00
[Tooltip("Height of ray")]
public float rayHeight = 0.1f;
2023-03-14 17:18:52 +08:00
[NonSerialized]
private TweenThread camArmTween;
[NonSerialized]
2023-03-15 19:39:12 +08:00
private TweenThreadVec3 offSetCamTween;
[NonSerialized]
2023-03-17 00:31:30 +08:00
private TweenThread FOVTween;
public float lerpPickUpDuration = 0.75f;
private float pickUptimer = 0.0f;
private bool foodHoldReach = false;
2023-03-14 17:18:52 +08:00
2023-03-15 19:39:12 +08:00
public float tweenAimDuration = 0.3f;
private bool camTweenUpdate = false;
2023-03-14 17:18:52 +08:00
2023-03-17 00:31:30 +08:00
public float aimingFOV = 15.0f;
2023-03-21 17:55:19 +08:00
private TrajectoryRenderable trajComp;
private Vector3 currThrowForce;
private float currentItemMass;
public uint trajMaxSteps = 50;
public float trajTimeSteps = 0.03f;
2022-11-02 00:25:43 +08:00
protected override void awake()
{
pc = GetScript<PlayerController>();
2023-03-25 02:38:56 +08:00
if (!pc)
Debug.LogError("PLAYER CONTROLLER EMPTY");
2022-11-21 00:12:09 +08:00
raccoonHoldLocation = GetComponentInChildren<Transform>();
2022-11-21 21:01:44 +08:00
if (!raccoonHoldLocation)
Debug.LogError("CHILD EMPTY");
2022-11-21 00:12:09 +08:00
tpc = GetScriptInChildren<ThirdPersonCamera>();
2023-03-25 02:38:56 +08:00
if (!tpc)
Debug.LogError("TPC EMPTY");
2023-03-25 02:38:56 +08:00
AudioHandler.audioClipHandlers["SFXThrowLarge"] = Audio.CreateAudioClip("event:/Raccoon/raccoon_throw_large");
AudioHandler.audioClipHandlers["SFXThrowMedium"] = Audio.CreateAudioClip("event:/Raccoon/raccoon_throw_medium");
AudioHandler.audioClipHandlers["SFXThrowSmall"] = Audio.CreateAudioClip("event:/Raccoon/raccoon_throw_small");
2023-02-03 19:37:18 +08:00
2022-11-21 00:12:09 +08:00
timer = delayTimer;
2023-03-21 17:55:19 +08:00
trajComp = GetComponentInChildren<TrajectoryRenderable>();
2023-03-25 02:38:56 +08:00
if (!trajComp)
2023-03-21 17:55:19 +08:00
Debug.LogError("TrajectoryRenderable MISSING");
2022-11-02 00:25:43 +08:00
}
2023-03-14 17:18:52 +08:00
protected override void start()
{
}
2022-11-02 00:25:43 +08:00
protected override void update()
{
2023-03-02 17:33:02 +08:00
if (GameManager.Instance.GamePause || !GameManager.Instance.stealFoodPopUpDone)
2023-02-21 19:31:50 +08:00
{
return;
}
2023-02-21 19:31:50 +08:00
if (timer <= delayTimer)
2022-11-21 00:12:09 +08:00
timer += Time.DeltaTimeF;
2022-11-13 21:56:28 +08:00
CalculateDir();
CastRay();
2023-03-15 19:39:12 +08:00
if (camTweenUpdate)
{
pc.camArm.TargetOffset = offSetCamTween.GetValue();
pc.camArm.ArmLength = camArmTween.GetValue();
2023-03-17 00:31:30 +08:00
pc.cam.FOV = FOVTween.GetValue();
2023-03-15 19:39:12 +08:00
2023-03-17 00:31:30 +08:00
if (offSetCamTween.IsCompleted() && camArmTween.IsCompleted() && FOVTween.IsCompleted())
2023-03-15 19:39:12 +08:00
camTweenUpdate = false;
}
if (pc && itemRidigBody && itemTransform && itemCollider)
2022-11-02 00:25:43 +08:00
{
if (pc.holdItem)
{
2023-03-15 19:39:12 +08:00
TweenFood();
itemTransform.LocalRotation = pc.tranform.LocalRotation;
2023-03-15 19:39:12 +08:00
itemRidigBody.ClearForces();
itemRidigBody.ClearTorque();
itemRidigBody.LinearVelocity = Vector3.Zero;
itemRidigBody.AngularVelocity = Vector3.Zero;
if (Input.GetMouseButtonDown(Input.MouseCode.LeftButton))
{
2022-11-21 00:12:09 +08:00
pc.isAiming = true;
2023-03-17 00:31:30 +08:00
TweenAimCamArm(true);
2022-11-21 00:12:09 +08:00
}
if (Input.GetMouseButtonUp(Input.MouseCode.LeftButton) && pc.isAiming)
{
2023-03-25 02:38:56 +08:00
if (itemScript.currCategory == ItemCategory.LIGHT)
AudioHandler.audioClipHandlers["SFXThrowSmall"].Play();
else if (itemScript.currCategory == ItemCategory.MEDIUM)
AudioHandler.audioClipHandlers["SFXThrowMedium"].Play();
else
AudioHandler.audioClipHandlers["SFXThrowLarge"].Play();
itemRidigBody.IsGravityEnabled = true;
itemCollider.GetCollisionShape(0).IsTrigger = false;
2022-11-21 00:12:09 +08:00
pc.isAiming = false;
2023-03-17 00:31:30 +08:00
TweenAimCamArm(false);
pc.holdItem = false;
2023-03-17 00:31:30 +08:00
foodHoldReach = false;
inRange = false;
throwItem = true;
2023-03-14 17:18:52 +08:00
PlayThrowAnimation();
2022-11-21 00:12:09 +08:00
timer = 0.0f;
}
2022-11-23 20:26:53 +08:00
if (Input.GetMouseButtonDown(Input.MouseCode.RightButton) && !pc.isAiming)
{
pc.holdItem = false;
2023-03-17 00:31:30 +08:00
foodHoldReach = false;
inRange = false;
itemRidigBody.IsGravityEnabled = true;
itemCollider.GetCollisionShape(0).IsTrigger = false;
ResetItemObject();
}
2022-11-23 20:26:53 +08:00
if (Input.GetMouseButtonDown(Input.MouseCode.RightButton) && pc.isAiming)
{
pc.isAiming = false;
pc.cam.FOV = Settings.cameraFOV;
2023-03-17 00:31:30 +08:00
TweenAimCamArm(false);
2022-11-23 20:26:53 +08:00
}
}
else if (!pc.holdItem)
{
itemRidigBody.IsGravityEnabled = true;
itemCollider.GetCollisionShape(0).IsTrigger = false;
}
2022-11-02 00:25:43 +08:00
}
2022-11-13 21:56:28 +08:00
2022-11-21 00:12:09 +08:00
if (timer > delayTimer && pc && !pc.holdItem && inRange && Input.GetMouseButtonDown(Input.MouseCode.LeftButton))
2022-11-13 21:56:28 +08:00
{
2022-11-21 00:12:09 +08:00
if (pc.currentState == RaccoonStates.WALKING || pc.currentState == RaccoonStates.IDLE)
{
pc.holdItem = true;
RetrieveItemComponets();
2023-03-14 17:18:52 +08:00
PlayPickUpAnimation();
2022-11-21 00:12:09 +08:00
}
2022-11-13 21:56:28 +08:00
}
2023-03-21 17:55:19 +08:00
if (pc.isAiming && itemScript)
{
if (itemScript.currCategory == ItemCategory.LIGHT)
currThrowForce = new Vector3(throwForce.x * lastXDir, throwForce.y + (throwForce.y * GetPitchRatioRange()), throwForce.z * lastZDir) * 0.2f;
else if (itemScript.currCategory == ItemCategory.MEDIUM)
currThrowForce = new Vector3(throwForce.x * lastXDir, throwForce.y + (throwForce.y * GetPitchRatioRange()), throwForce.z * lastZDir) * 0.75f;
else
currThrowForce = new Vector3(throwForce.x * lastXDir, throwForce.y + (throwForce.y * GetPitchRatioRange()), throwForce.z * lastZDir);
if (pc.holdItem && trajComp)
trajComp.SimulateTrajectory(item.EntityId, currentItemMass, currThrowForce, trajTimeSteps, trajMaxSteps);
}
2022-11-02 00:25:43 +08:00
}
protected override void fixedUpdate()
{
2023-03-02 17:33:02 +08:00
if (GameManager.Instance.GamePause || !GameManager.Instance.stealFoodPopUpDone)
2023-02-21 19:31:50 +08:00
{
return;
}
if (throwItem && itemRidigBody && pc)
{
2023-03-21 17:55:19 +08:00
itemRidigBody.AddForce(currThrowForce);
itemRidigBody.LinearVelocity += pc.rb.LinearVelocity;
throwItem = false;
ResetItemObject();
}
}
2023-03-25 15:52:22 +08:00
public void SetItemGravityBack()
{
if(itemRidigBody)
itemRidigBody.IsGravityEnabled = true;
if(itemCollider)
itemCollider.GetCollisionShape(0).IsTrigger = false;
}
2023-03-05 15:35:57 +08:00
public void ResetItemObject()
{
itemRidigBody = null;
itemTransform = null;
itemCollider = null;
2022-11-23 20:26:53 +08:00
itemScript = null;
item = new GameObject();
}
private void RetrieveItemComponets()
{
//get the transform of the given item
if (item.GetScript<Item>() && !itemTransform && !itemRidigBody)
{
itemRidigBody = item.GetComponent<RigidBody>();
if (!itemRidigBody)
Debug.Log("Item rb EMPTY");
else
{
2023-03-21 17:55:19 +08:00
currentItemMass = itemRidigBody.Mass;
itemRidigBody.IsGravityEnabled = false;
}
itemTransform = item.GetComponent<Transform>();
if (!itemTransform)
Debug.Log("Item transform EMPTY");
else
{
itemTransform.LocalEulerAngles = Vector3.Zero;
}
itemCollider = item.GetComponent<Collider>();
if (!itemCollider)
Debug.Log("Item collider EMPTY");
else
{
itemCollider.GetCollisionShape(0).IsTrigger = true;
}
2022-11-23 20:26:53 +08:00
itemScript = item.GetScript<Item>();
if(!itemScript)
Debug.Log("Item script EMPTY");
}
}
2022-11-13 21:56:28 +08:00
private void CalculateDir()
{
if (pc && pc.cam)
2022-11-13 21:56:28 +08:00
{
Vector3 camerAixs = pc.cam.GetForward();
2022-11-13 21:56:28 +08:00
camerAixs.y = 0;
camerAixs.Normalise();
lastXDir = camerAixs.x;
lastZDir = camerAixs.z;
}
}
private void CastRay()
2022-11-21 00:12:09 +08:00
{
if (pc != null)
{
Vector3 dirNor = pc.tranform.Forward;
Vector3 playerRayPos = pc.tranform.GlobalPosition;
2023-02-04 16:02:59 +08:00
playerRayPos.y += rayHeight;
dirNor.Normalise();
2023-03-15 19:39:12 +08:00
List<RaycastHit> rayList1 = Physics.Raycast(new Ray(playerRayPos, Vector3.RotateY(dirNor, SHADE.Math.DegreesToRadians(25.0f))), rayDistance, false, (ushort)65535);
List<RaycastHit> rayList2 = Physics.Raycast(new Ray(playerRayPos, Vector3.RotateY(dirNor, SHADE.Math.DegreesToRadians(-25.0f))), rayDistance, false, (ushort)65535);
List<RaycastHit> rayList3 = Physics.Raycast(new Ray(playerRayPos, Vector3.RotateY(dirNor, SHADE.Math.DegreesToRadians(12.5f))), rayDistance, false, (ushort)65535);
List<RaycastHit> rayList4 = Physics.Raycast(new Ray(playerRayPos, Vector3.RotateY(dirNor, SHADE.Math.DegreesToRadians(-12.5f))), rayDistance, false, (ushort)65535);
List<RaycastHit> rayList5 = Physics.Raycast(new Ray(playerRayPos, dirNor), rayDistance , false, (ushort)65535);
if (rayList1.Count > 0)
{
RaycastHit ray1 = rayList1[0];
inRange = CheckForItem(ray1);
return;
}
else if (rayList2.Count > 0)
{
RaycastHit ray2 = rayList2[0];
inRange = CheckForItem(ray2);
return;
}
else if (rayList3.Count > 0)
{
RaycastHit ray3 = rayList3[0];
inRange = CheckForItem(ray3);
return;
}
2023-03-15 19:39:12 +08:00
else if (rayList4.Count > 0)
{
RaycastHit ray4 = rayList4[0];
inRange = CheckForItem(ray4);
return;
}
else if (rayList5.Count > 0)
{
RaycastHit ray5 = rayList5[0];
inRange = CheckForItem(ray5);
return;
}
else
{
inRange = false;
}
}
2022-11-21 00:12:09 +08:00
}
private bool CheckForItem(RaycastHit ray)
{
if (ray.Hit)
{
if (ray.Other.Value.GetScript<Item>() && !pc.holdItem)
{
item = ray.Other.Value;
return true;
}
else
return false;
}
return false;
}
private float GetPitchRatioRange()
{
return (pc.camArm.Pitch - tpc.pitchUpperClamp) / (tpc.pitchLowerClamp - tpc.pitchUpperClamp);
}
2023-03-14 17:18:52 +08:00
private void PlayPickUpAnimation()
{
if (PlayerAnimations.Instance)
{
PlayerAnimations.Instance.playerAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.playerAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerPickUpClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.playerAnimator.Play(PlayerAnimations.Instance.playerCarryWalkClip);
else
PlayerAnimations.Instance.playerAnimator.Play(PlayerAnimations.Instance.playerCarryIdleClip);
}
});
PlayerAnimations.Instance.BagAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.BagAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerPickUpClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.BagAnimator.Play(PlayerAnimations.Instance.playerCarryWalkClip);
else
PlayerAnimations.Instance.BagAnimator.Play(PlayerAnimations.Instance.playerCarryIdleClip);
}
});
PlayerAnimations.Instance.silhoPlayerAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.silhoPlayerAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerPickUpClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.silhoPlayerAnimator.Play(PlayerAnimations.Instance.playerCarryWalkClip);
else
PlayerAnimations.Instance.silhoPlayerAnimator.Play(PlayerAnimations.Instance.playerCarryIdleClip);
}
});
PlayerAnimations.Instance.silhoBagAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.silhoBagAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerPickUpClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.silhoBagAnimator.Play(PlayerAnimations.Instance.playerCarryWalkClip);
else
PlayerAnimations.Instance.silhoBagAnimator.Play(PlayerAnimations.Instance.playerCarryIdleClip);
}
});
}
}
private void PlayThrowAnimation()
{
if (PlayerAnimations.Instance)
{
PlayerAnimations.Instance.playerAnimator.PlayOneShot(PlayerAnimations.Instance.playerThrowClip);
PlayerAnimations.Instance.playerAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerThrowClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.playerAnimator.Play(PlayerAnimations.Instance.playerWalkClip);
else
PlayerAnimations.Instance.playerAnimator.Play(PlayerAnimations.Instance.playerIdleClip);
}
});
PlayerAnimations.Instance.BagAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.BagAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerThrowClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.BagAnimator.Play(PlayerAnimations.Instance.playerWalkClip);
else
PlayerAnimations.Instance.BagAnimator.Play(PlayerAnimations.Instance.playerIdleClip);
}
});
PlayerAnimations.Instance.silhoPlayerAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.silhoPlayerAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerThrowClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.silhoPlayerAnimator.Play(PlayerAnimations.Instance.playerWalkClip);
else
PlayerAnimations.Instance.silhoPlayerAnimator.Play(PlayerAnimations.Instance.playerIdleClip);
}
});
PlayerAnimations.Instance.silhoBagAnimator.PlayOneShot(PlayerAnimations.Instance.playerPickUpClip);
PlayerAnimations.Instance.silhoBagAnimator.OnClipFinished.RegisterAction((x) =>
{
if (x.FinishedClip == PlayerAnimations.Instance.playerThrowClip)
{
if (pc.isMoveKeyPress)
PlayerAnimations.Instance.silhoBagAnimator.Play(PlayerAnimations.Instance.playerWalkClip);
else
PlayerAnimations.Instance.silhoBagAnimator.Play(PlayerAnimations.Instance.playerIdleClip);
}
});
}
}
2023-03-15 19:39:12 +08:00
private void TweenFood()
{
2023-03-17 00:31:30 +08:00
if (!foodHoldReach)
{
pickUptimer += Time.DeltaTimeF;
itemTransform.LocalPosition = Vector3.Lerp(itemTransform.LocalPosition, raccoonHoldLocation.GlobalPosition, pickUptimer / lerpPickUpDuration);
}
else
2023-03-15 19:39:12 +08:00
itemTransform.LocalPosition = raccoonHoldLocation.GlobalPosition;
2023-03-17 00:31:30 +08:00
if (pickUptimer >= lerpPickUpDuration)
{
foodHoldReach = true;
pickUptimer = 0.0f;
}
2023-03-15 19:39:12 +08:00
}
2023-03-17 00:31:30 +08:00
private void TweenAimCamArm(bool aim)
2023-03-15 19:39:12 +08:00
{
2023-03-17 00:31:30 +08:00
if (aim)
2023-03-15 19:39:12 +08:00
{
offSetCamTween = TweenManager.CreateTweenThreadVec3(tweenAimDuration, pc.camArm.TargetOffset, cameraArmOffSet, EASING_METHOD.EASE_IN_SINE);
2023-03-17 00:31:30 +08:00
camArmTween = TweenManager.CreateTweenThread(tweenAimDuration, pc.camArm.ArmLength, aimingLength, EASING_METHOD.EASE_IN_SINE);
FOVTween = TweenManager.CreateTweenThread(tweenAimDuration, pc.cam.FOV, Settings.cameraFOV + aimingFOV, EASING_METHOD.EASE_IN_SINE);
}
else
{
offSetCamTween = TweenManager.CreateTweenThreadVec3(tweenAimDuration, pc.camArm.TargetOffset, prevTargetOffSet, EASING_METHOD.EASE_IN_SINE);
camArmTween = TweenManager.CreateTweenThread(tweenAimDuration, pc.camArm.ArmLength, tpc.armLength, EASING_METHOD.EASE_IN_SINE);
FOVTween = TweenManager.CreateTweenThread(tweenAimDuration, pc.cam.FOV, Settings.cameraFOV , EASING_METHOD.EASE_IN_SINE);
2023-03-15 19:39:12 +08:00
}
2023-03-17 00:31:30 +08:00
camTweenUpdate = true;
2023-03-15 19:39:12 +08:00
}
2022-11-02 00:25:43 +08:00
}