Snake für Anfänger... Benötige Hilfe



  • Hallo allerseits.... Bin neu hier im Forum da ich eine Ausbildung zum Applikationsentwickler begonnen habe.
    Habe für mich zum Spass Snake probiert zu Programmieren 🙂 🙂 🙂
    Alles Funktioniert, aber wenn die Schlange den Apfel isst, verschwindet die irgendwo.... 😮 😮
    Ich vermute es liegt an dem "Schlange Array", wo der Feldwert wo sich die Schlange befindet speichert. So bald sich die nun um eins Verängern sollte, tritt ein Fehler auf.... Hoffe Ihr könnt mir helfen... 😃 😃 😃

    wurde im Visual Studio 2013 geschrieben...
    Hier der Code:

    /*##############################################################################
    #                                                                              #
    #                                                                              #
    #                                                                              #
    #     Name: Claudio Pazos                                                      #
    #     Datum: 01.11.2014                                                        #
    #     Aufgabe: Projekt                                                         #
    #                                                                              #
    #                                                                              #
    #                                                                              #
    ##############################################################################*/
    
    #include <iostream>
    #include <cstdlib>
    #include <stdio.h>
    #include <time.h>
    #include <iomanip>
    #include <windows.h>
    #include <conio.h>
    #include <stdlib.h>
    using namespace std;
    
    int fehler = 0;
    int ende = 0;
    char endeEingabe;
    int hz = 0;
    int feld[1801];
    int laenge = 5;
    int verlaengern = 0;
    int schlange[] = {444, 445, 446, 447, 448, 449};
    int zug;
    int richtung = 2;		// zeigt an ob die schlange nach (1 oben / 2 rechts / 3 unten / 4 links)
    char eingabeRichtung;
    int zeit = 10;
    int b;
    int verloren = 0;
    int buffer;
    
    int zufallFeld()
    
    {
    	int zz = (rand() % 1800 + 61);
    	return zz;
    }
    
    int zufallZeit()
    {
    	int zz = (rand() % 90 + 60);
    	return zz;
    }
    
    int apfel()
    {
    	if (zeit == 0)
    	{
    		do
    		{
    			b = zufallFeld();
    		} while (feld[b] != 0);
    		zeit = zufallZeit();
    	}
    	else
    	{
    		zeit--;
    	}
    	feld[b] = 3;
    	return 0;
    }
    
    int bewegung()
    {
    	if (_kbhit())
    	{
    		eingabeRichtung = _getch();
    		if (eingabeRichtung == 'w' || eingabeRichtung == 's' || eingabeRichtung == 'a' || eingabeRichtung == 'd')
    		{
    			if (eingabeRichtung == 'w' && richtung != 3)
    			{
    				richtung = 1;
    			}
    			else
    			{
    				if (eingabeRichtung == 's' && richtung != 1)
    				{
    					richtung = 3;
    				}
    				else
    				{
    					if (eingabeRichtung == 'a' && richtung != 2)
    					{
    						richtung = 4;
    					}
    					else
    					{
    						if (eingabeRichtung == 'd' && richtung != 4)
    						{
    							richtung = 2;
    						}
    					}
    				}
    			}
    		}
    	};
    
    	if (richtung == 1)
    	{
    		zug = -60;
    	}
    	else
    	{
    		if (richtung == 2)
    		{
    			zug = 1;
    		}
    		else
    		{
    			if (richtung == 3)
    			{
    				zug = 60;
    			}
    			else
    			{
    				if (richtung == 4)
    				{
    					zug = -1;
    				}
    			}
    		}
    	};
    
    	return zug;
    }
    
    int snake()
    {
    	if (feld[schlange[laenge]] == 3)
    	{
    		verlaengern = 1;
    	}
    	if(verlaengern == 0)
    	{
    		for (int x = 0; x <= laenge; x++)
    		{
    			feld[schlange[0]] = 0;
    			if (x < laenge)
    			{
    
    				schlange[x] = schlange[x + 1];
    			}
    			else
    			{
    
    				schlange[x] = schlange[x] + bewegung();
    
    			}
    		}
    	}
    	else
    	{
    		buffer = schlange[0];
    		for (int x = 0; x <= laenge; x++)
    		{
    			if (x < laenge)
    			{
    
    				schlange[x] = schlange[x + 1];
    			}
    			else
    			{
    
    				schlange[x] = schlange[x] + bewegung();
    
    			}
    		}
    		schlange[0] = buffer;
    		for (int x = 1; x <= laenge + 1; x++)
    		{
    			if (x < laenge)
    			{
    
    				schlange[x] = schlange[x + 1];
    			}
    			else
    			{
    
    				schlange[x] = schlange[x] + bewegung();
    
    			}
    		}
    		laenge++;
    		verlaengern = 0;
    	};
    
    	for (int x = 0; x <= laenge; x++)
    	{
    		feld[schlange[x]] = 2;
    	}
    
    	return 0;
    }
    
    int spielFeld()
    {
    	for (int x = 1; x <= 1800; x++)								   // Spielfeld wird generiert
    	{
    		if (x % 60 == 0 || (x - 1) % 60 == 0 || x <= 60 || x >= 1741) // Felder die eine Wand generieren
    		{
    
    			feld[x] = 1;
    		}
    		else														// Felder die ein Leeres Feld generieren
    		{
    			feld[x] = 0;
    		}
    
    	}
    
    	return 0;
    }
    
    int darstellung()
    {
    	for (int x = 1; x <= 1800; x++)									 // Darstellung
    	{
    		if (feld[x] == 1)
    		{
    			cout << "#";
    		}
    		else
    		{
    			if (feld[x] == 2)
    			{
    				cout << "+";
    			}
    			else
    			{
    				if (feld[x] == 3)
    				{
    					cout << "@";
    				}
    				else
    				{
    					cout << " ";
    				}
    			}
    		};
    
    		if (x % 60 == 0)
    		{
    			cout << endl;
    		};
    
    	}
    	return 0;
    }
    
    int main()
    {
    	cout << "******************************" << endl;
    	cout << "*  *                      *  *" << endl;
    	cout << "*    *  DEV by C.Pazos  *    *" << endl;
    	cout << "*      *              *      *" << endl;
    	cout << "*        *          *        *" << endl;
    	cout << "*            V2.0            *" << endl;
    	cout << "******************************" << endl << endl << endl;
    
    	srand(time(NULL));
    
    	do  //...
    	{
    		fflush(stdin);
    		fehler = 0;			//Bezeichnet, ob eine Fehleingabe erfolgt ist.
    		ende = 1;			//Ob das Programm beendet wird
    
    		cout << "******************************" << endl;
    		cout << "*           Snake            *" << endl;
    		cout << "******************************" << endl << endl << endl;
    
    		do
    		{
    			spielFeld();
    			apfel();
    			snake();
    			darstellung();
    			Sleep(300);
    			system("cls");
    		} while (verloren == 0);
    
    		cout << endl;
    
    		do
    		{
    			cout << "Erneut Spielen?" << endl;
    			cout << "'j' f\201r Ja oder 'n' f\201r Nein" << endl;
    			fflush(stdin);
    			cin >> endeEingabe;
    			if (endeEingabe == 'j' || endeEingabe == 'J' || endeEingabe == 'n' || endeEingabe == 'N')
    			{
    				if (endeEingabe == 'j' || endeEingabe == 'J')
    				{
    					ende = 1;
    					fehler = 0;
    				}
    				else
    				{
    					ende = 0;
    					fehler = 0;
    				}
    			}
    			else
    			{
    				cout << "Fehleingabe" << endl << endl << endl;
    				fflush(stdin);
    				cin.clear();
    				fehler = 1;
    			}
    		} while (fehler == 1);
    	} while (ende == 1);
    	return 0;
    }
    

    Für jede Hilfe bin ich sehr sehr dankbar....



  • Habe denn Fehler gefunden....
    Hab vergessen das Arrays feste grössen haben...
    Hab es auf 1000 vergrössert, und dass hat mein Problem gelösst. 😃 😃 😃 😃



  • Schau dir doch bitte mal std::vector an. Ist viel besser als ein festes Array.



  • Array sind für C besser geeignet als für C++. Vektoren haben ähnliche Eigenschaften und sind vom C++ Programmierstandart wesentlich aktueller. Außerdem würde ich für Angaben wie z.B. ob man verloren oder gewonnen hat den Datentyp Boolean (also bool) benutzen, da dieser weniger Speicher verbraucht als ein Int Datentyp.


  • Mod

    DarkLord44 schrieb:

    Außerdem würde ich für Angaben wie z.B. ob man verloren oder gewonnen hat den Datentyp Boolean (also bool) benutzen, da dieser weniger Speicher verbraucht als ein Int Datentyp.

    Speicherprobleme?



  • Ich meinte,dass man ob man z.B: verloren oder gewonnen hat besser in bool (Speicher ist systemabhängig) speichern sollte, da bool weniger Speicher benötigt als Integer (4 Bytes). Ein guter Programmcode soll ja möglichst wenig Ressourcen benötigen und möglichst effizient sein. In diesem Fall hat es nicht große Auswirkungen,aber wenn man z.B. größer Projekte in Angriff nimmt sollte man auf solche "Kleinigkeiten" schon achten.



  • DarkLord44 schrieb:

    Ich meinte,dass man ob man z.B: verloren oder gewonnen hat besser in bool (Speicher ist systemabhängig) speichern sollte, da bool weniger Speicher benötigt als Integer (4 Bytes). Ein guter Programmcode soll ja möglichst wenig Ressourcen benötigen und möglichst effizient sein. In diesem Fall hat es nicht große Auswirkungen,aber wenn man z.B. größer Projekte in Angriff nimmt sollte man auf solche "Kleinigkeiten" schon achten.

    Nö.
    Aber einen ja/nein-Wert in einen bool zu stopfen und einen 1/2/3/4/5-Wert in einen int, das wäre schlau, dann kann man den Code gleich viel besser lesen.
    ALso lieber inhaltliche Gründe als Speichergründe.
    1/2/3/4/5 würden auch in einen char passen, trotzdem wäre der int angemessener.

    Speichergründe kann man dann mal beachten, wenn die Probleme größer werden und man mit sowas hier keine Probleme mehr hat.


Anmelden zum Antworten