Exemplo n.º 1
0
    private IEnumerator EnableCollider2(Player player, Kugel kugel)
    {
        while (y < 0.15f)
        {
            y += Time.deltaTime;
            Debug.Log("waitign");
            yield return(null);
        }
        Debug.Log("finished");

        Physics.IgnoreCollision(player.GetComponent <Collider>(), GetComponent <Collider>(), false);
        y = 0;
    }
Exemplo n.º 2
0
    // Update is called once per frame
    void FixedUpdate()
    {
        PlayerInput();

        if (speedfactor > speedlimit)
        {
            speedfactor = speedlimit;
        }
        if (speed < minspeed)
        {
            speed = minspeed * SpeedPercentage;
        }
        speed = speedfactor * SpeedPercentage;


        zAxis   = transform.localPosition;
        zAxis.z = 0;
        transform.localPosition = zAxis;

        if (timer > 2)
        {
            speedblocker = false;
            timer        = 0;
        }
        if (speedblocker)
        {
            speedlimit = 0.5f;
            timer     += Time.deltaTime;
        }

        this.transform.rotation = new Quaternion(0, 0, 0, 0);

        if (SA_AttachedKugeln.Count > 0)
        {
            GetComponentInChildren <Image>().fillAmount = 0;

            var v3 = Input.mousePosition;
            v3.z = 10.0f;
            v3   = Camera.main.ScreenToWorldPoint(v3);
            //this.GetComponent<LineRenderer>().enabled = true;
            //this.GetComponent<LineRenderer>().SetPosition(0, this.transform.position);
            //this.GetComponent<LineRenderer>().SetPosition(1, Camera.main.ScreenToWorldPoint(Input.mousePosition));

            foreach (Kugel Kugel in SA_AttachedKugeln)
            {
                Kugel.kugelstate = KugelState.Loaded;

                Physics.IgnoreCollision(Kugel.GetComponent <Collider>(), GetComponent <Collider>(), true);
                this.GetComponent <LineRenderer>().SetPosition(0, Vector3.zero);
                Kugel.GetComponent <LineRenderer>().SetPosition(1, this.transform.position - Kugel.transform.position);
                if (Vector3.Distance(Kugel.transform.position, this.transform.position) > 0.1f)
                {
                    Kugel.delta += Time.deltaTime * 2;
                }
                Kugel.transform.position = Vector3.MoveTowards(Kugel.transform.position, this.transform.position, Kugel.delta);
            }
            if (singleplayer)
            {
                foreach (Kugel Kugel in SA_AttachedKugeln)
                {
                    if (Input.GetKeyDown(KeyCode.Space) && !Shoot && Vector3.Distance(this.transform.position, Kugel.transform.position) < 0.5f)
                    {
                        //Shoot = true;
                        foreach (obstacle obstacl in obstacle.All)
                        {
                            if (obstacl.obstaclestate == ObstacleState.DestructableWall)
                            {
                                if (Vector3.Distance(obstacl.transform.position, this.transform.position) < oldDistance)
                                {
                                    oldDistance    = Vector3.Distance(obstacl.transform.position, this.transform.position);
                                    current_target = obstacl;
                                }
                            }
                            //foreach (obstacle obstacl in obstacle.All)
                            //{
                            //    Vector3 screenPoint = Camera.main.WorldToViewportPoint(obstacl.transform.position);
                            //    bool onScreen = screenPoint.z > 0 && screenPoint.x > 0 && screenPoint.x < 1 && screenPoint.y > 0 && screenPoint.y < 1;
                            //}
                        }
                        if (current_target.obstaclestate == ObstacleState.DestructableWall)
                        {
                            Debug.Log("works");
                            GetComponent <AudioSource>().clip = aShot;
                            GetComponent <AudioSource>().Play();
                            Kugel.kugelstate = KugelState.Shot;
                            SA_AttachedKugeln.Remove(Kugel);
                            Kugel.GetComponent <Rigidbody>().AddForce((current_target.transform.position - this.transform.position).normalized * 55, ForceMode.Impulse);
                            Kugel.EnableCollider(this, Kugel);
                            current_target = null;
                            oldDistance    = 10000;
                            break;
                        }
                    }
                }
            }
            if (!singleplayer)
            {
                if (this == All[0])
                {
                    foreach (Kugel Kugel in SA_AttachedKugeln)
                    {
                        if (Input.GetKeyDown(KeyCode.Space) && !Shoot && Vector3.Distance(this.transform.position, Kugel.transform.position) < 0.5f)
                        {
                            //Shoot = true;

                            {
                                {
                                    GetComponent <AudioSource>().clip = aShot;
                                    GetComponent <AudioSource>().Play();
                                    Kugel.kugelstate = KugelState.Shot;
                                    SA_AttachedKugeln.Remove(Kugel);
                                    Kugel.GetComponent <Rigidbody>().AddForce((All[1].transform.position - this.transform.position).normalized * 55, ForceMode.Impulse);
                                    Kugel.EnableCollider(this, Kugel);
                                    break;
                                }
                            }
                        }
                    }
                }
                if (this == All[1])
                {
                    foreach (Kugel kugel in SA_AttachedKugeln)
                    {
                        if (Input.GetKeyDown(KeyCode.M) && !Shoot && Vector3.Distance(this.transform.position, kugel.transform.position) < 0.5f)
                        {
                            {
                                {
                                    GetComponent <AudioSource>().clip = aShot;
                                    GetComponent <AudioSource>().Play();
                                    kugel.kugelstate = KugelState.Shot;
                                    SA_AttachedKugeln.Remove(kugel);
                                    kugel.GetComponent <Rigidbody>().AddForce((All[0].transform.position - this.transform.position).normalized * 55, ForceMode.Impulse);
                                    kugel.EnableCollider(this, kugel);
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }

        if (SA_AttachedKugeln.Count == 0 && !SpecialAttackReady)
        {
            this.GetComponent <LineRenderer>().enabled = false;
            SAtimer += Time.deltaTime * 2;
            GetComponentInChildren <Image>().fillAmount = SAtimer;
            if (SAtimer > 1)
            {
                SAtimer            = 0;
                SpecialAttackReady = true;
            }
        }
    }
Exemplo n.º 3
0
    // Update is called once per frame
    void Update()
    {
        float[] spectrum = AudioListener.GetSpectrumData(1024, 0, FFTWindow.Hamming); //Reading the spectrum from the song put into the AudioListener
        float[] samples  = AudioListener.GetOutputData(1024, 0);


        //Adding up all the samples, for approximate overall "volume"
        float vol = 0;

        foreach (float sample in samples)
        {
            if (sample >= 0)
            {
                vol += sample;
            }
            else
            {
                vol -= sample;
            }
        }


        //Adding up first 20 floats in spectrum to determine a volume for the bass
        float bass = 0;

        for (int i = 0; i < 30; i++)
        {
            if (spectrum[i] >= 0)
            {
                bass += spectrum[i];
            }
            else
            {
                bass -= spectrum[i];
            }
        }



        /*
         * spawn spheres according to the volume of the music
         *
         * */
        for (int i = 0; i < (vol / 100) * amount; i++)

        {
            //create Random values for position, size, color and speed

            int     posX  = Random.Range(rangeXmin, rangeXmax);
            int     posZ  = Random.Range(rangeYmin, rangeYmax);
            int     col   = Random.Range(0, 4);
            int     size  = Random.Range(minSize, maxSize);
            int     speed = Random.Range(1, 6);
            Vector3 pos   = new Vector3(posX, -10, posZ);

            //create an Object Kugel with these values
            Kugel kug = new Kugel(sphere, pos, size, speed);

            // assign color to object
            if (col < Settings.Active.ColorScheme.Colors.Length)
            {
                kug.theSphere.GetComponent <Renderer>().material.color = Settings.Active.ColorScheme.Colors [col];
            }


            // store kug  in spheres
            for (int f = 0; f < spheres.Length; f++)
            {
                if (spheres[f] == null || spheres[f].theSphere == null)
                {
                    spheres[f] = kug;
                    break;
                }
            }
        }

        //destroy objects if they are too high
        GameObject[] look = GameObject.FindGameObjectsWithTag("Spheres");
        for (int j = 0; j < look.Length; j++)
        {
            if (look[j].transform.position.y >= 200)
            {
                Destroy(look[j]);
            }
        }

        //change Size according to bass
        try
        {
            for (int f = 0; f < spheres.Length; f++)
            {
                spheres[f].groesse(bass);
            }
        }
        catch
        {
        }
    }
Exemplo n.º 4
0
 public void EnableCollider(Player player, Kugel kugel)
 {
     StartCoroutine(EnableCollider2(player, kugel));
 }