Initialer Upload neues Unity-Projekt

Assets/SteamVR/InteractionSystem/Longbow/Scripts/Arrow.cs

@@ -0,0 +1,263 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: The arrow for the longbow
+//
+//=============================================================================
+
+using UnityEngine;
+using System.Collections;
+
+namespace Valve.VR.InteractionSystem
+{
+	//-------------------------------------------------------------------------
+	public class Arrow : MonoBehaviour
+	{
+		public ParticleSystem glintParticle;
+		public Rigidbody arrowHeadRB;
+		public Rigidbody shaftRB;
+
+		public PhysicMaterial targetPhysMaterial;
+
+		private Vector3 prevPosition;
+		private Quaternion prevRotation;
+		private Vector3 prevVelocity;
+		private Vector3 prevHeadPosition;
+
+		public SoundPlayOneshot fireReleaseSound;
+		public SoundPlayOneshot airReleaseSound;
+		public SoundPlayOneshot hitTargetSound;
+
+		public PlaySound hitGroundSound;
+
+		private bool inFlight;
+		private bool released;
+		private bool hasSpreadFire = false;
+
+		private int travelledFrames = 0;
+
+		private GameObject scaleParentObject = null;
+
+
+		//-------------------------------------------------
+		void Start()
+		{
+			Physics.IgnoreCollision( shaftRB.GetComponent<Collider>(), Player.instance.headCollider );
+		}
+
+
+		//-------------------------------------------------
+		void FixedUpdate()
+		{
+			if ( released && inFlight )
+			{
+				prevPosition = transform.position;
+				prevRotation = transform.rotation;
+				prevVelocity = GetComponent<Rigidbody>().velocity;
+				prevHeadPosition = arrowHeadRB.transform.position;
+				travelledFrames++;
+			}
+		}
+
+
+		//-------------------------------------------------
+		public void ArrowReleased( float inputVelocity )
+		{
+			inFlight = true;
+			released = true;
+
+			airReleaseSound.Play();
+
+			if ( glintParticle != null )
+			{
+				glintParticle.Play();
+			}
+
+			if ( gameObject.GetComponentInChildren<FireSource>().isBurning )
+			{
+				fireReleaseSound.Play();
+			}
+
+			// Check if arrow is shot inside or too close to an object
+			RaycastHit[] hits = Physics.SphereCastAll( transform.position, 0.01f, transform.forward, 0.80f, Physics.DefaultRaycastLayers, QueryTriggerInteraction.Ignore );
+			foreach ( RaycastHit hit in hits )
+			{
+				if ( hit.collider.gameObject != gameObject && hit.collider.gameObject != arrowHeadRB.gameObject && hit.collider != Player.instance.headCollider )
+				{
+					Destroy( gameObject );
+					return;
+				}
+			}
+
+			travelledFrames = 0;
+			prevPosition = transform.position;
+			prevRotation = transform.rotation;
+			prevHeadPosition = arrowHeadRB.transform.position;
+			prevVelocity = GetComponent<Rigidbody>().velocity;
+
+			Destroy( gameObject, 30 );
+		}
+
+
+		//-------------------------------------------------
+		void OnCollisionEnter( Collision collision )
+		{
+			if ( inFlight )
+			{
+				Rigidbody rb = GetComponent<Rigidbody>();
+				float rbSpeed = rb.velocity.sqrMagnitude;
+				bool canStick = ( targetPhysMaterial != null && collision.collider.sharedMaterial == targetPhysMaterial && rbSpeed > 0.2f );
+				bool hitBalloon = collision.collider.gameObject.GetComponent<Balloon>() != null;
+
+				if ( travelledFrames < 2 && !canStick )
+				{
+					// Reset transform but halve your velocity
+					transform.position = prevPosition - prevVelocity * Time.deltaTime;
+					transform.rotation = prevRotation;
+
+					Vector3 reflfectDir = Vector3.Reflect( arrowHeadRB.velocity, collision.contacts[0].normal );
+					arrowHeadRB.velocity = reflfectDir * 0.25f;
+					shaftRB.velocity = reflfectDir * 0.25f;
+
+					travelledFrames = 0;
+					return;
+				}
+
+				if ( glintParticle != null )
+				{
+					glintParticle.Stop( true );
+				}
+
+				// Only play hit sounds if we're moving quickly
+				if ( rbSpeed > 0.1f )
+				{
+					hitGroundSound.Play();
+				}
+
+				FireSource arrowFire = gameObject.GetComponentInChildren<FireSource>();
+				FireSource fireSourceOnTarget = collision.collider.GetComponentInParent<FireSource>();
+
+				if ( arrowFire != null && arrowFire.isBurning && ( fireSourceOnTarget != null ) )
+				{
+					if ( !hasSpreadFire )
+					{
+						collision.collider.gameObject.SendMessageUpwards( "FireExposure", gameObject, SendMessageOptions.DontRequireReceiver );
+						hasSpreadFire = true;
+					}
+				}
+				else
+				{
+					// Only count collisions with good speed so that arrows on the ground can't deal damage
+					// always pop balloons
+					if ( rbSpeed > 0.1f || hitBalloon )
+					{
+						collision.collider.gameObject.SendMessageUpwards( "ApplyDamage", SendMessageOptions.DontRequireReceiver );
+						gameObject.SendMessage( "HasAppliedDamage", SendMessageOptions.DontRequireReceiver );
+					}
+				}
+
+				if ( hitBalloon )
+				{
+					// Revert my physics properties cause I don't want balloons to influence my travel
+					transform.position = prevPosition;
+					transform.rotation = prevRotation;
+					arrowHeadRB.velocity = prevVelocity;
+					Physics.IgnoreCollision( arrowHeadRB.GetComponent<Collider>(), collision.collider );
+					Physics.IgnoreCollision( shaftRB.GetComponent<Collider>(), collision.collider );
+				}
+
+				if ( canStick )
+				{
+					StickInTarget( collision, travelledFrames < 2 );
+				}
+
+				// Player Collision Check (self hit)
+				if ( Player.instance && collision.collider == Player.instance.headCollider )
+				{
+					Player.instance.PlayerShotSelf();
+				}
+			}
+		}
+
+
+		//-------------------------------------------------
+		private void StickInTarget( Collision collision, bool bSkipRayCast )
+		{
+			Vector3 prevForward = prevRotation * Vector3.forward;
+
+			// Only stick in target if the collider is front of the arrow head
+			if ( !bSkipRayCast )
+			{
+				RaycastHit[] hitInfo;
+				hitInfo = Physics.RaycastAll( prevHeadPosition - prevVelocity * Time.deltaTime, prevForward, prevVelocity.magnitude * Time.deltaTime * 2.0f );
+				bool properHit = false;
+				for ( int i = 0; i < hitInfo.Length; ++i )
+				{
+					RaycastHit hit = hitInfo[i];
+
+					if ( hit.collider == collision.collider )
+					{
+						properHit = true;
+						break;
+					}
+				}
+
+				if ( !properHit )
+				{
+					return;
+				}
+			}
+
+			Destroy( glintParticle );
+
+			inFlight = false;
+
+			shaftRB.velocity = Vector3.zero;
+			shaftRB.angularVelocity = Vector3.zero;
+			shaftRB.isKinematic = true;
+			shaftRB.useGravity = false;
+			shaftRB.transform.GetComponent<BoxCollider>().enabled = false;
+
+			arrowHeadRB.velocity = Vector3.zero;
+			arrowHeadRB.angularVelocity = Vector3.zero;
+			arrowHeadRB.isKinematic = true;
+			arrowHeadRB.useGravity = false;
+			arrowHeadRB.transform.GetComponent<BoxCollider>().enabled = false;
+
+			hitTargetSound.Play();
+
+
+			// If the hit item has a parent, dock an empty object to that
+			// this fixes an issue with scaling hierarchy. I suspect this is not sustainable for a large object / scaling hierarchy.
+			scaleParentObject = new GameObject( "Arrow Scale Parent" );
+			Transform parentTransform = collision.collider.transform;
+
+			// Don't do this for weebles because of how it has a fixed joint
+			ExplosionWobble wobble = collision.collider.gameObject.GetComponent<ExplosionWobble>();
+			if ( !wobble )
+			{
+				if ( parentTransform.parent )
+				{
+					parentTransform = parentTransform.parent;
+				}
+			}
+
+			scaleParentObject.transform.parent = parentTransform;
+
+			// Move the arrow to the place on the target collider we were expecting to hit prior to the impact itself knocking it around
+			transform.parent = scaleParentObject.transform;
+			transform.rotation = prevRotation;
+			transform.position = prevPosition;
+			transform.position = collision.contacts[0].point - transform.forward * ( 0.75f - ( Util.RemapNumberClamped( prevVelocity.magnitude, 0f, 10f, 0.0f, 0.1f ) + Random.Range( 0.0f, 0.05f ) ) );
+		}
+
+
+		//-------------------------------------------------
+		void OnDestroy()
+		{
+			if ( scaleParentObject != null )
+			{
+				Destroy( scaleParentObject );
+			}
+		}
+	}
+}