public Sheep(RenderContext rc, float3 position, float3 rotation, float3 scaleFactor,  SceneRenderer sc, Game game)
            : base(rc, position, rotation, scaleFactor, sc)
        {
            _distance = position.Length;
            if (_distance > 60)
            {
                _score = 120;
            }
            if (_distance > 40)
            {
                _score = 80;
            }
            else
            {
                _score = 50;
            }
            Speed = (5 / _distance) * game.Level;
            Radius = 4f;
            _game = game;
            Pos = position;
            _alpha = (float)Math.Tan(Pos.z/Pos.x);
            Tag = "Sheep";
            _level = 1;
            //zufällige Wellenbewegung

            if (position.x % 2 == 0)
            {
                TheWave = SinWave;
            }
            else
            {
                TheWave = CosWave;
            }
        }

 //initilization
 void Start() {
     Wave SetWave = new Wave(maxAnimats, 0.5f);
     waves = new Wave[] { SetWave , SetWave , SetWave , SetWave , SetWave };
     FirstWave();
     FindObjectOfType<SunControls>().NightFall += RecallAnimats;
     FindObjectOfType<SunControls>().DayBreak += UnDock;
 }

    void NextWave()
    {
        currentWaveNumber++;
        if(currentWaveNumber -1 < waves.Length){
            currentWave = waves[currentWaveNumber-1];
        }

        enemiesRemainingToSpawn = currentWave.enemyCount;
        enemiesRemainingAlive = enemiesRemainingToSpawn;

        if(OnNewWave != null) {
            OnNewWave( currentWaveNumber );
        }
        ResetPlayerPosition();

        if (!currentWave.infinite)
        {
            gameUI.waveText.text = "Wave #: " + currentWaveNumber;
            gameUI.enemiesLeftText.text = "Enemies left: " + enemiesRemainingAlive;
        }
        else
        {
            gameUI.waveText.text = "Wave #: Infinite";
            gameUI.enemiesLeftText.text = "Enemies left: Infinite";
        }
    }

 void Start()
 {
     if (m_currentLevel.HasWavesRemaining)
     {
         m_currentWave = m_currentLevel.NextWave;
     }
 }

 public Wave CreateWave(Round round)
 {
     // lookup pool by type
     Wave wave = new Wave(round.waves.Count);
     round.waves.Add(wave);
     return wave;
 }

 private static float LaunchDelaySeconds(Wave original)
 {
     var delay = original.LaunchDelaySeconds  - .05f;
     if (delay < .4f)
         delay = .4f;
     return delay;
 }

 private static float PositionUpdateDelaySeconds(Wave original)
 {
     var delay =  original.PositionUpdateDelaySeconds - .01f;
     if (delay < .2f)
         delay = .2f;
     return delay;
 }

        private void LoadLevel(string levelName)
        {
            var doc = new XmlDocument();
            doc.Load("Assets/Resources/Levels/{0}.xml".ToFormat(levelName));
            var waves = doc.SelectSingleNode("Waves");

            foreach (XmlNode wave in waves.SelectNodes("Wave"))
            {
                var w = new Wave
                {
                    BeforeWaveDelay = float.Parse(wave.GetAttributeOrDefault("BeforeWaveDelay", "0")),
                    EnemiesToSpawn = new List<GameObject>()
                };

                foreach (XmlNode enemy in wave.SelectNodes("Enemy"))
                {
                    var e = (GameObject) Instantiate(
                        Resources.Load("Prefabs/Enemies/" + enemy.GetAttributeOrDefault("Type", "Popcorn")));
                    var ecom = e.GetComponent<Enemy>();
                    ecom.X = float.Parse(enemy.GetAttributeOrDefault("X", "0"));
                    ecom.Spawn = float.Parse(enemy.GetAttributeOrDefault("Spawn", "0"));
                    ecom.Speed = float.Parse(enemy.GetAttributeOrDefault("Speed", "5"));
                    ecom.transform.Translate(0, 20, 0);
                    e.gameObject.SetActive(false);

                    w.EnemiesToSpawn.Add(e);
                }

                _waves.Add(w);
            }
        }

	void Start() 
    {
        if (StartSpawning)
            Spawning = true;

        CurrentWave = Waves[0];
	}

 private void CheckForNewWave()
 {
     if (Waves.IndexOf(CurrentWave) != GameManager.CurrentStage)
     {
         CurrentWave = Waves[GameManager.CurrentStage - 1];
     }
 }

    private void NextWave()
    {
        currentWaveNumber++;
        currentWave = waves[currentWaveNumber - 1];

        enemyRemainingToSpawn = currentWave.enemyCount;
    }

    //public Seq[] sequences;
    // Use this for initialization
    void Start()
    {
        var cz = GetComponent<CombatZone>();
        var wCount = 0;
        foreach (Wav wav in waves) {
            var w = new Wave();
            cz.spawnWaves.Add(w);
            cz.spawnWaves[wCount].delayNextSeq = wav.delaySeq;
            foreach (Seq seq in wav.sequences) {

                    var sq = new Sequence ();
                    cz.spawnWaves [wCount].spawnSeqs.Add (sq);
                    sq.delayNextEvent = seq.delay;
                    sq.pos = seq.pos;
                    for (int i=0; i<seq.amount; i ++) {
                            var e = new SpawnEvent ();//sq.spawnEvents[i];
                            e.enemyType = seq.eType;
                            e.equipped = seq.equipped;
                            e.paratrooper = seq.chute;
                            Vector2 p = transform.position;
                            e.offset = p + sq.pos + (seq.offset * i);
                            sq.spawnEvents.Add (e);
                    }

            }
            wCount++;
        }
    }

 void SpawnWave(Wave w)
 {
     for (int i = 0; i < w.waves.Length; i++) {
         SpawnEnnemy (w.waves [i].number, w.waves [i].health, w.waves [i].speed, w.waves [i].color, w.waves [i].size, (float)(i * 1.2f));
     }
     waveSpawnEnd = true;
 }

 /// <summary>
 /// Spawns a wave of enemies
 /// </summary>
 /// <param name="wave">a Wave object containing enemies</param>
 /// <returns>A time in seconds to wait</returns>
 IEnumerator SpawnWave(Wave wave)
 {
     foreach (string enemy in wave.wave)
     {
         SpawnEnemy(enemy);
         yield return new WaitForSeconds(2);
     }
 }

 // ---- getters & setters ----
 // ---- constructor ----
 public Round()
 {
     this.OnIndexChange += delegate {
         SetEventHandlers(currentWave, false);
         currentWave = selectedItem as Wave;
         SetEventHandlers(currentWave, true);
     };
 }

 void Spawn(Wave wave)
 {
     for(int i = 0; i < wave.numWaves; i++)
     {
         int spawnPointIndex = Random.Range (0, spawnPoints.Length);
         Instantiate (wave.getEnemy(i), spawnPoints [spawnPointIndex].position, spawnPoints [spawnPointIndex].rotation);
     }
 }

 public void DoWave(Wave wave)
 {
     wave.Done = true;
     foreach(AnimalSpec spec in wave.Animals)
     {
         SpawnAnimals(spec);
     }
 }

        Wave wave; //wav file wrapper

        #endregion Fields

        #region Constructors

        //constructor takes in a Wave object which is used to initialize the fields
        public MapMaker(Wave w)
        {
            wave = w;
            wavAudio = new Audio(wave, 1000000);//1000000

            SBD = new StatBeatDetection(wave, 1000000);

            soundInformation = new SoundInfo[SBD.length() + 1];
        }

 IEnumerator spawnCoroutine(Wave wave)
 {
     for(int i = 0; i < wave.numWaves; i++)
     {
         int spawnPointIndex = Random.Range (0, spawnPoints.Length);
         Instantiate (wave.getEnemy(i), spawnPoints [spawnPointIndex].position, spawnPoints [spawnPointIndex].rotation);
         yield return new WaitForSeconds(1);
     }
 }

 public Visualizer(Wave song)
 {
     this.song = song;
     blank = new Texture2D(Globals.graphics.GraphicsDevice, 1, 1, false, SurfaceFormat.Color);
     blank.SetData(new[] { Color.White });//blank texture
     for (int i = 0; i < 30; i++)
     {
         points[i] = new Vector2(850, 645);//fill points with default values
     }
 }