Visual Studios anderer Kopf bei einer Schlange?

...komplette Frage anzeigen

3 Antworten

Kannst du uns den Code zeigen womit du die Schlange zeichnest?

Hast du die Positionen in einem Array gespeichert so würdest du bei der ersten (oder letzten) Position des Arrays eben einen anderen Char zeichnen. Ohne dein Code ist es aber unmöglich zu sagen wie du es umsetzen solltest.

JECKIJ 19.12.2016, 15:33

 class Program
    {
        static void Main(string[] args)
        {
            // EIN COMPUTERSPIEL
            bool spielEnde;
            double spielerX, spielerY;
            int richtungX, richtungY;
            int frames, framesPerSecond;
            DateTime letzteZeitmessung;
            DateTime letzteFpsBerechnung;
            double geschwindigkeit;
            Random zzGenerator = new Random();
          
            char[] spielfeld;
            spielfeld = new char[Console.WindowWidth * Console.WindowHeight];
            char nächsterBuchstabe = 'A';
            DateTime spielbeginn = DateTime.Now;

            int körperlänge = 5;

            List<int> körper;
            körper = new List<int>();
           
         
            SpielfeldAufbauen(zzGenerator, ref spielfeld);

         
            spielEnde = false;
            spielerX = Console.WindowWidth / 2;
            spielerY = Console.WindowHeight / 2;

          
            int spielerkoordinate = ((int)spielerY * Console.WindowWidth) + (int)spielerX;
            körper.Add(spielerkoordinate);

            richtungX = richtungY = 0;
            frames = framesPerSecond = 0;
          
            geschwindigkeit = 10 / 1000.0; // 5 Zeichen Pro Sekunde

            letzteZeitmessung = letzteFpsBerechnung = DateTime.Now;
            spielbeginn = DateTime.Now;
           
            // solange das Spiel läuft
            while (! spielEnde)
            {
                frames++;
                DateTime jetzt = DateTime.Now;
                TimeSpan vergangeneZeit = jetzt - letzteZeitmessung;
                if ((jetzt - letzteFpsBerechnung).TotalMilliseconds >= 1000)
                {
                    letzteFpsBerechnung = jetzt;

                    framesPerSecond = frames; //FPS = die ANzal der Frames in einer Sekunde
                    frames = 0; // wir beginnen von neum zu zählen

                }
              

              
                spielEnde = BearbeiteSpieleEingabe(ref richtungX, ref richtungY);

            
                if (spielEnde == false)
                spielEnde = AktualisiereDasSpiel(ref spielerX, ref spielerY, körper, ref körperlänge, richtungX, richtungY,ref geschwindigkeit, vergangeneZeit, spielfeld, ref nächsterBuchstabe, spielbeginn);

             
                RendereStartistik(framesPerSecond, nächsterBuchstabe, spielbeginn);
                RendereDasSpiel(spielerX, spielerY, spielfeld, nächsterBuchstabe);

                letzteZeitmessung = jetzt;
            }

 

            // Spiel beenden
        }
 private static void RendereDasSpiel(double spielerX, double spielerY,char[] spielfeld, char nächsterBuchstabe)
        {
            for (int i = 0; i < spielfeld.Length; i++)
            {
                if (spielfeld[i] == nächsterBuchstabe)
                {
                    int y = i / Console.WindowWidth;
                    int x = i % Console.WindowWidth;

                    GeheZu(x, y);
                    ConsoleColor vorherigeFarbe = Console.ForegroundColor;
                    Console.ForegroundColor = ConsoleColor.Red;

                    Console.Write(nächsterBuchstabe);

                    Console.ForegroundColor = vorherigeFarbe;

                }
            }

0
JECKIJ 19.12.2016, 15:38

Das Restliche konnte ich leider nicht kommentieren, also steht es als Antwort.

0

Das gehört zwischen die beiden.

 

         GeheZu((int)spielerX, (int)spielerY);
            Console.Write('@');

        }

        private static void RendereStartistik(int frames, char nächsterBuchstabe, DateTime spielbeginn)
        {
            GeheZu(1, 0);
            Console.Write(frames);

            GeheZu(10, 0);
            Console.Write($"zu fressen: {nächsterBuchstabe}");

            GeheZu(20, 0);
            TimeSpan spieldauer = DateTime.Now - spielbeginn;

            GeheZu(40, 0);
            Console.Write($"Spieldauer: {spieldauer.ToString()}");
        }

        private static bool AktualisiereDasSpiel(ref double spielerX, ref double spielerY, List<int> körper, ref int körperlänge, int richtungX, int richtungY, ref double geschwindigkeit, TimeSpan vergangeneZeit, char[]spielfeld, ref char nächsterBuchstabe, DateTime spielbeginn)
        {
            //     deltaX = +1        * (   5            * 0.005)
            bool spielMussBeendetWerden = false;

            double deltaX = richtungX * (geschwindigkeit * vergangeneZeit.TotalMilliseconds);
            double deltaY = richtungY * (geschwindigkeit * vergangeneZeit.TotalMilliseconds * 0.65);

         
            if ((spielerX + deltaX) != spielerX || (spielerY + deltaY) !=spielerY)
            {
                if (körper.Count > körperlänge)
                {
                 
                    int koordinateDesKörperendes = körper.ElementAt(0);

                    int körperendeX = koordinateDesKörperendes % Console.WindowWidth;
                    int körperendeY = koordinateDesKörperendes / Console.WindowWidth;

                   
                    GeheZu(körperendeX, körperendeY);

                    Console.Write(" ");
                    spielfeld[koordinateDesKörperendes] = ' ';

               
                    körper.RemoveAt(0);
                }
               
            }
            // Die aktuelle Spilerposition merken bevor sie verändert wird!
            int altesX = (int)spielerX;
            int altesY = (int)spielerY;

            // Neue Spilerposition setzen
            spielerX = spielerX + deltaX;
            spielerY = spielerY + deltaY;

            // Die Spielfeldgrenzen prüfen, ob der Spieler das Spielfeld
            // auch nicht verlässt
            spielerX = Math.Max(1, spielerX);
            spielerX = Math.Min(spielerX, Console.WindowWidth - 2);
            spielerY = Math.Max(1, spielerY);
            spielerY = Math.Min(spielerY, Console.WindowHeight - 2);

            // In die Körperliste wird die neue Spilerpsition NUR aufgenommen,
            //falls sie sich von der alten Spielerposition unterscheidet!
            int x = (int)spielerX; //Hilfvar. um int-WEr fpr das "if" zu haben
            int y = (int)spielerY;

            if (altesX != x || altesY != y)
            {
                int spielerkoodinate = (y * Console.WindowWidth) + x;
                körper.Add(spielerkoodinate);

            }
        

            if (spielfeld [(y*Console.WindowWidth) + x] !=' ')
            {
               
                if (spielfeld[(y * Console.WindowWidth) + x] == nächsterBuchstabe)
                {
                   
                  
                    if (nächsterBuchstabe == 'Z')
                    {
                        spielMussBeendetWerden = true;
                    }
                    else
                    {
                        spielMussBeendetWerden = false; 
                    }

                  
                    // wir fressen als nächsten Buchstaben, jenen in ASCII-Tabelle
                    //der einen Code + 1 aufweist!

                    nächsterBuchstabe++;
                    körperlänge += 2;

                  
                    spielfeld[(y * Console.WindowWidth) + x] = ' ';

                    geschwindigkeit += 1.25 / 1000.0;

                   
                }
                else
                {
                   
                    if (altesX == x && altesY == y && spielfeld[(y * Console.WindowWidth) + x] == '@')
                    {
                        spielMussBeendetWerden = false;
                    }
                    else
                    {
                        spielMussBeendetWerden = true;
                    }
                }
            }
            if (altesX != x || altesY != y)
            {
                spielfeld[(y * Console.WindowWidth) + x] = '@';
            }

                return spielMussBeendetWerden;
        }

        private static bool BearbeiteSpieleEingabe(ref int richtungX, ref int richtungY)
        {
            bool spielIstZuEnde = false;
            if (Console.KeyAvailable) // Test, ob eine Taste gedrückt wurde
            {
                ConsoleKeyInfo tastenInfo = Console.ReadKey(true);
                if (tastenInfo.Key == ConsoleKey.Escape)
                {
                    spielIstZuEnde = true;
                }
                if (tastenInfo.Key == ConsoleKey.LeftArrow)
                {
                    // Corsor links
                    //spielerX--;
                    richtungX = -1;
                    richtungY = 0;

                }
                if (tastenInfo.Key == ConsoleKey.RightArrow)
                {
                    //Corsor rechts
                    //spielerX++;
                    richtungX = +1;
                    richtungY = 0;
                }
                if (tastenInfo.Key == ConsoleKey.UpArrow)
                {
                    //Cusor auf
                    // spielerY--;
                    richtungX = 0;
                    richtungY = -1;
                }
                if (tastenInfo.Key == ConsoleKey.DownArrow)
                {
                    //Cusor ab
                    //spielerY++;
                    richtungX = 0;
                    richtungY = +1;
                }
            }
            return spielIstZuEnde;
        }

 

        // SPIELFELD
        private static void SpielfeldAufbauen(Random zzg, ref char[] spielfeld)
        {
            Console.CursorVisible = false;
            Console.BackgroundColor = ConsoleColor.DarkGreen;
            Console.ForegroundColor = ConsoleColor.White;
            Console.Clear();

            GeheZu(1, 1);

 

           
            for (int x = 0; x < 1; x++)
            {
                GeheZu(x, 0);
                Console.Write('╔');
            }

            for (int x = 1; x < Console.WindowWidth - 1; x++)
            {
                GeheZu(x, 0);
                Console.Write('═');
            }

            // linke senkrechte Linie
            for (int y = 1; y < Console.WindowHeight - 1; y++)
            {
                GeheZu(0, y);
                Console.Write('║');
            }

            for (int x = 0; x < 1; x++)
            {
                GeheZu(x, Console.WindowHeight - 1);
                Console.Write('╚');
            }

         
            for (int x = 1; x < Console.WindowWidth - 1; x++)
            {
                GeheZu(x, Console.WindowHeight - 1);
                Console.Write('═');
            }

  
            for (int y = 0; y < 1; y++)
            {
                GeheZu(Console.WindowWidth - 1, y);
                Console.Write('╗');
            }

        
            for (int y = 1; y < Console.WindowHeight - 1; y++)
            {
                GeheZu(Console.WindowWidth - 1, y);
                Console.Write('║');
            }

           
            for (int y = 0; y < 1; y++)
            {
                GeheZu(Console.WindowWidth - 1, Console.WindowHeight - 1);
                Console.Write('╝');
            }
           
            for (int zeile = 0; zeile < Console.WindowHeight; zeile++)
            {
                for (int spalte = 0; spalte < Console.WindowWidth; spalte++)
                {
                    spielfeld[(zeile * Console.WindowWidth) + spalte] = ' ';
                }
            }

            for (char zeichen = 'A'; zeichen <= 'Z'; zeichen++)
            {
                int buchstabenXPos = zzg.Next(1, Console.WindowWidth - 1);
                int buchstabenYPos = zzg.Next(1, Console.WindowHeight - 1);

              
                while (spielfeld[(buchstabenYPos*Console.WindowWidth) + buchstabenXPos] != ' ')
                {
                    buchstabenXPos = zzg.Next(1, Console.WindowWidth - 1);
                    buchstabenYPos = zzg.Next(1, Console.WindowHeight - 1);
                }

                GeheZu(buchstabenXPos, buchstabenYPos);
                Console.Write(zeichen);

              
                spielfeld[buchstabenYPos * Console.WindowWidth + buchstabenXPos] = zeichen;
            }

        }

        // Funktion benötigt für SPIELFELD
        private static void GeheZu(int x, int y)
        { 
           Console.SetCursorPosition(x, y);
        }
    }
}

Was möchtest Du wissen?