Firecrackers cheese adventure code

				
					using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class player_movement : MonoBehaviour
{
    //scripts
    public player_interaction pI;
    //components=============================================================
    //animators
    public Animator pAnime;
    Animator rocketAnime;
    Animator rocketsoundAnime;
    //rigidboddys
    Rigidbody mainRigid;
    //gameobjects
    public GameObject firecracker_rat;
    public GameObject gimble1;
    public GameObject gimble2;
    public GameObject rocketSoundObject;
    public GameObject rocketBostAudio;
    public GameObject voiceObject;
    public GameObject interactionObject;
    public GameObject deathObject;
    public GameObject crashSoundObject;
    public GameObject bounceSoundObject;

    //particles
    ParticleSystem pSystem1;
    ParticleSystemRenderer pSystem1Ren;
    ParticleSystem pSystem2;
    ParticleSystemRenderer pSystem2Ren;
    //colliders
    Collider interactionCollider;
    //components=============================================================
    //media==================================================================
    //materials
    public Material blueFlame;
    public Material redFlame;
    //audio imports
    AudioSource voiceSource;
    AudioSource crashSoundSourse;
    AudioSource bounceSoundScource;
    AudioClip CurentVoiceClip;
    public AudioClip[] cheeseDoodleVoice;
    public AudioClip[] cheeseBallVoice;
    public AudioClip[] doritoVoice;
    public AudioClip[] laughVoice;
    public AudioClip[] numnumVoice;
    public AudioClip[] cheeseWinVoice;
    public AudioClip[] yesyesVoice;
    public AudioClip[] gonnaDieVoice;
    public AudioClip[] bounceSounds;
    //media==================================================================
    //Ragdoll Specific game objects==========================================
    public List<Collider> ragdollParts = new List<Collider>();
    //Ragdoll Specific game objects==========================================
    //floats=================================================================
    public float upBoost = 10f;
    public float sideBoost = 10f;
    public float moveBoost = 10f;
    public float playerRotation = 100f;
    public float particleBoosSpeed = 5f;
    public float originalParticleSpeed = 2.28f;
    float playedVoice;
    float SoundClipLength;
    float laughWaitTime;
    float soundAnimationTiming;
    float timer;
    public float TrueDuration;
    float lastPlayedVoice;
    //bools=========================================================================
    bool pp_right;
    bool pp_left;
    bool pp_forward;
    bool pp_backwards;
    public bool pp_upward;
    bool pp_laugh;
    bool voiceIsPlayed;
    bool notLoopingLaugh = false;
    bool playerDead;
    //int============================================================================
    public int laughFrom = 30;
    public int laughTo = 35;
    int randomeWait;
    int rangeScan;
    int toPlay;
    int toSayCheeseDoodle;
    // The amount of time firecracker says his line on pickup of CheeseDoodles.
    public int CheeseDoodleVoicerate = 15;
    // Start is called before the first frame update
    void Start()
    {
        //put ragdoll coliders in array.

        //gets animator for the rigged character.
        pAnime = gameObject.GetComponent<Animator>();
        //gets animator from child object to run two animators for the same character.
        rocketAnime = firecracker_rat.GetComponent<Animator>();
        rocketsoundAnime = rocketBostAudio.GetComponent<Animator>();
        //get audio sources from child object.
        voiceSource = voiceObject.GetComponent<AudioSource>();
        crashSoundSourse = crashSoundObject.GetComponent<AudioSource>();
        bounceSoundScource = bounceSoundObject.GetComponent<AudioSource>();
        //get collider from child object
        interactionCollider = interactionObject.GetComponent<Collider>();
        //get particle emiters from su items.
        pSystem1 = gimble1.GetComponent<ParticleSystem>();
        pSystem2 = gimble2.GetComponent<ParticleSystem>();
        pSystem1Ren = gimble1.GetComponent<ParticleSystemRenderer>();
        pSystem2Ren = gimble2.GetComponent<ParticleSystemRenderer>();
        mainRigid = GetComponent<Rigidbody>();
        //floats
        SoundClipLength = 0;
        // bools to make shure the player is ideling when the game starts.
        pp_left = false;
        pp_right = false;
        pp_forward = false;
        pp_backwards = false;
        pp_upward = false;
        pp_laugh = false;
        voiceIsPlayed = false;
        playerDead = false;
        //int
        randomeWait = 15;
        //disabled objects
        deathObject.gameObject.SetActive(false);
    }
    // Update is called once per frame
    private void Awake()
    {
        //removes ragdoll on awake so the player can controll the player.
        SetRagdollParts();
    }
    // 
    private void SetRagdollParts()
    {
        // gets the rigidbodys from the children of this game object.
        Rigidbody[] rigids = this.gameObject.GetComponentsInChildren<Rigidbody>();
        foreach (Rigidbody r in rigids)
        {
            //removes the game object we want physics on.
            if (r.gameObject.tag != "tail" && r.gameObject != this.gameObject)
            {
                // I wanted to use c.attachedRigidbody in the next for each loop instead but the player spaces out when I do.
                //This makes the ragdoll not afected by gravity.
                r.isKinematic = true;
            }
        }
        //Does the same as above but for the coliders in the rag Doll
        Collider[] colliders = this.gameObject.GetComponentsInChildren<Collider>();
        foreach (Collider c in colliders)
        {
            // || c.gameObject.tag != "tail" || c.gameObject.tag != "notRag"
            if (c.gameObject.tag != "tail" && c.gameObject != this.gameObject)
            {
                //isTrigger tells the colider that it cant physacly collide with anything.
                c.isTrigger = true;
                //puts the ragdoll parts in a list so it can be easely used in the ragdollPlayer function.
                ragdollParts.Add(c);
            }
        }
    }
    void ragdollPlayer()
    {
        //ragdolls player on death.
        // Disables the main box colider that keeps the player from going thru the world.
        //this.gameObject.GetComponentInChildren<BoxCollider>().enabled = false;
        // Diables the animator for the rocket but keeps the player screaming to his death.
        rocketAnime.enabled = false;
        // works the same as in SetRagdollParts() but does the oposite.
        Rigidbody[] rigids = this.gameObject.GetComponentsInChildren<Rigidbody>();
        foreach (Rigidbody r in rigids)
        {
            if (r.gameObject.tag != "tail")
            {
                r.isKinematic = false;
                //removes the velocity from the player so it falls right down. (Makes the death less glitchy)
                //r.velocity = Vector3.zero;
            }
        }
        foreach (Collider c in ragdollParts)
        {
            c.isTrigger = false;
        }
    }
    void Update()
    {
        //only movment from keys
        if (playerDead != true)
        {
            if (Input.GetKey(KeyCode.W))
            {
                mainRigid.AddForce(transform.forward * Time.deltaTime * moveBoost);
            }

            if (Input.GetKey(KeyCode.S))
            {
                mainRigid.AddForce(-transform.forward * Time.deltaTime * moveBoost);
            }
            if (Input.GetKey(KeyCode.Space))
            {
                mainRigid.AddForce(Vector3.up * Time.deltaTime * upBoost, ForceMode.Impulse);
            }
            if (Input.GetKey(KeyCode.D))
            {
                mainRigid.AddForce(transform.right * Time.deltaTime * sideBoost, ForceMode.Impulse);
            }
            if (Input.GetKey(KeyCode.A))
            {
                mainRigid.AddForce(-transform.right * Time.deltaTime * sideBoost, ForceMode.Impulse);
            }
            //mouse movement
            if (Input.GetAxis("Mouse X") < 0)
            {
                transform.Rotate(new Vector3(0, -1, 0) * Time.deltaTime * playerRotation, Space.World);
            }
            if (Input.GetAxis("Mouse X") > 0)
            {
                transform.Rotate(new Vector3(0, 1, 0) * Time.deltaTime * playerRotation, Space.World);
            }
        }
        //gets keyinputs and plays animations on key presses.
        if (Input.GetKeyDown(KeyCode.A))
        {
            //Debug.Log("Player holding A!");
            pp_left = true;
        }
        if (Input.GetKeyUp(KeyCode.A))
        {
            //Debug.Log("Player not holding A!");
            pp_left = false;
        }
        if (Input.GetKeyDown(KeyCode.D))
        {
            //Debug.Log("Player holding D!");
            pp_right = true;
        }
        if (Input.GetKeyUp(KeyCode.D))
        {
            //Debug.Log("Player not holding D!");
            pp_right = false;
        }
        if (Input.GetKeyDown(KeyCode.W))
        {
            pp_forward = true;
        }
        if (Input.GetKeyUp(KeyCode.W))
        {
            pp_forward = false;
        }
        if (Input.GetKeyDown(KeyCode.S))
        {
            pp_backwards = true;
        }
        if (Input.GetKeyUp(KeyCode.S))
        {
            pp_backwards = false;
        }
        //emitrate on space
        if (Input.GetKeyDown(KeyCode.Space))
        {
            BoostParticles();
            pp_upward = true;
        }
        if (Input.GetKeyUp(KeyCode.Space))
        {
            ResetParticles();
            pp_upward = false;
        }
        // plays animator
        //pAnime
        if (pp_left == false)
        {
            pAnime.SetBool("holdLeft", false);
            rocketAnime.SetBool("tiltLeft", false);
        }
        if (pp_left == true)
        {
            pAnime.SetBool("holdLeft", true);
            rocketAnime.SetBool("tiltLeft", true);
        }
        if (pp_right == false)
        {
            pAnime.SetBool("holdRight", false);
            rocketAnime.SetBool("tiltRight", false);
        }
        if (pp_right == true)
        {
            pAnime.SetBool("holdRight", true);
            rocketAnime.SetBool("tiltRight", true);
        }
        //character interaction anime
        if (pp_laugh == false)
        {
            pAnime.SetBool("laughing", false);
        }
        if (pp_laugh == true)
        {
            pAnime.SetBool("laughing", true);
        }
        //rocketAnime
        if (pp_forward == false)
        {
            rocketAnime.SetBool("tiltForward", false);
        }
        if (pp_forward == true)
        {
            rocketAnime.SetBool("tiltForward", true);
        }
        if (pp_backwards == false)
        {
            rocketAnime.SetBool("tiltBackward", false);
        }
        if (pp_backwards == true)
        {
            rocketAnime.SetBool("tiltBackward", true);
        }
        // rocketSoundAnime
        if (pp_upward == false)
        {
            //Debug.Log("HoldingUp");
            rocketsoundAnime.SetBool("holdingUp", false);
        }
        if (pp_upward == true)
        {
            //Debug.Log("not HoldingUp!");
            rocketsoundAnime.SetBool("holdingUp", true);
        }
        //voice code
        //Randome laugh
        //Debug.Log(playerDead);
        if (voiceIsPlayed == false)
        {
            if (playerDead == false)
            {
                //runs the laugh after a time
                StartCoroutine(ExecuteAfterTime(randomeWait));
                //function to run the laugh
                IEnumerator ExecuteAfterTime(float time)
                {
                    //checks if it's allready waiting to play the laugh.
                    if (notLoopingLaugh)
                        //breaks if the laugh is being waited for.
                        yield break;
                    notLoopingLaugh = true;
                    //Waiting fuction
                    yield return new WaitForSeconds(time);
                    //executes the laugh
                    playedVoice = 1;
                    voicePlayer(playedVoice);
                    // picks a randome time to play the next laugh
                    randomeWait = Random.Range(laughFrom, laughTo);
                    //This bool tels the script that it's alowed to run this script again after the time.
                    notLoopingLaugh = false;
                }
            }
        }
        if (pI.outOfFule)
        {
            wallHit();
        }
        //voiceTimer
        //Debug.Log(SoundClipLength);
        //makes shure there is an active soundclip
        if (SoundClipLength > 0)
        {
            //converts the value to another float so we can reset the float to not constantly refill it.
            TrueDuration = SoundClipLength;
        }
        // Sets a bool that the voice is being played
        voiceIsPlayed = true;
        //starts the timer by removing the time acording to the time left in the float.
        TrueDuration -= Time.deltaTime;
        // when there is no time left it lets the next voce be played.
        if (TrueDuration < 0)
        {
            voiceIsPlayed = false;
            TrueDuration = 0;
        }
        //resets the soundclip duration so we only refll the timer when there is an active clip playing.
        SoundClipLength = 0;
        //voiceTimer
    }
    void BoostParticles()
    {
        // you have to use main here for some reason.
        var main = pSystem1.main;
        //Boosts the particle speed making it emit faster
        main.startSpeed = particleBoosSpeed;
        var main2 = pSystem2.main;
        main2.startSpeed = particleBoosSpeed;
        // Changes the material of the flames to blue
        pSystem1Ren.material = blueFlame;
        pSystem2Ren.material = blueFlame;

    }
    void ResetParticles()
    {
        var main = pSystem1.main;
        main.startSpeed = originalParticleSpeed;
        var main2 = pSystem2.main;
        main2.startSpeed = originalParticleSpeed;
        pSystem1Ren.material = redFlame;
        pSystem2Ren.material = redFlame;
    }
    void voicePlayer(float playedVoice)
    {
        // Makes shure you die correctly.
        if (playedVoice == 5)
        {
            voiceIsPlayed = false;
            TrueDuration = 0;
        }
        // To interupt the laugh to make shure important dialog goes first
        if (lastPlayedVoice == 1)
        {
            voiceIsPlayed = false;
            TrueDuration = 0;
        }
        lastPlayedVoice = playedVoice;
        // Makes shure the character is not saying anyting or is dead.
        if (voiceIsPlayed == false && playerDead == false)
        {
            switch (playedVoice)
            {
                case 1:
                    // gets how long the array is
                    rangeScan = laughVoice.Length;
                    //selects a random nr from the leth of the array
                    toPlay = Random.Range(0, rangeScan);
                    //choses a random nr fro mthe array;
                    CurentVoiceClip = laughVoice[toPlay];
                    break;
                case 2:
                    rangeScan = cheeseDoodleVoice.Length;
                    toPlay = Random.Range(0, rangeScan);
                    CurentVoiceClip = cheeseDoodleVoice[toPlay];
                    break;
                case 3:
                    rangeScan = cheeseBallVoice.Length;
                    toPlay = Random.Range(0, rangeScan);
                    CurentVoiceClip = cheeseBallVoice[toPlay];
                    break;
                case 4:
                    rangeScan = doritoVoice.Length;
                    toPlay = Random.Range(0, rangeScan);
                    CurentVoiceClip = doritoVoice[toPlay];
                    break;
                case 5:
                    rangeScan = gonnaDieVoice.Length;
                    toPlay = Random.Range(0, rangeScan);
                    CurentVoiceClip = gonnaDieVoice[toPlay];
                    break;
                case 6:
                    rangeScan = cheeseWinVoice.Length;
                    toPlay = Random.Range(0, rangeScan);
                    CurentVoiceClip = cheeseWinVoice[toPlay];
                    break;
            }
            Debug.Log(CurentVoiceClip);
            //pauses the last played clip.
            voiceSource.Pause();
            //swiches clip.
            voiceSource.clip = CurentVoiceClip;
            //plays the new one.
            voiceSource.Play();
            // SoundClipLegth will be used to tell the animation engine how long to animate the talking/laghing loop.
            SoundClipLength = CurentVoiceClip.length;
            // Ends the animation a little sooner becuse of dead air in audio clips from encoding.
            soundAnimationTiming = SoundClipLength - 1.5f;
            //laughWaitTime tells the laghloop how long to wait to start again.
            laughWaitTime = SoundClipLength;
            // Sets the bool to stop the laugh loop and stopes the character from speaking when saying lines.
            voiceIsPlayed = true;
            //This controlls the animation on speach (at the moment laugh is used for all animations but will change in the future)
            pp_laugh = true;
            StartCoroutine(LaughAnimationTime(soundAnimationTiming));
            IEnumerator LaughAnimationTime(float time)
            {
                yield return new WaitForSeconds(time);
                pp_laugh = false;
            }
        }
    }
    //colider functions
    void OnTriggerEnter(Collider other)
    {
        switch (other.tag)
        {
            case "cheeseDoodle":
                {
                    pI.pickUpInteraction(1);

                    toSayCheeseDoodle = Random.Range(1, 100);
                    if (toSayCheeseDoodle < CheeseDoodleVoicerate)
                    {
                        playedVoice = 2;
                        voicePlayer(playedVoice);
                    }
                    pI.destroyPickUp(other.gameObject);
                    //other.gameObject.SetActive(false);
                }
                break;
            case "cheeseBall":
                {
                    pI.pickUpInteraction(2);
                    playedVoice = 3;
                    voicePlayer(playedVoice);
                    pI.destroyPickUp(other.gameObject);
                }
                break;
            case "dorito":
                {
                    pI.pickUpInteraction(3);
                    playedVoice = 4;
                    voicePlayer(playedVoice);
                    pI.destroyPickUp(other.gameObject);
                }
                break;
            case "safe":
                {
                    safeLanding();
                }
                break;
            case "wall":
                {
                    wallHit();
                }
                break;
            case "ground":
                {
                    playerDead = true;
                    //deathObject creates an expolsion with sound and particles on activation.
                    deathObject.gameObject.SetActive(true);
                    removeRocketFire();
                    ragdollPlayer();
                    pAnime.enabled = false;
                    //voiceObject.gameObject.SetActive(false);
                    pI.pickUpInteraction(4);
                }
                break;
            case "winningGround":
                {
                    playedVoice = 6;
                    voicePlayer(playedVoice);
                    safeLanding();
                    removeRocketFire();
                    // Does not kill the player but turns of movement.
                    playerDead = true;
                    rocketAnime.enabled = false;
                    pI.pickUpInteraction(5);
                }
                break;

        }
    }
    void wallHit()
    {
        //plays crash sound
        crashSoundSourse.Play();
        playedVoice = 5;
        voicePlayer(playedVoice);
        playerDead = true;
        removeRocketFire();
        ragdollPlayer();
        // showes in game menu if it takes to long for the player to hit the ground!
        StartCoroutine(waitToDie(7));
        IEnumerator waitToDie(float time)
        {
            yield return new WaitForSeconds(time);
            pI.pickUpInteraction(4);
        }
    }
    void removeRocketFire()
    {
        //stops rocket sound
        rocketBostAudio.gameObject.SetActive(false);
        rocketSoundObject.gameObject.SetActive(false);
        //Stops particle system
        pSystem1.Stop();
        pSystem2.Stop();
    }
    void safeLanding()
    {
        //plays a random bounce sound when player hits somthing safe.
        rangeScan = bounceSounds.Length;
        toPlay = Random.Range(0, rangeScan);
        CurentVoiceClip = bounceSounds[toPlay];
        bounceSoundScource.clip = CurentVoiceClip;
        bounceSoundScource.Play();
    }
}