// Token: 0x06005DD7 RID: 24023 RVA: 0x0020D7A3 File Offset: 0x0020BBA3
public void StartRotationLerp()
{
this.lerpStartTime = Time.time;
this.lerpBackToZeroRotation = true;
this.lerpStartRotation = this.pivotTransform.localRotation;
Util.ResetTransform(this.nockTransform, true);
}
//-------------------------------------------------
public void StartRotationLerp()
{
lerpStartTime = Time.time;
lerpBackToZeroRotation = true;
lerpStartRotation = pivotTransform.localRotation;
Util.ResetTransform(nockTransform);
}
//-------------------------------------------------
private GameObject InstantiateArrow()
{
GameObject arrow = Instantiate(ArrowPrefab, ArrowNockTransform.position, ArrowNockTransform.rotation);
arrow.name = "Bow " + ArrowPrefab.name;
arrow.transform.parent = ArrowNockTransform;
Util.ResetTransform(arrow.transform);
return(arrow);
}
// Token: 0x060021FE RID: 8702 RVA: 0x000A8578 File Offset: 0x000A6778
private void OnChaperoneInfoInitialized()
{
ChaperoneInfo instance = ChaperoneInfo.instance;
if (instance.initialized && instance.roomscale)
{
if (this.playAreaPreviewTransform == null)
{
this.playAreaPreviewTransform = new GameObject("PlayAreaPreviewTransform").transform;
this.playAreaPreviewTransform.parent = base.transform;
Util.ResetTransform(this.playAreaPreviewTransform, true);
this.playAreaPreviewCorner.SetActive(true);
this.playAreaPreviewCorners = new Transform[4];
this.playAreaPreviewCorners[0] = this.playAreaPreviewCorner.transform;
this.playAreaPreviewCorners[1] = Object.Instantiate <Transform>(this.playAreaPreviewCorners[0]);
this.playAreaPreviewCorners[2] = Object.Instantiate <Transform>(this.playAreaPreviewCorners[0]);
this.playAreaPreviewCorners[3] = Object.Instantiate <Transform>(this.playAreaPreviewCorners[0]);
this.playAreaPreviewCorners[0].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewCorners[1].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewCorners[2].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewCorners[3].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewSide.SetActive(true);
this.playAreaPreviewSides = new Transform[4];
this.playAreaPreviewSides[0] = this.playAreaPreviewSide.transform;
this.playAreaPreviewSides[1] = Object.Instantiate <Transform>(this.playAreaPreviewSides[0]);
this.playAreaPreviewSides[2] = Object.Instantiate <Transform>(this.playAreaPreviewSides[0]);
this.playAreaPreviewSides[3] = Object.Instantiate <Transform>(this.playAreaPreviewSides[0]);
this.playAreaPreviewSides[0].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewSides[1].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewSides[2].transform.parent = this.playAreaPreviewTransform;
this.playAreaPreviewSides[3].transform.parent = this.playAreaPreviewTransform;
}
float playAreaSizeX = instance.playAreaSizeX;
float playAreaSizeZ = instance.playAreaSizeZ;
this.playAreaPreviewSides[0].localPosition = new Vector3(0f, 0f, 0.5f * playAreaSizeZ - 0.25f);
this.playAreaPreviewSides[1].localPosition = new Vector3(0f, 0f, -0.5f * playAreaSizeZ + 0.25f);
this.playAreaPreviewSides[2].localPosition = new Vector3(0.5f * playAreaSizeX - 0.25f, 0f, 0f);
this.playAreaPreviewSides[3].localPosition = new Vector3(-0.5f * playAreaSizeX + 0.25f, 0f, 0f);
this.playAreaPreviewSides[0].localScale = new Vector3(playAreaSizeX - 0.5f, 1f, 1f);
this.playAreaPreviewSides[1].localScale = new Vector3(playAreaSizeX - 0.5f, 1f, 1f);
this.playAreaPreviewSides[2].localScale = new Vector3(playAreaSizeZ - 0.5f, 1f, 1f);
this.playAreaPreviewSides[3].localScale = new Vector3(playAreaSizeZ - 0.5f, 1f, 1f);
this.playAreaPreviewSides[0].localRotation = Quaternion.Euler(0f, 0f, 0f);
this.playAreaPreviewSides[1].localRotation = Quaternion.Euler(0f, 180f, 0f);
this.playAreaPreviewSides[2].localRotation = Quaternion.Euler(0f, 90f, 0f);
this.playAreaPreviewSides[3].localRotation = Quaternion.Euler(0f, 270f, 0f);
this.playAreaPreviewCorners[0].localPosition = new Vector3(0.5f * playAreaSizeX - 0.25f, 0f, 0.5f * playAreaSizeZ - 0.25f);
this.playAreaPreviewCorners[1].localPosition = new Vector3(0.5f * playAreaSizeX - 0.25f, 0f, -0.5f * playAreaSizeZ + 0.25f);
this.playAreaPreviewCorners[2].localPosition = new Vector3(-0.5f * playAreaSizeX + 0.25f, 0f, -0.5f * playAreaSizeZ + 0.25f);
this.playAreaPreviewCorners[3].localPosition = new Vector3(-0.5f * playAreaSizeX + 0.25f, 0f, 0.5f * playAreaSizeZ - 0.25f);
this.playAreaPreviewCorners[0].localRotation = Quaternion.Euler(0f, 0f, 0f);
this.playAreaPreviewCorners[1].localRotation = Quaternion.Euler(0f, 90f, 0f);
this.playAreaPreviewCorners[2].localRotation = Quaternion.Euler(0f, 180f, 0f);
this.playAreaPreviewCorners[3].localRotation = Quaternion.Euler(0f, 270f, 0f);
this.playAreaPreviewTransform.gameObject.SetActive(false);
}
}
private void ShowController()
{
if (this.hand == null || this.hand.controller == null)
{
return;
}
for (int i = 0; i < this.renderModels.Length; i++)
{
if (this.renderModels[i] == null)
{
this.renderModels[i] = new GameObject("SteamVR_RenderModel").AddComponent <SteamVR_RenderModel>();
this.renderModels[i].updateDynamically = false;
this.renderModels[i].transform.parent = base.transform;
Util.ResetTransform(this.renderModels[i].transform, true);
}
this.renderModels[i].gameObject.SetActive(true);
this.renderModels[i].SetDeviceIndex((int)this.hand.controller.index);
}
}
private GameObject InstantiateArrow()
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.arrowPrefab, this.arrowNockTransform.position, this.arrowNockTransform.rotation);
gameObject.name = "Bow Arrow";
gameObject.transform.parent = this.arrowNockTransform;
Util.ResetTransform(gameObject.transform, true);
this.arrowList.Add(gameObject);
while (this.arrowList.Count > this.maxArrowCount)
{
GameObject gameObject2 = this.arrowList[0];
this.arrowList.RemoveAt(0);
if (gameObject2)
{
UnityEngine.Object.Destroy(gameObject2);
}
}
return(gameObject);
}
//-------------------------------------------------
private void ShowController()
{
if (hand == null || hand.controller == null)
{
return;
}
for (int i = 0; i < renderModels.Length; i++)
{
if (renderModels[i] == null)
{
renderModels[i] = new GameObject("SteamVR_RenderModel").AddComponent <SteamVR_RenderModel>();
renderModels[i].updateDynamically = false; // Update one per frame (see Update() method)
renderModels[i].transform.parent = transform;
Util.ResetTransform(renderModels[i].transform);
}
renderModels[i].gameObject.SetActive(true);
renderModels[i].SetDeviceIndex((int)hand.controller.index);
}
}
//-------------------------------------------------
private GameObject InstantiateArrow()
{
UnityEngine.GameObject arrow = Instantiate(arrowPrefab, arrowNockTransform.position, arrowNockTransform.rotation) as UnityEngine.GameObject;
arrow.name = "Bow Arrow";
arrow.transform.parent = arrowNockTransform;
Util.ResetTransform(arrow.transform);
arrowList.Add(arrow);
while (arrowList.Count > maxArrowCount)
{
UnityEngine.GameObject oldArrow = arrowList[0];
arrowList.RemoveAt(0);
if (oldArrow)
{
Destroy(oldArrow);
}
}
return(arrow);
}
private GameObject InstantiateArrow()
{
GameObject arrow = Instantiate(arrowHand.arrowPrefab, arrowHand.arrowNockTransform.position, arrowHand.arrowNockTransform.rotation) as GameObject;
arrow.name = "Bow Arrow";
arrow.transform.parent = arrowHand.arrowNockTransform;
Util.ResetTransform(arrow.transform);
// arrowList.Add( arrow );
// while ( arrowList.Count > maxArrowCount )
// {
// GameObject oldArrow = arrowList[0];
// arrowList.RemoveAt( 0 );
// if ( oldArrow )
// {
// Destroy( oldArrow );
// }
// }
return(arrow);
}
public void NockArrow(Inventory linkedInventory) //, ArrowHand arrowHand) {
{
Debug.LogError("nocked");
// If arrow is close enough to the nock position and we're pressing the trigger, and we're not nocked yet, Nock
if (inNockRange && !nocked)
{
if (arrowHand.currentArrow == null)
{
arrowHand.currentArrow = InstantiateArrow();
}
// nocked = true;
StartNock( ); //arrowHand );
linkedInventory.GetComponent <Interactor>().HoverLock(null); // arrowhand.GetComponent<Interactable>() );
arrowHand.currentArrow.transform.parent = nockTransform;
Util.ResetTransform(arrowHand.currentArrow.transform);
Util.ResetTransform(arrowHand.arrowNockTransform);
}
}
public void AttemptArrowFire(Inventory linkedInventory)
{
if (nocked)
{
if (pulled) // If bow is pulled back far enough, fire arrow, otherwise reset arrow in arrowhand
{
FireArrow();
}
else
{
arrowHand.arrowNockTransform.rotation = arrowHand.currentArrow.transform.rotation;
arrowHand.currentArrow.transform.parent = arrowHand.arrowNockTransform;
Util.ResetTransform(arrowHand.currentArrow.transform);
nocked = false;
ReleaseNock();
linkedInventory.GetComponent <Interactor>().HoverUnlock(null); //arrowhand.GetComponent<Interactable>() );
}
// Arrow is releasing from the bow, tell the bow to lerp back to controller rotation
StartRotationLerp();
}
}
//-------------------------------------------------
private void OnChaperoneInfoInitialized()
{
ChaperoneInfo chaperone = ChaperoneInfo.instance;
if (chaperone.initialized && chaperone.roomscale)
{
//Set up the render model for the play area bounds
if (playAreaPreviewTransform == null)
{
playAreaPreviewTransform = new GameObject("PlayAreaPreviewTransform").transform;
playAreaPreviewTransform.parent = transform;
Util.ResetTransform(playAreaPreviewTransform);
playAreaPreviewCorner.SetActive(true);
playAreaPreviewCorners = new Transform[4];
playAreaPreviewCorners[0] = playAreaPreviewCorner.transform;
playAreaPreviewCorners[1] = Instantiate(playAreaPreviewCorners[0]);
playAreaPreviewCorners[2] = Instantiate(playAreaPreviewCorners[0]);
playAreaPreviewCorners[3] = Instantiate(playAreaPreviewCorners[0]);
playAreaPreviewCorners[0].transform.parent = playAreaPreviewTransform;
playAreaPreviewCorners[1].transform.parent = playAreaPreviewTransform;
playAreaPreviewCorners[2].transform.parent = playAreaPreviewTransform;
playAreaPreviewCorners[3].transform.parent = playAreaPreviewTransform;
playAreaPreviewSide.SetActive(true);
playAreaPreviewSides = new Transform[4];
playAreaPreviewSides[0] = playAreaPreviewSide.transform;
playAreaPreviewSides[1] = Instantiate(playAreaPreviewSides[0]);
playAreaPreviewSides[2] = Instantiate(playAreaPreviewSides[0]);
playAreaPreviewSides[3] = Instantiate(playAreaPreviewSides[0]);
playAreaPreviewSides[0].transform.parent = playAreaPreviewTransform;
playAreaPreviewSides[1].transform.parent = playAreaPreviewTransform;
playAreaPreviewSides[2].transform.parent = playAreaPreviewTransform;
playAreaPreviewSides[3].transform.parent = playAreaPreviewTransform;
}
float x = chaperone.playAreaSizeX;
float z = chaperone.playAreaSizeZ;
playAreaPreviewSides[0].localPosition = new Vector3(0.0f, 0.0f, 0.5f * z - 0.25f);
playAreaPreviewSides[1].localPosition = new Vector3(0.0f, 0.0f, -0.5f * z + 0.25f);
playAreaPreviewSides[2].localPosition = new Vector3(0.5f * x - 0.25f, 0.0f, 0.0f);
playAreaPreviewSides[3].localPosition = new Vector3(-0.5f * x + 0.25f, 0.0f, 0.0f);
playAreaPreviewSides[0].localScale = new Vector3(x - 0.5f, 1.0f, 1.0f);
playAreaPreviewSides[1].localScale = new Vector3(x - 0.5f, 1.0f, 1.0f);
playAreaPreviewSides[2].localScale = new Vector3(z - 0.5f, 1.0f, 1.0f);
playAreaPreviewSides[3].localScale = new Vector3(z - 0.5f, 1.0f, 1.0f);
playAreaPreviewSides[0].localRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
playAreaPreviewSides[1].localRotation = Quaternion.Euler(0.0f, 180.0f, 0.0f);
playAreaPreviewSides[2].localRotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);
playAreaPreviewSides[3].localRotation = Quaternion.Euler(0.0f, 270.0f, 0.0f);
playAreaPreviewCorners[0].localPosition = new Vector3(0.5f * x - 0.25f, 0.0f, 0.5f * z - 0.25f);
playAreaPreviewCorners[1].localPosition = new Vector3(0.5f * x - 0.25f, 0.0f, -0.5f * z + 0.25f);
playAreaPreviewCorners[2].localPosition = new Vector3(-0.5f * x + 0.25f, 0.0f, -0.5f * z + 0.25f);
playAreaPreviewCorners[3].localPosition = new Vector3(-0.5f * x + 0.25f, 0.0f, 0.5f * z - 0.25f);
playAreaPreviewCorners[0].localRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
playAreaPreviewCorners[1].localRotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);
playAreaPreviewCorners[2].localRotation = Quaternion.Euler(0.0f, 180.0f, 0.0f);
playAreaPreviewCorners[3].localRotation = Quaternion.Euler(0.0f, 270.0f, 0.0f);
playAreaPreviewTransform.gameObject.SetActive(false);
}
}
//-------------------------------------------------
private void HandAttachedUpdate(Hand hand)
{
if (bow == null)
{
FindBow();
}
if (bow == null)
{
return;
}
if (allowArrowSpawn && (currentArrow == null)) // If we're allowed to have an active arrow in hand but don't yet, spawn one
{
currentArrow = InstantiateArrow();
arrowSpawnSound.Play();
}
var distanceToNockPosition = Vector3.Distance(transform.parent.position, bow.nockTransform.position);
// If there's an arrow spawned in the hand and it's not nocked yet
if (!nocked)
{
// If we're close enough to nock position that we want to start arrow rotation lerp, do so
if (distanceToNockPosition < rotationLerpThreshold)
{
var lerp = Util.RemapNumber(distanceToNockPosition, rotationLerpThreshold, lerpCompleteDistance, 0, 1);
arrowNockTransform.rotation = Quaternion.Lerp(arrowNockTransform.parent.rotation, bow.nockRestTransform.rotation, lerp);
}
else // Not close enough for rotation lerp, reset rotation
{
arrowNockTransform.localRotation = Quaternion.identity;
}
// If we're close enough to the nock position that we want to start arrow position lerp, do so
if (distanceToNockPosition < positionLerpThreshold)
{
var posLerp = Util.RemapNumber(distanceToNockPosition, positionLerpThreshold, lerpCompleteDistance, 0, 1);
posLerp = Mathf.Clamp(posLerp, 0f, 1f);
arrowNockTransform.position = Vector3.Lerp(arrowNockTransform.parent.position, bow.nockRestTransform.position, posLerp);
}
else // Not close enough for position lerp, reset position
{
arrowNockTransform.position = arrowNockTransform.parent.position;
}
// Give a haptic tick when lerp is visually complete
if (distanceToNockPosition < lerpCompleteDistance)
{
if (!arrowLerpComplete)
{
arrowLerpComplete = true;
hand.controller.TriggerHapticPulse(500);
}
}
else
{
if (arrowLerpComplete)
{
arrowLerpComplete = false;
}
}
// Allow nocking the arrow when controller is close enough
if (distanceToNockPosition < nockDistance)
{
if (!inNockRange)
{
inNockRange = true;
bow.ArrowInPosition();
}
}
else
{
if (inNockRange)
{
inNockRange = false;
}
}
// If arrow is close enough to the nock position and we're pressing the trigger, and we're not nocked yet, Nock
if ((distanceToNockPosition < nockDistance) && hand.controller.GetPress(SteamVR_Controller.ButtonMask.Trigger) && !nocked)
{
if (currentArrow == null)
{
currentArrow = InstantiateArrow();
}
nocked = true;
bow.StartNock(this);
hand.HoverLock(GetComponent <Interactable>());
allowTeleport.teleportAllowed = false;
currentArrow.transform.parent = bow.nockTransform;
Util.ResetTransform(currentArrow.transform);
Util.ResetTransform(arrowNockTransform);
}
}
// If arrow is nocked, and we release the trigger
if (nocked && (!hand.controller.GetPress(SteamVR_Controller.ButtonMask.Trigger) || hand.controller.GetPressUp(SteamVR_Controller.ButtonMask.Trigger)))
{
if (bow.pulled) // If bow is pulled back far enough, fire arrow, otherwise reset arrow in arrowhand
{
FireArrow();
}
else
{
arrowNockTransform.rotation = currentArrow.transform.rotation;
currentArrow.transform.parent = arrowNockTransform;
Util.ResetTransform(currentArrow.transform);
nocked = false;
bow.ReleaseNock();
hand.HoverUnlock(GetComponent <Interactable>());
allowTeleport.teleportAllowed = true;
}
bow.StartRotationLerp(); // Arrow is releasing from the bow, tell the bow to lerp back to controller rotation
}
}
private void HandAttachedUpdate(Hand hand)
{
if (this.bow == null)
{
this.FindBow();
}
if (this.bow == null)
{
return;
}
if (this.allowArrowSpawn && this.currentArrow == null)
{
this.currentArrow = this.InstantiateArrow();
this.arrowSpawnSound.Play();
}
float num = Vector3.Distance(base.transform.parent.position, this.bow.nockTransform.position);
if (!this.nocked)
{
if (num < this.rotationLerpThreshold)
{
float t = Util.RemapNumber(num, this.rotationLerpThreshold, this.lerpCompleteDistance, 0f, 1f);
this.arrowNockTransform.rotation = Quaternion.Lerp(this.arrowNockTransform.parent.rotation, this.bow.nockRestTransform.rotation, t);
}
else
{
this.arrowNockTransform.localRotation = Quaternion.identity;
}
if (num < this.positionLerpThreshold)
{
float num2 = Util.RemapNumber(num, this.positionLerpThreshold, this.lerpCompleteDistance, 0f, 1f);
num2 = Mathf.Clamp(num2, 0f, 1f);
this.arrowNockTransform.position = Vector3.Lerp(this.arrowNockTransform.parent.position, this.bow.nockRestTransform.position, num2);
}
else
{
this.arrowNockTransform.position = this.arrowNockTransform.parent.position;
}
if (num < this.lerpCompleteDistance)
{
if (!this.arrowLerpComplete)
{
this.arrowLerpComplete = true;
hand.controller.TriggerHapticPulse(500, EVRButtonId.k_EButton_Axis0);
}
}
else if (this.arrowLerpComplete)
{
this.arrowLerpComplete = false;
}
if (num < this.nockDistance)
{
if (!this.inNockRange)
{
this.inNockRange = true;
this.bow.ArrowInPosition();
}
}
else if (this.inNockRange)
{
this.inNockRange = false;
}
if (num < this.nockDistance && hand.controller.GetPress(8589934592UL) && !this.nocked)
{
if (this.currentArrow == null)
{
this.currentArrow = this.InstantiateArrow();
}
this.nocked = true;
this.bow.StartNock(this);
hand.HoverLock(base.GetComponent <Interactable>());
this.allowTeleport.teleportAllowed = false;
this.currentArrow.transform.parent = this.bow.nockTransform;
Util.ResetTransform(this.currentArrow.transform, true);
Util.ResetTransform(this.arrowNockTransform, true);
}
}
if (this.nocked && (!hand.controller.GetPress(8589934592UL) || hand.controller.GetPressUp(8589934592UL)))
{
if (this.bow.pulled)
{
this.FireArrow();
}
else
{
this.arrowNockTransform.rotation = this.currentArrow.transform.rotation;
this.currentArrow.transform.parent = this.arrowNockTransform;
Util.ResetTransform(this.currentArrow.transform, true);
this.nocked = false;
this.bow.ReleaseNock();
hand.HoverUnlock(base.GetComponent <Interactable>());
this.allowTeleport.teleportAllowed = true;
}
this.bow.StartRotationLerp();
}
}
//-------------------------------------------------
private void HandAttachedUpdate(Hand hand)
{
if (_bow == null)
{
FindBow();
}
if (_bow == null)
{
return;
}
if (allowArrowSpawn && (_currentArrow == null)) // If we're allowed to have an active arrow in hand but don't yet, spawn one
{
InstantiateAndSetArrow();
arrowSpawnSound.Play();
}
float distanceToNockPosition = Vector3.Distance(transform.parent.position, _bow.nockTransform.position);
// If there's an arrow spawned in the hand and it's not nocked yet
if (!nocked)
{
// If we're close enough to nock position that we want to start arrow rotation lerp, do so
if (distanceToNockPosition < rotationLerpThreshold)
{
float lerp = Util.RemapNumber(distanceToNockPosition, rotationLerpThreshold, lerpCompleteDistance, 0, 1);
ArrowNockTransform.rotation = Quaternion.Lerp(ArrowNockTransform.parent.rotation, _bow.nockRestTransform.rotation, lerp);
}
else // Not close enough for rotation lerp, reset rotation
{
ArrowNockTransform.localRotation = Quaternion.identity;
}
// If we're close enough to the nock position that we want to start arrow position lerp, do so
if (distanceToNockPosition < positionLerpThreshold)
{
float posLerp = Util.RemapNumber(distanceToNockPosition, positionLerpThreshold, lerpCompleteDistance, 0, 1);
posLerp = Mathf.Clamp(posLerp, 0f, 1f);
ArrowNockTransform.position = Vector3.Lerp(ArrowNockTransform.parent.position, _bow.nockRestTransform.position, posLerp);
}
else // Not close enough for position lerp, reset position
{
ArrowNockTransform.position = ArrowNockTransform.parent.position;
}
// Give a haptic tick when lerp is visually complete
if (distanceToNockPosition < lerpCompleteDistance)
{
if (!arrowLerpComplete)
{
arrowLerpComplete = true;
hand.TriggerHapticPulse(500);
}
}
else if (arrowLerpComplete)
{
arrowLerpComplete = false;
}
// Allow nocking the arrow when controller is close enough
if (distanceToNockPosition < nockDistance)
{
if (!inNockRange)
{
inNockRange = true;
_bow.ArrowInPosition();
}
}
else if (inNockRange)
{
inNockRange = false;
}
GrabTypes bestGrab = hand.GetBestGrabbingType(GrabTypes.Pinch, true);
// If arrow is close enough to the nock position and we're pressing the trigger, and we're not nocked yet, Nock
if ((distanceToNockPosition < nockDistance) && bestGrab != GrabTypes.None && !nocked)
{
if (_currentArrow == null)
{
InstantiateAndSetArrow();
}
nocked = true;
nockedWithType = bestGrab;
_bow.StartNock(this);
hand.HoverLock(GetComponent <Interactable>());
_currentArrow.transform.parent = _bow.nockTransform;
Util.ResetTransform(_currentArrow.transform);
Util.ResetTransform(ArrowNockTransform);
}
}
if (_currentArrowCmpt != null)
{
_currentArrowCmpt.Charging = nocked && _bow.pulled;
}
// If arrow is nocked, and we release the trigger
if (nocked)
{
if (hand.IsGrabbingWithType(nockedWithType) == false)
{
if (_bow.pulled) // If bow is pulled back far enough, fire arrow, otherwise reset arrow in arrowhand
{
FireArrow();
}
else
{
ArrowNockTransform.rotation = _currentArrow.transform.rotation;
_currentArrow.transform.parent = ArrowNockTransform;
Util.ResetTransform(_currentArrow.transform);
nocked = false;
nockedWithType = GrabTypes.None;
_bow.ReleaseNock();
hand.HoverUnlock(GetComponent <Interactable>());
}
_bow.StartRotationLerp(); // Arrow is releasing from the bow, tell the bow to lerp back to controller rotation
}
}
}
//-------------------------------------------------
private void HandAttachedUpdate(Hand hand)
{
//quiver.GetComponent<Quiver>().
//Debug.Log("update");
if (bow == null)
{
FindBow();
}
if (bow == null)
{
return;
}
float distanceToNockPosition = Vector3.Distance(transform.parent.position, bow.nockTransform.position);
int quiverType = quiverSelection.GetComponent <Dropdown>().value + 1;
switch (quiverType)
{
case 1:
quiver = GameObject.Find("Quiver (Neck)");
break;
case 2:
quiver = GameObject.Find("Quiver (Shoulder)");
break;
case 3:
quiver = GameObject.Find("Quiver (Chest)");
break;
default:
print("Oops");
break;
}
noQuiver = quiverEnable.GetComponent <Toggle>().isOn;
if (allowArrowSpawn && (currentArrow == null) && ((noQuiver || quiver.GetComponent <Interactable>().isHovering))) // If we're allowed to have an active arrow in hand but don't yet, spawn one
{
currentArrow = InstantiateArrow();
arrowSpawnSound.Play();
hand.TriggerHapticPulse(5000);
}
// If there's an arrow spawned in the hand and it's not nocked yet
else if ((currentArrow != null) && !nocked)
{
// If we're close enough to nock position that we want to start arrow rotation lerp, do so
if (distanceToNockPosition < rotationLerpThreshold)
{
float lerp = Util.RemapNumber(distanceToNockPosition, rotationLerpThreshold, lerpCompleteDistance, 0, 1);
arrowNockTransform.rotation = Quaternion.Lerp(arrowNockTransform.parent.rotation, bow.nockRestTransform.rotation, lerp);
}
else // Not close enough for rotation lerp, reset rotation
{
arrowNockTransform.localRotation = Quaternion.identity;
}
// If we're close enough to the nock position that we want to start arrow position lerp, do so
if (distanceToNockPosition < positionLerpThreshold)
{
float posLerp = Util.RemapNumber(distanceToNockPosition, positionLerpThreshold, lerpCompleteDistance, 0, 1);
posLerp = Mathf.Clamp(posLerp, 0f, 1f);
arrowNockTransform.position = Vector3.Lerp(arrowNockTransform.parent.position, bow.nockRestTransform.position, posLerp);
}
else // Not close enough for position lerp, reset position
{
arrowNockTransform.position = arrowNockTransform.parent.position;
}
// Give a haptic tick when lerp is visually complete
if (distanceToNockPosition < lerpCompleteDistance)
{
if (!arrowLerpComplete)
{
arrowLerpComplete = true;
hand.TriggerHapticPulse(500);
}
}
else
{
if (arrowLerpComplete)
{
arrowLerpComplete = false;
}
}
// Allow nocking the arrow when controller is close enough
if (distanceToNockPosition < nockDistance)
{
if (!inNockRange)
{
inNockRange = true;
bow.ArrowInPosition();
}
}
else
{
if (inNockRange)
{
inNockRange = false;
}
}
GrabTypes bestGrab = hand.GetBestGrabbingType(GrabTypes.Pinch, true);
// If arrow is close enough to the nock position and we're pressing the trigger, and we're not nocked yet, Nock
if ((distanceToNockPosition < nockDistance) && bestGrab != GrabTypes.None && !nocked)
{
if (currentArrow == null)
{
currentArrow = InstantiateArrow();
}
nocked = true;
nockedWithType = bestGrab;
bow.StartNock(this);
hand.HoverLock(GetComponent <Interactable>());
allowTeleport.teleportAllowed = false;
currentArrow.transform.parent = bow.nockTransform;
Util.ResetTransform(currentArrow.transform);
Util.ResetTransform(arrowNockTransform);
}
}
// If arrow is nocked, and we release the trigger
if (nocked && hand.IsGrabbingWithType(nockedWithType) == false)
{
if (bow.pulled) // If bow is pulled back far enough, fire arrow, otherwise reset arrow in arrowhand
{
FireArrow();
}
else
{
arrowNockTransform.rotation = currentArrow.transform.rotation;
currentArrow.transform.parent = arrowNockTransform;
Util.ResetTransform(currentArrow.transform);
nocked = false;
nockedWithType = GrabTypes.None;
bow.ReleaseNock();
hand.HoverUnlock(GetComponent <Interactable>());
allowTeleport.teleportAllowed = true;
}
bow.StartRotationLerp(); // Arrow is releasing from the bow, tell the bow to lerp back to controller rotation
}
}
