Search Unity

  1. Welcome to the Unity Forums! Please take the time to read our Code of Conduct to familiarize yourself with the forum rules and how to post constructively.
  2. Unite 2023 Registrations are now LIVE! We are thrilled to announce that Unite 2023 Registration is now live and open for all!
    Dismiss Notice
New Forum User Notice Unite 2023 Registrations are now LIVE!

How to create single fire ?

Discussion in 'Scripting' started by ggsnip, Nov 28, 2014.

  1. ggsnip

    ggsnip

    Joined:
    Nov 28, 2014
    Posts:
    3
    Hi !:cool: i have a script for my weapon and i want insert a single fire in this script :
    Code (CSharp):
    1. using UnityEngine;
    2. using System.Collections;
    3.  
    4. [System.Serializable]
    5. public class ReloadSound
    6. {
    7.     public string name = "Mag out";
    8.     public AudioClip clip;
    9.     public float length;
    10. }
    11.  
    12. public class Weapon : MonoBehaviour
    13. {
    14.     public Animation anim;
    15.     public AnimationClip fireAnim;
    16.     public AnimationClip reloadAnim;
    17.     public AnimationClip reloadEmptyAnim;
    18.     public AnimationClip drawAnim;
    19.  
    20.     #region bools
    21.     public bool reloading;
    22.     public bool[] canAims;
    23.     private bool canAim;
    24.     public bool[] canReloads;
    25.     private bool canReload;
    26.     public bool[] canFires;
    27.     private bool canFire;
    28.     #endregion
    29.  
    30.     #region stats
    31.     public float fireRate = 0.1f;
    32.     public float timer = 0;
    33.     [SerializeField]
    34.     protected int bulletsLeft = 30;
    35.     [SerializeField]
    36.     protected int bulletsPerMag = 30;
    37.     [SerializeField]
    38.     protected int magsLeft = 10;
    39.     public float range = 2000;
    40.     public float damageMin = 10;
    41.     public float damageMax = 20;
    42.     public Transform bulletGo;
    43.     public LayerMask hitLayers;
    44.     public GameObject blood;
    45.     public GameObject concrete;
    46.     public GameObject wood;
    47.     public GameObject metal;
    48.     public GameObject dirt;
    49.     #endregion
    50.  
    51.     #region readOnly
    52.     public int bulletsLeftRead = 30;
    53.     public int bulletsPerMagRead = 30;
    54.     public int magsLeftRead = 10;
    55.     #endregion
    56.  
    57.  
    58.     #region components
    59.     public CharacterValues cv;
    60.     public PlayerAnimations pa;
    61.     #endregion
    62.  
    63.     #region sound
    64.     public AudioSource localSource;
    65.     public AudioClip fireSound;
    66.     public ReloadSound[] drawSound;
    67.     public ReloadSound[] reloadSounds;
    68.     public ReloadSound[] reloadSoundsEmpty;
    69.     #endregion
    70.  
    71.     #region ads
    72.     public Camera cam;
    73.     public bool aiming;
    74.     public float hipFov = 75;
    75.     public float aimFov = 55;
    76.     private float curFov = 75;
    77.     public Vector3 hipPos;
    78.     public Vector3 crouchPos;
    79.     public Vector3 aimPos;
    80.     private Vector3 curPos;
    81.     #endregion
    82.  
    83.     #region recoil
    84.     public Transform camKB;
    85.     public Transform wepKB;
    86.     public float minKB;
    87.     public float maxKB;
    88.     public float minKBSide;
    89.     public float maxKBSide;
    90.     public float returnSpeed = 5f;
    91.     #endregion
    92.  
    93.     #region muzzle
    94.     public GameObject muzzle;
    95.     #endregion
    96.  
    97.     #region crosshair
    98.     public float sizeMultiplier = 1f;
    99.     public float aimSpread;
    100.     public float basicSpread = 30;
    101.     public float maximumSpread = 100;
    102.     public float spreadReturnTime = 5;
    103.     public float spreadAddPerShot = 5;
    104.     public float spreadTemp;
    105.     private float spread = 30;
    106.  
    107.     //Crosshair Textures
    108.     public Texture2D crosshairFirstModeHorizontal;
    109.     public Texture2D crosshairFirstModeVertical;
    110.  
    111.     #endregion
    112.  
    113.     #region private
    114.     private Vector2 pivot;
    115.     #endregion
    116.  
    117.     #region hitMark
    118.     public Texture2D tex;
    119.     public float size = 32;
    120.     private float hitAlpha;
    121.     public AudioClip hitMarkerSound;
    122.     #endregion
    123.  
    124.  
    125.     void Start()
    126.     {
    127.         muzzle.SetActive(false);
    128.         if (networkView.isMine)
    129.         {
    130.             spreadTemp = basicSpread;
    131.             spread = basicSpread;
    132.             StartCoroutine(CheckBools());
    133.             StartCoroutine(Draw());
    134.         }
    135.         else
    136.         {
    137.             this.enabled = false;
    138.         }
    139.     }
    140.  
    141.     void Update()
    142.     {
    143.         if (networkView.isMine)
    144.         {
    145.             if (hitAlpha > 0) hitAlpha -= Time.deltaTime;
    146.             spread = Mathf.Clamp(spread, 0, maximumSpread);
    147.             if (aiming) spread = aimSpread;
    148.             else spread = Mathf.Lerp(spread, spreadTemp + cv.velMag * 2, Time.deltaTime * 8);
    149.             if (spreadTemp > basicSpread) spreadTemp -= Time.deltaTime * spreadReturnTime;
    150.             pivot = new Vector2(Screen.width / 2, Screen.height / 2);
    151.             bulletsLeftRead = bulletsLeft;
    152.             bulletsPerMagRead = bulletsPerMag;
    153.             magsLeftRead = magsLeft;
    154.             camKB.localRotation = Quaternion.Lerp(camKB.localRotation, Quaternion.identity, Time.deltaTime * returnSpeed);
    155.             wepKB.localRotation = Quaternion.Lerp(wepKB.localRotation, Quaternion.identity, Time.deltaTime * returnSpeed);
    156.             cam.fieldOfView = Mathf.Lerp(cam.fieldOfView, curFov, Time.deltaTime * 10);
    157.             transform.localPosition = Vector3.Lerp(transform.localPosition, curPos, Time.deltaTime * 10);
    158.             if (Screen.lockCursor)
    159.                 CheckInput();
    160.             canReloads[1] = true;
    161.             canAims[1] = !cv.running;
    162.             canFires[1] = !cv.running;
    163.             if (aiming)
    164.             {
    165.                 curFov = aimFov;
    166.                 curPos = aimPos;
    167.             }
    168.             else
    169.             {
    170.                 curFov = hipFov;
    171.                 if (cv.state == 0)
    172.                 {
    173.                     curPos = hipPos;
    174.                 }
    175.                 else if (cv.state == 1)
    176.                 {
    177.                     curPos = crouchPos;
    178.                 }
    179.             }
    180.  
    181.             if (!canAim) aiming = false;
    182.         }
    183.         else
    184.         {
    185.             this.enabled = false;
    186.         }
    187.     }
    188.  
    189.     void OnGUI()
    190.     {
    191.         if (networkView.isMine)
    192.         {
    193.  
    194.             float w = crosshairFirstModeHorizontal.width;
    195.             float h = crosshairFirstModeHorizontal.height;
    196.             Rect position1 = new Rect((Screen.width + w) / 2 + (spread * sizeMultiplier), (Screen.height - h) / 2, w, h);
    197.             Rect position2 = new Rect((Screen.width - w) / 2, (Screen.height + h) / 2 + (spread * sizeMultiplier), w, h);
    198.             Rect position3 = new Rect((Screen.width - w) / 2 - (spread * sizeMultiplier) - w, (Screen.height - h) / 2, w, h);
    199.             Rect position4 = new Rect((Screen.width - w) / 2, (Screen.height - h) / 2 - (spread * sizeMultiplier) - h, w, h);
    200.             if (!aiming)
    201.             {
    202.                 GUI.DrawTexture(position1, crosshairFirstModeHorizontal);     //Right
    203.                 GUI.DrawTexture(position2, crosshairFirstModeVertical);     //Up
    204.                 GUI.DrawTexture(position3, crosshairFirstModeHorizontal);     //Left
    205.                 GUI.DrawTexture(position4, crosshairFirstModeVertical);        //Down
    206.             }
    207.  
    208.             GUI.color = new Color(1, 1, 1, hitAlpha);
    209.             GUI.DrawTexture(new Rect((Screen.width - size) / 2, (Screen.height - size) / 2, size, size), tex);
    210.  
    211.         }
    212.     }
    213.  
    214.     void CheckInput()
    215.     {
    216.         aiming = (canAim && Input.GetKey(KeyCode.Mouse1));
    217.         if (!reloading && Time.time > timer && canFire && Input.GetKey(KeyCode.Mouse0) && bulletsLeft > 0 && Screen.lockCursor)
    218.         {
    219.             FireOneShot();
    220.         }
    221.         if (!reloading && canReload && magsLeft > 0 && Input.GetKeyDown(KeyCode.R) && Screen.lockCursor)
    222.         {
    223.             reloading = true;
    224.             StartCoroutine(Reload());
    225.         }
    226.     }
    227.  
    228.     void FireOneShot()
    229.     {
    230.         spreadTemp += spreadAddPerShot;
    231.         timer = Time.time + fireRate;
    232.         anim.Rewind(fireAnim.name);
    233.         anim.Play(fireAnim.name);
    234.         localSource.clip = fireSound;
    235.         localSource.PlayOneShot(fireSound);
    236.         StartCoroutine(MuzzleFlash());
    237.         StartCoroutine(Kick3(camKB, new Vector3(-Random.Range(minKB, maxKB), Random.Range(minKBSide, maxKBSide), 0), 0.1f));
    238.         StartCoroutine(Kick3(wepKB, new Vector3(-Random.Range(minKB, maxKB), Random.Range(minKBSide, maxKBSide), 0), 0.1f));
    239.  
    240.         float actualSpread = Random.Range(-spread, spread);
    241.         //Vector3 position = new Vector3(bulletGo.position.x - actualSpread, bulletGo.position.y - actualSpread, bulletGo.position.z);
    242.         Vector3 direction = gameObject.transform.TransformDirection(new Vector3(Random.Range(-0.01f, 0.01f) * spread, Random.Range(-0.01f, 0.01f) * spread, 1));
    243.         RaycastHit hit2;
    244.         if (Physics.Raycast(bulletGo.position, direction, out hit2, range, hitLayers))
    245.         {
    246.             OnHit(hit2);
    247.         }
    248.         bulletsLeft--;
    249.     }
    250.  
    251.     void DoHitMark()
    252.     {
    253.         hitAlpha = 2;
    254.         audio.PlayOneShot(hitMarkerSound, 1f);
    255.     }
    256.  
    257.     void OnHit(RaycastHit hit)
    258.     {
    259.         if (hit.rigidbody)
    260.         {
    261.             hit.rigidbody.AddForceAtPosition(2000 * bulletGo.forward, hit.point);
    262.         }
    263.         if (hit.transform.tag == "Player")
    264.         {
    265.             Instantiate(blood, hit.point, Quaternion.identity);
    266.             DoHitMark();
    267.             if (hit.transform.root.networkView)
    268.                 hit.transform.root.networkView.RPC("ApplyDamage", RPCMode.AllBuffered, Random.Range(damageMin, damageMax), 1);
    269.         }
    270.         else
    271.         {
    272.             if (hit.transform.tag == "Wood")
    273.             {
    274.                 GameObject theObj = Instantiate(wood, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    275.                 theObj.transform.parent = hit.transform;
    276.             }
    277.             else if (hit.transform.tag == "Metal")
    278.             {
    279.                 GameObject theObj = Instantiate(metal, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    280.                 theObj.transform.parent = hit.transform;
    281.             }
    282.             else if (hit.transform.tag == "Dirt")
    283.             {
    284.                 GameObject theObj = Instantiate(dirt, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    285.                 theObj.transform.parent = hit.transform;
    286.             }
    287.             else
    288.             {
    289.                 GameObject theObj = Instantiate(concrete, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    290.                 theObj.transform.parent = hit.transform;
    291.             }
    292.         }
    293.     }
    294.  
    295.     IEnumerator Kick3(Transform goTransform, Vector3 kbDirection, float time)
    296.     {
    297.         Quaternion startRotation = goTransform.localRotation;
    298.         Quaternion endRotation = goTransform.localRotation * Quaternion.Euler(kbDirection);
    299.         float rate = 1.0f / time;
    300.         var t = 0.0f;
    301.         while (t < 1.0f)
    302.         {
    303.             t += Time.deltaTime * rate;
    304.             goTransform.localRotation = Quaternion.Slerp(startRotation, endRotation, t);
    305.             yield return null;
    306.         }
    307.     }
    308.  
    309.     IEnumerator Reload()
    310.     {
    311.         reloading = true;
    312.         canAims[0] = false;
    313.         canFires[0] = false;
    314.         canReloads[0] = false;
    315.         if (bulletsLeft > 0)
    316.         {
    317.             StartCoroutine(ReloadingSound(reloadSounds));
    318.             anim.Play(reloadAnim.name);
    319.             yield return new WaitForSeconds(reloadAnim.length);
    320.             bulletsLeft = bulletsPerMag + 1;
    321.             magsLeft--;
    322.         }
    323.         else
    324.         {
    325.             StartCoroutine(ReloadingSound(reloadSoundsEmpty));
    326.             anim.Play(reloadEmptyAnim.name);
    327.             yield return new WaitForSeconds(reloadEmptyAnim.length);
    328.             bulletsLeft = bulletsPerMag;
    329.             magsLeft--;
    330.         }
    331.         canAims[0] = true;
    332.         canFires[0] = true;
    333.         canReloads[0] = true;
    334.         reloading = false;
    335.     }
    336.  
    337.     IEnumerator ReloadingSound(ReloadSound[] theSound)
    338.     {
    339.         foreach (ReloadSound lol in theSound)
    340.         {
    341.             yield return new WaitForSeconds(lol.length);
    342.             localSource.clip = lol.clip;
    343.             localSource.Play();
    344.         }
    345.     }
    346.  
    347.     IEnumerator CheckBools()
    348.     {
    349.         CheckAim();
    350.         CheckReload();
    351.         CheckFire();
    352.         yield return new WaitForSeconds(0.1f);
    353.         StartCoroutine(CheckBools());
    354.     }
    355.  
    356.     IEnumerator MuzzleFlash()
    357.     {
    358.         muzzle.SetActive(true);
    359.         yield return new WaitForSeconds(0.1f);
    360.         muzzle.SetActive(false);
    361.     }
    362.  
    363.     void CheckAim()
    364.     {
    365.         canAim = false;
    366.         foreach (bool lol in canAims)
    367.         {
    368.             if (!lol) return;
    369.         }
    370.         canAim = true;
    371.     }
    372.  
    373.     void CheckReload()
    374.     {
    375.         canReload = false;
    376.         foreach (bool lol in canReloads)
    377.         {
    378.             if (!lol) return;
    379.         }
    380.         canReload = true;
    381.     }
    382.  
    383.     void CheckFire()
    384.     {
    385.         canFire = false;
    386.         foreach (bool lol in canFires)
    387.         {
    388.             if (!lol) return;
    389.         }
    390.         canFire = true;
    391.     }
    392.  
    393.     IEnumerator Draw()
    394.     {
    395.         canAims[0] = false;
    396.         canFires[0] = false;
    397.         canReloads[0] = false;
    398.         //localSource.clip = drawSound;
    399.         //localSource.Play();
    400.         StartCoroutine(ReloadingSound(drawSound));
    401.         anim.Play(drawAnim.name);
    402.         yield return new WaitForSeconds(drawAnim.length);
    403.         canAims[0] = true;
    404.         canFires[0] = true;
    405.         canReloads[0] = true;
    406.     }
    407. }
    please help me :(

    PS: i'm french and i'm sorry for the bad english :p and i don't if i'm in the good sectiono_O
     
    ggsnip, Nov 28, 2014
    #1

  2. Defero

    Defero

    Joined:
    Jul 9, 2012
    Posts:
    200
    This is untested, but the direction is ok i think.

    I added two new variables :
    public bool singleShotMode = false;
    private bool waitingForMouseUp = false;

    and added a little code in the Update() and CheckInput() functions.


    Code (CSharp):
    1. using UnityEngine;
    2. using System.Collections;
    3. [System.Serializable]
    4. public class ReloadSound
    5. {
    6.     public string name = "Mag out";
    7.     public AudioClip clip;
    8.     public float length;
    9. }
    10. public class Weapon : MonoBehaviour
    11. {
    12.     public Animation anim;
    13.     public AnimationClip fireAnim;
    14.     public AnimationClip reloadAnim;
    15.     public AnimationClip reloadEmptyAnim;
    16.     public AnimationClip drawAnim;
    17.     #region bools
    18.     public bool reloading;
    19.     public bool[] canAims;
    20.     private bool canAim;
    21.     public bool[] canReloads;
    22.     private bool canReload;
    23.     public bool[] canFires;
    24.     private bool canFire;
    25.     #endregion
    26.     #region stats
    27.     public float fireRate = 0.1f;
    28.     public float timer = 0;
    29.     [SerializeField]
    30.     protected int bulletsLeft = 30;
    31.     [SerializeField]
    32.     protected int bulletsPerMag = 30;
    33.     [SerializeField]
    34.     protected int magsLeft = 10;
    35.     public float range = 2000;
    36.     public float damageMin = 10;
    37.     public float damageMax = 20;
    38.     public bool singleShotMode = false;
    39.     private bool waitingForMouseUp = false;
    40.     public Transform bulletGo;
    41.     public LayerMask hitLayers;
    42.     public GameObject blood;
    43.     public GameObject concrete;
    44.     public GameObject wood;
    45.     public GameObject metal;
    46.     public GameObject dirt;
    47.     #endregion
    48.     #region readOnly
    49.     public int bulletsLeftRead = 30;
    50.     public int bulletsPerMagRead = 30;
    51.     public int magsLeftRead = 10;
    52.     #endregion
    53.     #region components
    54.     public CharacterValues cv;
    55.     public PlayerAnimations pa;
    56.     #endregion
    57.     #region sound
    58.     public AudioSource localSource;
    59.     public AudioClip fireSound;
    60.     public ReloadSound[] drawSound;
    61.     public ReloadSound[] reloadSounds;
    62.     public ReloadSound[] reloadSoundsEmpty;
    63.     #endregion
    64.     #region ads
    65.     public Camera cam;
    66.     public bool aiming;
    67.     public float hipFov = 75;
    68.     public float aimFov = 55;
    69.     private float curFov = 75;
    70.     public Vector3 hipPos;
    71.     public Vector3 crouchPos;
    72.     public Vector3 aimPos;
    73.     private Vector3 curPos;
    74.     #endregion
    75.     #region recoil
    76.     public Transform camKB;
    77.     public Transform wepKB;
    78.     public float minKB;
    79.     public float maxKB;
    80.     public float minKBSide;
    81.     public float maxKBSide;
    82.     public float returnSpeed = 5f;
    83.     #endregion
    84.     #region muzzle
    85.     public GameObject muzzle;
    86.     #endregion
    87.     #region crosshair
    88.     public float sizeMultiplier = 1f;
    89.     public float aimSpread;
    90.     public float basicSpread = 30;
    91.     public float maximumSpread = 100;
    92.     public float spreadReturnTime = 5;
    93.     public float spreadAddPerShot = 5;
    94.     public float spreadTemp;
    95.     private float spread = 30;
    96.     //Crosshair Textures
    97.     public Texture2D crosshairFirstModeHorizontal;
    98.     public Texture2D crosshairFirstModeVertical;
    99.     #endregion
    100.     #region private
    101.     private Vector2 pivot;
    102.     #endregion
    103.     #region hitMark
    104.     public Texture2D tex;
    105.     public float size = 32;
    106.     private float hitAlpha;
    107.     public AudioClip hitMarkerSound;
    108.     #endregion
    109.     void Start()
    110.     {
    111.         muzzle.SetActive(false);
    112.         if (networkView.isMine)
    113.         {
    114.             spreadTemp = basicSpread;
    115.             spread = basicSpread;
    116.             StartCoroutine(CheckBools());
    117.             StartCoroutine(Draw());
    118.         }
    119.         else
    120.         {
    121.             this.enabled = false;
    122.         }
    123.     }
    124.     void Update()
    125.     {
    126.         if (networkView.isMine)
    127.         {
    128.             if (hitAlpha > 0) hitAlpha -= Time.deltaTime;
    129.             spread = Mathf.Clamp(spread, 0, maximumSpread);
    130.             if (aiming) spread = aimSpread;
    131.             else spread = Mathf.Lerp(spread, spreadTemp + cv.velMag * 2, Time.deltaTime * 8);
    132.             if (spreadTemp > basicSpread) spreadTemp -= Time.deltaTime * spreadReturnTime;
    133.             pivot = new Vector2(Screen.width / 2, Screen.height / 2);
    134.             bulletsLeftRead = bulletsLeft;
    135.             bulletsPerMagRead = bulletsPerMag;
    136.             magsLeftRead = magsLeft;
    137.             camKB.localRotation = Quaternion.Lerp(camKB.localRotation, Quaternion.identity, Time.deltaTime * returnSpeed);
    138.             wepKB.localRotation = Quaternion.Lerp(wepKB.localRotation, Quaternion.identity, Time.deltaTime * returnSpeed);
    139.             cam.fieldOfView = Mathf.Lerp(cam.fieldOfView, curFov, Time.deltaTime * 10);
    140.             transform.localPosition = Vector3.Lerp(transform.localPosition, curPos, Time.deltaTime * 10);
    141.             if (Screen.lockCursor)
    142.                 CheckInput();
    143.             canReloads[1] = true;
    144.             canAims[1] = !cv.running;
    145.             canFires[1] = !cv.running;
    146.             if (aiming)
    147.             {
    148.                 curFov = aimFov;
    149.                 curPos = aimPos;
    150.             }
    151.             else
    152.             {
    153.                 curFov = hipFov;
    154.                 if (cv.state == 0)
    155.                 {
    156.                     curPos = hipPos;
    157.                 }
    158.                 else if (cv.state == 1)
    159.                 {
    160.                     curPos = crouchPos;
    161.                 }
    162.             }
    163.             if (!canAim) aiming = false;
    164.             if (waitingForMouseUp && Input.GetKeyUp(KeyCode.Mouse0))
    165.               waitingForMouseUp = false;
    166.         }
    167.         else
    168.         {
    169.             this.enabled = false;
    170.         }
    171.     }
    172.     void OnGUI()
    173.     {
    174.         if (networkView.isMine)
    175.         {
    176.             float w = crosshairFirstModeHorizontal.width;
    177.             float h = crosshairFirstModeHorizontal.height;
    178.             Rect position1 = new Rect((Screen.width + w) / 2 + (spread * sizeMultiplier), (Screen.height - h) / 2, w, h);
    179.             Rect position2 = new Rect((Screen.width - w) / 2, (Screen.height + h) / 2 + (spread * sizeMultiplier), w, h);
    180.             Rect position3 = new Rect((Screen.width - w) / 2 - (spread * sizeMultiplier) - w, (Screen.height - h) / 2, w, h);
    181.             Rect position4 = new Rect((Screen.width - w) / 2, (Screen.height - h) / 2 - (spread * sizeMultiplier) - h, w, h);
    182.             if (!aiming)
    183.             {
    184.                 GUI.DrawTexture(position1, crosshairFirstModeHorizontal);     //Right
    185.                 GUI.DrawTexture(position2, crosshairFirstModeVertical);     //Up
    186.                 GUI.DrawTexture(position3, crosshairFirstModeHorizontal);     //Left
    187.                 GUI.DrawTexture(position4, crosshairFirstModeVertical);        //Down
    188.             }
    189.             GUI.color = new Color(1, 1, 1, hitAlpha);
    190.             GUI.DrawTexture(new Rect((Screen.width - size) / 2, (Screen.height - size) / 2, size, size), tex);
    191.         }
    192.     }
    193.     void CheckInput()
    194.     {
    195.         aiming = (canAim && Input.GetKey(KeyCode.Mouse1));
    196.         singleShotMode
    197.         if (!reloading && Time.time > timer && canFire && Input.GetKey(KeyCode.Mouse0) && bulletsLeft > 0 && Screen.lockCursor)
    198.         {
    199.           if(singleShotMode && !waitingForMouseUp)
    200.           {
    201.             FireOneShot();
    202.             waitingForMouseUp = true;
    203.           }
    204.         }
    205.         if (!reloading && canReload && magsLeft > 0 && Input.GetKeyDown(KeyCode.R) && Screen.lockCursor)
    206.         {
    207.             reloading = true;
    208.             StartCoroutine(Reload());
    209.         }
    210.        
    211.     }
    212.     void FireOneShot()
    213.     {
    214.         spreadTemp += spreadAddPerShot;
    215.         timer = Time.time + fireRate;
    216.         anim.Rewind(fireAnim.name);
    217.         anim.Play(fireAnim.name);
    218.         localSource.clip = fireSound;
    219.         localSource.PlayOneShot(fireSound);
    220.         StartCoroutine(MuzzleFlash());
    221.         StartCoroutine(Kick3(camKB, new Vector3(-Random.Range(minKB, maxKB), Random.Range(minKBSide, maxKBSide), 0), 0.1f));
    222.         StartCoroutine(Kick3(wepKB, new Vector3(-Random.Range(minKB, maxKB), Random.Range(minKBSide, maxKBSide), 0), 0.1f));
    223.         float actualSpread = Random.Range(-spread, spread);
    224.         //Vector3 position = new Vector3(bulletGo.position.x - actualSpread, bulletGo.position.y - actualSpread, bulletGo.position.z);
    225.         Vector3 direction = gameObject.transform.TransformDirection(new Vector3(Random.Range(-0.01f, 0.01f) * spread, Random.Range(-0.01f, 0.01f) * spread, 1));
    226.         RaycastHit hit2;
    227.         if (Physics.Raycast(bulletGo.position, direction, out hit2, range, hitLayers))
    228.         {
    229.             OnHit(hit2);
    230.         }
    231.         bulletsLeft--;
    232.     }
    233.     void DoHitMark()
    234.     {
    235.         hitAlpha = 2;
    236.         audio.PlayOneShot(hitMarkerSound, 1f);
    237.     }
    238.     void OnHit(RaycastHit hit)
    239.     {
    240.         if (hit.rigidbody)
    241.         {
    242.             hit.rigidbody.AddForceAtPosition(2000 * bulletGo.forward, hit.point);
    243.         }
    244.         if (hit.transform.tag == "Player")
    245.         {
    246.             Instantiate(blood, hit.point, Quaternion.identity);
    247.             DoHitMark();
    248.             if (hit.transform.root.networkView)
    249.                 hit.transform.root.networkView.RPC("ApplyDamage", RPCMode.AllBuffered, Random.Range(damageMin, damageMax), 1);
    250.         }
    251.         else
    252.         {
    253.             if (hit.transform.tag == "Wood")
    254.             {
    255.                 GameObject theObj = Instantiate(wood, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    256.                 theObj.transform.parent = hit.transform;
    257.             }
    258.             else if (hit.transform.tag == "Metal")
    259.             {
    260.                 GameObject theObj = Instantiate(metal, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    261.                 theObj.transform.parent = hit.transform;
    262.             }
    263.             else if (hit.transform.tag == "Dirt")
    264.             {
    265.                 GameObject theObj = Instantiate(dirt, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    266.                 theObj.transform.parent = hit.transform;
    267.             }
    268.             else
    269.             {
    270.                 GameObject theObj = Instantiate(concrete, hit.point + hit.normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hit.normal)) as GameObject;
    271.                 theObj.transform.parent = hit.transform;
    272.             }
    273.         }
    274.     }
    275.     IEnumerator Kick3(Transform goTransform, Vector3 kbDirection, float time)
    276.     {
    277.         Quaternion startRotation = goTransform.localRotation;
    278.         Quaternion endRotation = goTransform.localRotation * Quaternion.Euler(kbDirection);
    279.         float rate = 1.0f / time;
    280.         var t = 0.0f;
    281.         while (t < 1.0f)
    282.         {
    283.             t += Time.deltaTime * rate;
    284.             goTransform.localRotation = Quaternion.Slerp(startRotation, endRotation, t);
    285.             yield return null;
    286.         }
    287.     }
    288.     IEnumerator Reload()
    289.     {
    290.         reloading = true;
    291.         canAims[0] = false;
    292.         canFires[0] = false;
    293.         canReloads[0] = false;
    294.         if (bulletsLeft > 0)
    295.         {
    296.             StartCoroutine(ReloadingSound(reloadSounds));
    297.             anim.Play(reloadAnim.name);
    298.             yield return new WaitForSeconds(reloadAnim.length);
    299.             bulletsLeft = bulletsPerMag + 1;
    300.             magsLeft--;
    301.         }
    302.         else
    303.         {
    304.             StartCoroutine(ReloadingSound(reloadSoundsEmpty));
    305.             anim.Play(reloadEmptyAnim.name);
    306.             yield return new WaitForSeconds(reloadEmptyAnim.length);
    307.             bulletsLeft = bulletsPerMag;
    308.             magsLeft--;
    309.         }
    310.         canAims[0] = true;
    311.         canFires[0] = true;
    312.         canReloads[0] = true;
    313.         reloading = false;
    314.     }
    315.     IEnumerator ReloadingSound(ReloadSound[] theSound)
    316.     {
    317.         foreach (ReloadSound lol in theSound)
    318.         {
    319.             yield return new WaitForSeconds(lol.length);
    320.             localSource.clip = lol.clip;
    321.             localSource.Play();
    322.         }
    323.     }
    324.     IEnumerator CheckBools()
    325.     {
    326.         CheckAim();
    327.         CheckReload();
    328.         CheckFire();
    329.         yield return new WaitForSeconds(0.1f);
    330.         StartCoroutine(CheckBools());
    331.     }
    332.     IEnumerator MuzzleFlash()
    333.     {
    334.         muzzle.SetActive(true);
    335.         yield return new WaitForSeconds(0.1f);
    336.         muzzle.SetActive(false);
    337.     }
    338.     void CheckAim()
    339.     {
    340.         canAim = false;
    341.         foreach (bool lol in canAims)
    342.         {
    343.             if (!lol) return;
    344.         }
    345.         canAim = true;
    346.     }
    347.     void CheckReload()
    348.     {
    349.         canReload = false;
    350.         foreach (bool lol in canReloads)
    351.         {
    352.             if (!lol) return;
    353.         }
    354.         canReload = true;
    355.     }
    356.     void CheckFire()
    357.     {
    358.         canFire = false;
    359.         foreach (bool lol in canFires)
    360.         {
    361.             if (!lol) return;
    362.         }
    363.         canFire = true;
    364.     }
    365.     IEnumerator Draw()
    366.     {
    367.         canAims[0] = false;
    368.         canFires[0] = false;
    369.         canReloads[0] = false;
    370.         //localSource.clip = drawSound;
    371.         //localSource.Play();
    372.         StartCoroutine(ReloadingSound(drawSound));
    373.         anim.Play(drawAnim.name);
    374.         yield return new WaitForSeconds(drawAnim.length);
    375.         canAims[0] = true;
    376.         canFires[0] = true;
    377.         canReloads[0] = true;
    378.     }
    379. }
     
    Defero, Nov 28, 2014
    #2

  3. ggsnip

    ggsnip

    Joined:
    Nov 28, 2014
    Posts:
    3
    okey but i have this error why ?
     

    Attached Files:

    ggsnip, Nov 28, 2014
    #3

  4. Louis-LCM

    Louis-LCM

    Joined:
    Aug 26, 2014
    Posts:
    59
    For the second error insert a "}" at the end of the script .
     
    Louis-LCM, Nov 28, 2014
    #4

  5. Defero

    Defero

    Joined:
    Jul 9, 2012
    Posts:
    200
    Uff sry, just delete the line 196 : singleShotMode

    I usually copy new variables names lower, so i don't forget the names when. Because i'm lazy and i don't like scrolling :rolleyes:

    Edit:

    It wrong also, use this conditions:

    Code (CSharp):
    1. if(singleShotMode)
    2. {
    3.        if(!waitingForMouseUp){
    4.             FireOneShot();
    5.             waitingForMouseUp = true;
    6.       }
    7. }else{
    8.            FireOneShot();
    9. }
     
    Last edited: Nov 28, 2014
    Defero, Nov 28, 2014
    #5

  6. Defero

    Defero

    Joined:
    Jul 9, 2012
    Posts:
    200
    Ye i realised after second look, if you look my previous post, i edited it a bit
     
    Defero, Nov 28, 2014
    #6

  7. ggsnip

    ggsnip

    Joined:
    Nov 28, 2014
    Posts:
    3
    i know XD . Okey the sript work !! thank you :oops:
     
    ggsnip, Nov 28, 2014
    #7