yichael_smartbow/Assets/MeiShu Asset/BowAsset/Scripts/BowControlLegacy.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using UnityStandardAssets.Characters.FirstPerson;

public class BowControlLegacy : WeaponsBaseLegacy
{
	#region Fields

	[SerializeField] bool useSmooth = true;
	[Range (1f, 10f)]
	[SerializeField] float aimSmooth;
	[Range(1, 179)]
	[SerializeField] float aimFov = 35;
	float defaultFov;
	float currentFov;

	[HideInInspector] public float baseSpread = 1.0f;  
	public float maxSpread = 4.0f; 
	private float defaultSpread;
	private float defaultMaxSpread;

	public GameObject arrow = null;
	public Transform mountPoint = null;    
	public GameObject attachedArrow = null;

	bool isFiring = false;  

	// basic stats
	public int range = 300; 
	public float damage = 20.0f;
	public float maxPenetration = 3.0f;
	public float fireRate = 0.5f; 
	public int impactForce = 50;   
	public float arrowSpeed = 60.0f;  

	bool isLoaded = false;

	#endregion

	protected override void Awake ()
	{
		base.Awake ();
		defaultSpread = baseSpread;
		defaultMaxSpread = maxSpread;
	}
		
	protected override void Start ()
	{
		base.Start ();
		defaultFov = Camera.main.fieldOfView;
		canAim = true;
	}

	protected override void InputUpdate()
	{
		if (Input.GetMouseButton (1) && CanAim)
		{
			isAimed = true;

			if (!isFiring)
				EmptySlot (false);

			if (Input.GetMouseButtonDown (0) && CanFire && isLoaded)
			{
				isFiring = true;
				StartCoroutine (Fire ());  
			}
		}
		else
		{
			isAimed = false;
			isLoaded = false;
		}
	}

	protected override void SyncState()
	{
		if (isAimed && !isLoaded && !isFiring && !disableWeapon)
		{
			if (playerSync) 
			{
				if (playerSync.WpState != WeaponState.PrepareAiming) 
				{
					playerSync.WpState = WeaponState.PrepareAiming;
					StartCoroutine (LoadArrow ());
				}
			}
		}
		else if (isAimed && isLoaded && !isFiring && !disableWeapon)
		{
			if (playerSync) 
			{
				if (playerSync.WpState != WeaponState.AimedIdle) 
				{
					playerSync.WpState = WeaponState.AimedIdle;
					PlayWeaponAnimation (weaponAnimations.Weapon_ADS_Idle.name, WrapMode.Loop);
				}
			}
		}
		else if (isAimed && isFiring && !disableWeapon)
		{
			if (playerSync) 
			{
				if (playerSync.WpState != WeaponState.AimedFiring) {
					playerSync.WpState = WeaponState.AimedFiring;
				}
			}
		}
		else if (disableWeapon)
		{
			if (playerSync)
			{
				playerSync.WpState = WeaponState.Lowering;
			}
		}
		else if (controller.IsRunning && !disableWeapon && !isFiring && !isAimed)
		{
			if (playerSync)
			{
				playerSync.WpState = WeaponState.Running;
			}
		}
		else if (controller.IsWalking && !disableWeapon && !isFiring && !isAimed)
		{
			if (playerSync)
			{
				playerSync.WpState = WeaponState.Walking;
				PlayWeaponAnimation (weaponAnimations.Weapon_Idle.name, WrapMode.Loop);
			}
		}
		else
		{
			if (playerSync) 
			{
				if (playerSync.WpState != WeaponState.Idle) 
				{
					playerSync.WpState = WeaponState.Idle;
					PlayWeaponAnimation (weaponAnimations.Weapon_Idle.name, WrapMode.Loop);
				}
			}
		}
	}

	protected override void Aim()
	{
		if (isAimed)
		{
			currentFov = aimFov;
			baseSpread = defaultSpread / 2f; 
			maxSpread = defaultMaxSpread / 2f;
		}
		else 
		{      
			currentFov = defaultFov;
			baseSpread = defaultSpread;
			maxSpread = defaultMaxSpread;
		}
		Camera.main.fieldOfView = useSmooth ? 
			Mathf.Lerp(Camera.main.fieldOfView, currentFov, Time.deltaTime * (aimSmooth * 3)) : //apply fog distance
			Mathf.Lerp(Camera.main.fieldOfView, currentFov, Time.deltaTime * aimSmooth);
	}

	IEnumerator Fire()
	{
		StartCoroutine (FireOneShot());
		EmptySlot (true);
		isLoaded = false;
		Source.clip = FireSound;
		Source.spread = Random.Range (1.0f, 1.5f);
		Source.pitch  = Random.Range (1.0f, 1.05f);
		Source.Play();
		PlayWeaponAnimation (weaponAnimations.Weapon_ADS_Fire.name, WrapMode.Once);
		yield return StartCoroutine (WaitAnimationFinish (weaponAnimations.Weapon_ADS_Fire));
		isFiring = false;
//		yield return null;
	}

	IEnumerator FireOneShot()
	{
		Vector3 position = mountPoint.position;

		// set the gun's info into an array to send to the bullet
		MissileInfo info = new MissileInfo();
		info.damage = damage;
		info.impactForce = impactForce;
		info.maxPenetration = maxPenetration;
		info.maxspread = maxSpread;
		info.speed = arrowSpeed;
		info.position = this.transform.root.position;
		info.lifeTime = range;

		Quaternion q = Quaternion.Euler (new Vector3 (0, transform.eulerAngles.y - 90f, -transform.eulerAngles.x));

		GameObject newArrow = Instantiate (arrow, position, q) as GameObject;
		newArrow.GetComponent<Missile>().SetUp(info);
//		newArrow.transform.RotateAround (newArrow.transform.position, newArrow.transform.right, 90f);
		newArrow.transform.RotateAround (newArrow.transform.position, newArrow.transform.forward, 90f);
		Source.clip = FireSound;
		Source.spread = Random.Range (1.0f, 1.5f);
		Source.Play();

		yield return null;
	}

	void EmptySlot (bool value)
	{
		if (value) 
			attachedArrow.SetActive (false);
		else
			attachedArrow.SetActive (true);
	}

	IEnumerator LoadArrow ()
	{
		PlayWeaponAnimation (weaponAnimations.Weapon_IdleToADS.name);
		yield return StartCoroutine (WaitAnimationFinish (weaponAnimations.Weapon_IdleToADS));
		isLoaded = true;
	}

	public override IEnumerator ReloadNormal()
	{
		PlayWeaponAnimation (weaponAnimations.Weapon_Reload.name, WrapMode.Once);
		EmptySlot (false);
		yield return StartCoroutine (WaitAnimationFinish (weaponAnimations.Weapon_Reload));
		isReloading = false;
		canAim = true;
		canFire = true;
	}

	public override void DisableWeapon()
	{
		canAim = false;
		isReloading = false;
		attachedArrow.SetActive (false);
		base.DisableWeapon ();
	}

	public bool CanReload
	{
		get
		{
			if (!isReloading) 
			{
				if (controller.IsWalking || controller.IsQuiet)
					return true;

				return false;
			}
			return false;
		}
	}
		
}	// class