Esempio n. 1
0
 /// <summary>
 /// Löscht den Stein aus dem Spielfeld raus
 /// </summary>
 /// <param name="stein"></param>
 private void Loeschen(Spielstein stein)
 {
     spielfeld[stein.x1, stein.y1] = 0;
     spielfeld[stein.x2, stein.y2] = 0;
     spielfeld[stein.x3, stein.y3] = 0;
     spielfeld[stein.x4, stein.y4] = 0;
 }
Esempio n. 2
0
 /// <summary>
 /// Zeichnet den Stein an seiner aktuellen Position ins Spielfeld ein
 /// </summary>
 /// <param name="stein"></param>
 private void Setzen(Spielstein stein)
 {
     spielfeld[stein.x1, stein.y1] = stein.FarbCode;
     spielfeld[stein.x2, stein.y2] = stein.FarbCode;
     spielfeld[stein.x3, stein.y3] = stein.FarbCode;
     spielfeld[stein.x4, stein.y4] = stein.FarbCode;
 }
Esempio n. 3
0
        /// <summary>
        /// Prüft, ob der Stein an seiner aktuellen Position im Spielfeld gezeichnet werden kann
        /// </summary>
        /// <param name="stein"></param>
        /// <returns></returns>
        private bool Setzbar(Spielstein stein)
        {
            int farbe = stein.FarbCode;

            // Ist Spielfeld an der Position leer oder enthält die gleiche Farbe wie der aktuelle Stein? (wird für "Geisterstein" in der Methode Verschiebbar benötigt)
            return((spielfeld[stein.x1, stein.y1] == farbe || spielfeld[stein.x1, stein.y1] == 0) &&
                   (spielfeld[stein.x2, stein.y2] == farbe || spielfeld[stein.x2, stein.y2] == 0) &&
                   (spielfeld[stein.x3, stein.y3] == farbe || spielfeld[stein.x3, stein.y3] == 0) &&
                   (spielfeld[stein.x4, stein.y4] == farbe || spielfeld[stein.x4, stein.y4] == 0));
        }
Esempio n. 4
0
        private bool Drehbar(Spielstein einSpielstein)
        {
            if (einSpielstein == null)
            {
                return(false);
            }
            Spielstein verschobenerSpielstein = einSpielstein.Kopie();

            verschobenerSpielstein.Drehen();
            return(Setzbar(verschobenerSpielstein));
        }
Esempio n. 5
0
        /// <summary>
        ///  Prüft, ob der gegebene Spielstein in die gewünschte Richtung bewegt werden kann
        /// </summary>
        /// <param name="einSpielstein"></param>
        /// <param name="richtung"></param>
        /// <returns></returns>
        private bool Verschiebbar(Spielstein einSpielstein, Richtung richtung)
        {
            if (einSpielstein == null)
            {
                return(false);
            }

            // "Geisterstein" erzeugen
            Spielstein verschobenerSpielstein = einSpielstein.Kopie();

            // mit Geisterstein die Bewegung simulieren
            verschobenerSpielstein.Verschieben(richtung);

            // Wenn Geisterstein an seiner neuen position setzbar, true zurückgeben
            return(Setzbar(verschobenerSpielstein));
        }
Esempio n. 6
0
        private void Ablegen(Spielstein einSpielstein)
        {
            if (einSpielstein == null)
            {
                return;
            }

            einSpielstein.FarbCode = einSpielstein.FarbCode + 8;
            Setzen(einSpielstein);

            stats.Score += 10;

            // Hier exisistert noch ein Bug bei dem die Zeilen nicht verschwinden wenn größer x2 und mehrere Zeilen abgebaut werden sollen.
            // Lösung: Koordinaten vorher sortieren

            var yKoords = new int[4];

            yKoords[0] = einSpielstein.y1;
            yKoords[1] = einSpielstein.y2;
            yKoords[2] = einSpielstein.y3;
            yKoords[3] = einSpielstein.y4;

            Array.Sort(yKoords);

            foreach (var y in yKoords)
            {
                for (int i = 1; i <= xmax; ++i)
                {
                    if (spielfeld[i, y] == 0)
                    {
                        break;
                    }
                    if (i == xmax)
                    {
                        ZeileLöschen(y);
                    }
                }
            }

            stats.Score += 100;
            gui.Update(this.spielfeld);
        }
Esempio n. 7
0
        /// <summary>
        /// Erzeugt einen neuen Spielstein
        /// </summary>
        private void NeuerSpielstein()
        {
            var randomInt  = (int)(random.Next(1, 8));
            var neuerStein = new Spielstein(randomInt);

            // Wenn neuer Stein nicht setzbar, ist das Spiel zu Ende
            if (Setzbar(neuerStein))
            {
                aktSpielstein = neuerStein;

                // Kann der neue Stein nicht mehr verschoben werden, wird er sofort abgelegt. Danach ist das Spiel zu Ende.
                if (Verschiebbar(aktSpielstein, Richtung.Unten) || Verschiebbar(aktSpielstein, Richtung.Links) || Verschiebbar(aktSpielstein, Richtung.Rechts))
                {
                    return;
                }
                else
                {
                    Ablegen(aktSpielstein);
                }
            }
            aktSpielstein = null;
            GameOver();
        }
Esempio n. 8
0
 /// <summary>
 /// Stein wird im Spielfeld in die gewünschte Richtung verschoben
 /// </summary>
 /// <param name="einSpielstein"></param>
 /// <param name="richtung"></param>
 private void Verschieben(Spielstein einSpielstein, Richtung richtung)
 {
     Loeschen(einSpielstein);
     einSpielstein.Verschieben(richtung);
     Setzen(einSpielstein);
 }
Esempio n. 9
0
 private void Drehen(Spielstein stein)
 {
     Loeschen(stein);
     stein.Drehen();
     Setzen(stein);
 }