Ping Pong Fertig

Keiner hätte es geglaubt, aber es Funtkioniert auch im Banalen C, wenn jemand seinen spaß drann haben will xD

#include <conio.h>		//Einbindung von conio.h für die Funktion getch()
#include <iostream>     //Einbindung von iostream für die Funktionen cin und cout
#include <windows.h>    //Einbindung von windows.h für die Funktion PlaySoundA sowie GetKeyState
#include <mmsystem.h>	//Einbindung von mmystem.h für die Funktion PlaySoundA
#pragma comment(lib,"winmm.lib") //Die library winmm.lib wird eingebunden(genaure Erklärung zufinden in der schriftlichen Ausarbeitung)

using namespace std;	//namespace std; Deklaration

/*"using namespace std" ist eine Direktive. 
Im Gueltigkeitsbereich der Datei wird der Namensbereich (namespace)
mit dem Namen std zur Verfügung (using) gestellt.
Man kann dies auch weglassen, dann müsste man aber überall cout durch std::cout ersetzen, 
weil die globale Variable cout zum Namensbereich std gehört. 
Mit dieser Direktvie tut man das einfach gesagtdem Compiler vorher sagen"*/

void spiel();			//Hauptfunktion des Spieles hier wird das Spiel aufgerufen
void start();           //Logo-Ausgabe und Eingabefunktion zur Auswahl
void spielfeld();       //Deklaration des Spielfeld-Array, Wiederholung so wie Abfrage der Bewegungen

void bewegung1(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 1
void bewegung2(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 2
void bewegung3(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 3
void bewegung4(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 4		
void bewegung5(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 5
void bewegung6(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 6
void bewegung7(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 7
void bewegung8(char spielfeld[21][51], int &y);		 //Bewegungs Szenario 8
void spielfeldausgabe(char spiel[20][51]);			 //Ausgabe des (manipulierten) Spielfeld-Arrays.
void spielerbewegung(char spielfeld[21][51], int &y);//Eingabefunktion des Spielers
void verloren(int *pscore);			//Ausgabe des Punkte-Standes und Bewertung
void highscore(int *pscore);        //Komplette Ausgabe des Highscores 
void highscoreausgabe();
void lesen(int &a, int &b, int &c);
void vergleich(int *punkte,int &a, int &b, int &c);
void speichern(int feld0,int feld1,int feld2);
void abschluss();			          //Funktion zur Beendung des Spieles
void bildhalten();				      //Funktion um das Spiel anzuhalten und das Fenster offen zu halten 

void main()
{
	spiel();		//Funktion void spiel() wird Aufgerufen

}
void spiel()
{
	start();		//Funktion void start() wird Aufgerufen

}
void start()
{
	int wahl;						//Wert wahl wird deklariert																
	char ponglogo[18][56]=			//pong logo wird deklariert und initialisiert
{
(" *     *           *         *       *          *      "),
("  _____  _    *         *   _____         *            "),
(" |  __  (_)         *      |  __    *               *  "),
(" | |__) | |_ __   __ _     | |__) |___  _ __   __ _    "),
(" |  ___/| |  _   / _  |    |  ___// _  |  _   / _  |   "),
(" | |    | | | | | (_| | *  | |   | (_) | | | | (_| |   "),
(" |_|  * |_|_| |_| __, |    |_|     ___/|_| |_| __, |   "),
("  *               __/ |        *               __/ |   "),
("             *   |___/   *                    |___/  * "),
("  *                               *       *            "),
("  _____  *         *                  _ _     _   *    "),
(" |_   _|    *          *     *       (_) |   | |       "),
("   | |  _ __ ___  _ __   ___  ___ ___ _| |__ | | ___ * "),
("   | | |  _   _  |  _   / _  / __/ __| |  _  | |/ _    "),
("  _| |_| | | | | | |_) | (_)  __  __   | |_) | |  __/  "),
(" |_____|_| |_| |_|  __/  ___/|___/___/_|_ __/|_| ___|  "),
("  *      *       | |      *        *      *       *    "),
("      *     *    |_|  *      *        *      *         ") 
};

	system("cls");												 //Bildschirm wird gelöscht	
	cout<<endl;
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 9);
	for(int x=0;x<=17;x++)										 //For Schleife Zählt 18 Spalten hoch
	{
		for(int y=0;y<=55;y++)									 //For Schleife zählt 56 Zeilen hoch
		{
		cout<<ponglogo[x][y];									 //Spalte x und Zeile y wird ausgegeben
		}
		cout<<endl;												 //Springt in die nächste Zeile
	}

	PlaySoundA("intro.wav",NULL,SND_LOOP|SND_ASYNC);			 //Wave Datei Intro wird aufgerufen/abgespielt in einer Daurschleife	
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 4); //Funktion zur Ausgabe eines farbigen Textes[ROT]

	cout<<endl<<endl<<endl<<endl<<" Spielstart = 1   Highscore = 2   Spiel beenden = 3  "; 
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 15);  //Funktion zur Ausgabe eines farbigen Textes[WEIS]
	cin>>wahl;													   //Werteingabe zur Wahl des Modus	

	PlaySoundA("leer.wav", NULL,SND_ASYNC);						   //Beendung des Sound Intros durch leere wave

	switch(wahl)				//setzt die Bedinung für die Variable wahl
	{
	case 1:
		system("cls");
		spielfeld();			//Bei Eingabe 1: wird das "Hauptspiel" aufgerufen
		break;
	case 2:
		 system("cls");
		 highscoreausgabe();
				    //Bei Eingabe 2: wird der Highscore aufgerufen
		 break;

	case 3:
		system("cls");
		abschluss();			//Bei Eingabe 3: Spielende
		break;

	default:					//Bei Eingabe einer nicht angegeben Zahl 
		system("cls");	
	    char falscheingabe[500]=//Falscheingabe vom Typ Char wird deklariert und anschl. initialisiert. 
		{                                                                                                                                   
			".___   .      .       .___          .     \n"
			"[__  _.| __ _.|_  _   [__ *._  _  _.|_  _ \n"
			"|   (_]|_) (_.[ )(/_  [___|[ )(_](_][_)(/_\n"
			"                              ._|			\n"
		};

		cout<<falscheingabe<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<"Sie haben leider eine falsche Eingabe getaetigt"<<endl<<endl<<"Dr"<<char(129)<<"cken Sie eine Taste und versuchen Sie es nochmal...";
								//Logo Falscheingabe sowie folgender Text werden ausgegeben 
		getch();				//Wartet auf eine eingabe
		start();				//Widerholt die Funktion start

	}

}
void spielfeld()
{

	char spielfeld [21][51]=		//Ein Array namens Spielfeld mit dem Datentyp Char wird deklariert 21 Spalten und 51 Zeilen 
	{
		("                                                  "),
		("                         |                        "),                                              
	    ("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                         |                        "), 
		("                                                  "),
		("                                                  "),	
	};

	int *pscore;		    //Pointer für Den Punktestand wird deklariert
	int wert=0;		        //Die Variable Wert wird mit der Zahl 0 Deklariert
	int x=1;			    //Bedingung der Whilschleife wird auf 1 gesetzt
	int iy = 1;
	int &y = iy;
	int vorgang=1;			//Hilfsvariable um einen stufenweisen Vorgang abzuarbeiten
	pscore=&wert;           //Der Pointer Score zeigt auf die Adresse der Variable Wert (*pointer=0)

	spielfeld[1][2]='|'; spielfeld[2][2]='|'; spielfeld[1][47]='|'; spielfeld[2][47]='|'; spielfeld[1][3]='o';
												//Es werden Schläger und Ball in das Array gespeichert
	while(x==1)									//While Schleife mit der Bedingung x=1(Schläger an Pos1) wird ausgeführt
	{

		if(spielfeld[1][2]=='|' && vorgang==1)		//Abfrage des Spieler-Schlägers und Stufe(1)
		{											//Wenn die Bedingung erfüllt ist:	
			*pscore=*pscore+8;						//Pointer score wird +8 hochgezählt	
			bewegung1(spielfeld,y);					//Bewegung 1 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			bewegung2(spielfeld,y);					//Bewegung 2 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben	
			vorgang=2;								//Vorgang (Stufe) wird mit dem Wert 2 initliaisert
		}
		else
		{
			x=0;									//Unterbricht die While-Schleife falls Bedinung nicht erfüllt wird
		}

		if(spielfeld[9][2]=='|' && vorgang==2)		//Abfrage des Spieler-Schlägers und Stufe(2)
		{											//Wenn die Bedingung erfüllt ist:	
			*pscore=*pscore+8;						//Pointer score wird +8 hochgezählt	
			bewegung3(spielfeld,y);					//Bewegung 3 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			bewegung4(spielfeld,y);					//Bewegung 4 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			vorgang=3;								//Vorgang (Stufe) wird mit dem Wert 3 initliaisert
		}
		else
		{				
			x=0;									//Unterbricht die While-Schleife falls Bedinung nicht erfüllt wird
		}

		if	(spielfeld[17][2]=='|' && vorgang==3)	//Abfrage des Spieler-Schlägers und Stufe(3)
		{											//Wenn die Bedingung erfüllt ist:							    
			*pscore=*pscore+8;						//Pointer score wird +8 hochgezählt	
			bewegung5(spielfeld,y);					//Bewegung 5 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			bewegung6(spielfeld,y);					//Bewegung 6 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			vorgang=4;								//Vorgang (Stufe) wird mit dem Wert 4 initliaisert
		}
		else
		{			
			x=0;									//Unterbricht die While-Schleife falls Bedinung nicht erfüllt wird

		}
		if (spielfeld[5][2]=='|' && vorgang==4) 	//Abfrage des Spieler-Schlägers und Stufe(4)
		{											//Wenn die Bedingung erfüllt ist:   
			*pscore=*pscore+8;						//Pointer score wird +8 hochgezählt	
			bewegung7(spielfeld,y);					//Bewegung 7 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			bewegung8(spielfeld,y);					//Bewegung 8 wird ausgeführt, das Spielfeld und der Wert y(SchlägerKoordinate) wird übergeben
			vorgang=1;								//Vorgang (Stufe) wird mit dem Wert 1 initliaisert
		}
		else
		{
				x=0;								//Unterbricht die While-Schleife falls Bedinung nicht erfüllt wird
		}
	}
	verloren(pscore);								//Ruft die Funktion verloren auf und übergibt die Variable pscore(pointer)

}			

void bewegung1(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC);		//Funktion spielt Ball-Schläger Konfrontation ab
	spielfeld[1][47]='|';					//Gegenspieler Schläger(1) wird auf Spalte 1 Zeile 47 gezeichnet
	spielfeld[2][47]='|';					//Gegenspieler Schläger(2) wird auf Spalte 2 Zeile 47 gezeichnet	
	for(int x=0;x<=43;x++)					//For Schleife zälht in 44 Schritten den Wert +1 hoch
	{

		spielerbewegung(spielfeld,y);		//Spielfeldbewegung zur Manipulation der Schläger wird aufgerufen Wert y wird übergeben

		spielfeld[1][3+x]='o';				//Ball "o" wird in das Array geschrieben und durch x Wert erhöt	
		if (x != 0) spielfeld[1][2+x]=' ';	//Der Ball "o" wird wieder gelöscht 
		if (x == 22 || x == 23) spielfeld[1][25]='|'; //Spielfeldlinie(mittig) wird bei der Konfrontation mit dem Ball überpsprungen => Linie bleibt erhalten
		spielfeldausgabe(spielfeld);		// Spielfeld wird ausgegeben "gezeichnet"
	}
}
void bewegung2(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC); 
	for (int x=0;x<=43;x++)
	{
		spielerbewegung(spielfeld,y);
		if(x==0)
		{
			spielfeld[2][47]='|';
			spielfeld[1][46]=' ';
		}
		if(x<=5)
		{
			spielfeld[2][45-x]='o';
			spielfeld[2][46-x]=' ';
			spielfeld[2][47]='|';
			if(x==5)
			{
				spielfeld[2][40]=' ';
			}
		}
		if (x>5 && x<=10)
		{
			spielfeld[3][46-x]='o';
			spielfeld[3][47-x]=' ';

			if(x==10)
			{
				spielfeld[3][36]=' ';
			}
		}
		if(x>10 && x<=15)
		{
			spielfeld[4][46-x]='o';
			spielfeld[4][47-x]=' ';

			if(x==15)
			{
				spielfeld[4][31]=' ';
			}
		}
		if(x>15 && x<=20)
		{
			spielfeld[5][46-x]='o';
			spielfeld[5][47-x]=' ';

			if(x==20)
			{
				spielfeld[5][26]=' ';
			}

		}
		if(x>20 && x<=25)
		{
			spielfeld[6][46-x]='o';
			spielfeld[6][47-x]=' ';
			spielfeld[6][25]='|';

			if(x==25)
			{
				spielfeld[6][21]=' ';
			}
		}
		if(x>25 && x<=30)
		{
			spielfeld[7][46-x]='o';
			spielfeld[7][47-x]=' ';

			if(x==30)
			{
				spielfeld[7][16]=' ';
			}
		}
		if(x>30 && x<=35)
		{
			spielfeld[8][46-x]='o';
			spielfeld[8][47-x]=' ';

			if(x==35)
			{
				spielfeld[8][11]=' ';
			}
		}
		if(x>35 && x<=43)
		{
			spielfeld[9][46-x]='o';
			spielfeld[9][47-x]=' ';

			if(x==43)
			{
				spielfeld[9][3]=' ';
			}
		}	
		spielfeldausgabe(spielfeld);
	}
}
void bewegung3(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC); 
	for(int x=0;x<=43;x++)
	{
		spielerbewegung(spielfeld,y);
		if(x<=15)
		{
			spielfeld[0+x][47]= ' ';
			// spielfeld[1+x][47]= ' ';	// ? oO, wegen nächster Zeile überflüssig
			spielfeld[1+x][47]= '|';
			spielfeld[2+x][47]= '|';
		}
		if(x<=5)
		{
			spielfeld[10][3+x]='o';
			spielfeld[10][2+x]=' ';
			if(x==5)
			{
				spielfeld[10][8]=' ';
			}
		}
		if(x>5 && x<=10)
		{
			spielfeld[11][3+x]='o';
			spielfeld[11][2+x]=' ';
			if(x==10)
			{
				spielfeld[11][13]=' ';
			}
		}
		if(x>10 && x<=15)
		{
			spielfeld[12][3+x]='o';
			spielfeld[12][2+x]=' ';
			if(x==15)
			{
				spielfeld[12][18]=' ';
			}
		}
		if(x>15 && x<=20)
		{
			spielfeld[13][3+x]='o';
			spielfeld[13][2+x]=' ';
			if(x==20)
			{
				spielfeld[13][23]=' ';
			}
		}
		if(x>20 && x<=25)
		{
			spielfeld[14][3+x]='o';
			spielfeld[14][2+x]=' ';
			spielfeld[14][25]='|';
			if(x==25)
			{
				spielfeld[14][28]=' ';
			}
		}
		if(x>25 && x<=30)
		{
			spielfeld[15][3+x]='o';
			spielfeld[15][2+x]=' ';
			if(x==30)
			{
				spielfeld[15][33]=' ';
			}
		}
		if(x>30 && x<=35)
		{
			spielfeld[16][3+x]='o';
			spielfeld[16][2+x]=' ';
			if(x==35)
			{
				spielfeld[16][38]=' ';
			}
		}
		if(x>35 && x<=43)
		{
			spielfeld[17][3+x]='o';
			spielfeld[17][2+x]=' ';
		}

		spielfeldausgabe(spielfeld);
	}
}
void bewegung4(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC); 
	//	spielfeld[16][47]= '|'; spielfeld[17][47]= '|'; // Stand nach bewegung3
	for(int x=0;x<=43;x++)
	{
		spielerbewegung(spielfeld,y);
		spielfeld[17][46-x]='o';
		if (x != 0) spielfeld[17][47-x]=' ';
		if (x == 21 || x == 22) spielfeld[17][25]='|';

		if(x==43)
		{
			spielfeld[17][3]=' ';
		}
		spielfeldausgabe(spielfeld);
	}
}
void bewegung5(char spielfeld[21][51], int &y)
{PlaySoundA
	("pong", NULL,SND_ASYNC); 
	// spielfeld[16][47]= '|'; spielfeld[17][47]='|';	// Stand nach bewegung3 & 4
	for(int x=0; x<=41; x++)	// 43?..
	{
		spielerbewegung(spielfeld,y);
		if (0 <= x && x<= 2) {
				spielfeld[17][4+x]='o';
				if (x != 0) spielfeld[17][3+x]=' ';
		}
		if (3 <= x && x <= 10) {
			if (x == 3) spielfeld[17][6]=' ';
			spielfeld[16][4+x]='o';
			spielfeld[16][3+x]=' ';
		}
		if (11 <= x && x <= 12) {
			if (x == 11) {
				spielfeld[16][14]=' ';	// in dem 2. []: 3+x = 14
				spielfeld[15][15]='o';	// in dem 2. []: 4+x = 15

				spielfeld[17][47]=' ';
				spielfeld[15][47]='|';
			}
			if (x == 12) {
				spielfeld[15][15]=' ';
				spielfeld[14][16]='o';

				spielfeld[16][47]=' ';
				spielfeld[14][47]='|';
			}
		}
		if (13 <= x && x <= 20) {
			if (x == 13) {
				spielfeld[14][16]=' ';	// um 'o' aus vorheriger if bei x == 12 zu entfernen
				spielfeld[15][47]=' ';	// PC-'|'-Bewegung, aufgeteilt
				spielfeld[13][47]='|';	// 15-x-3 = 12-x  &  geht von 12 bis 5
			}			
			spielfeld[13][4+x]='o';	// 4+13=17 bis 4+20=24
			spielfeld[13][3+x]=' ';	// 3+13=16 bis 3+20=23
		}
		if (21 <= x && x <= 22) {
			if (x == 21) {
				spielfeld[13][24]=' ';
				spielfeld[12][26]='o';
				spielfeld[14][47]=' ';
				spielfeld[12][47]='|';
			}
			if (x == 22) {
				spielfeld[12][26]=' ';
				spielfeld[11][27]='o';
				spielfeld[13][47]=' ';
				spielfeld[11][47]='|';
			}
		}
		if (23 <= x && x <= 30) {
			if (x == 23) {
				spielfeld[11][27]=' ';
				spielfeld[12][47]=' ';
				spielfeld[10][47]='|';
			}
			spielfeld[10][5+x]='o';
			spielfeld[10][4+x]=' ';
		}
		if (31 <= x && x <= 32) {
			if (x == 31) {
				spielfeld[10][35]=' ';
				spielfeld[9][36]='o';
				spielfeld[11][47]=' ';
				spielfeld[9][47]='|';
			}
			if (x == 32) {
				spielfeld[8][37]='o';
				spielfeld[9][36]=' ';
				spielfeld[10][47]=' ';
				spielfeld[8][47]='|';
			}
		}
		if (33 <= x && x <= 36) {
			if (x == 33) {
				spielfeld[8][37]=' ';
				spielfeld[9][47]=' ';
				spielfeld[7][47]='|';
			}
			spielfeld[7][5+x]='o';
			spielfeld[7][4+x]=' ';
		}
		if (37 <= x && x <= 41) {
			if (x == 37) {
				spielfeld[7][41]=' ';
				spielfeld[6][42]='o';
				spielfeld[8][47]=' ';
				spielfeld[6][47]='|';
			}
			if (x == 38) {
				spielfeld[6][42]=' ';
				spielfeld[5][43]='o';
				spielfeld[7][47]=' ';
				spielfeld[5][47]='|';
			}
			if (39 <= x && x <= 41) {
				spielfeld[5][4+x]=' ';	// 4+39 = 43
				spielfeld[5][5+x]='o';	// 5+39 = 44
			}
		}
		spielfeldausgabe(spielfeld);
	}
}
void bewegung6(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC); 
	// spielfeld[5][47]='|'; spielfeld[6][47]='|';	// stand nach bewegung5
	for(int x=0;x<=43;x++)
	{
		spielerbewegung(spielfeld,y);

		/* spielfeld[5][25]='|';	// in Mitte wurde '|' nicht zu 'o'
		spielfeld[5][46-x]='o';	// 'o' bis zu [5][46] (auf [5][47] ist erst der PC-'|')
		if (x != 0 && x != 22) spielfeld[5][47-x]=' ';	// sonst bei x = 0 ggf. PC-'|' zu ' ' und bei x = 22 Mitte-'|' nicht zu ' '
		*/

		spielfeld[5][46-x]='o';	// 'o' bis zu [5][46] (auf [5][47] ist erst der PC-'|')
		if (x != 0) spielfeld[5][47-x]=' ';	// sonst bei x = 0 ggf. PC-'|' zu ' '
		spielfeld[5][25]='|';	// 'o' und ' ' in Mitte immer überschrieben

		spielfeldausgabe(spielfeld);
	}
}
void bewegung7(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC); 
	// spielfeld[5][47]='|'; spielfeld[6][47]='|';	// Stand nach bewegung5 & 6
	for(int x=0;x<=43;x++)
	{
		spielerbewegung(spielfeld,y);
		if(x<=8)
		{
			spielfeld[5][3+x]='o';
			spielfeld[5][2+x]=' ';
		}
		if(x>8 && x<=16)
		{
			if (x == 9)	spielfeld[5][11]=' '; 
			spielfeld[6][3+x]='o';
			spielfeld[6][2+x]=' ';
		}
		if(x>16 && x<=24)
		{
			if (x == 17) spielfeld[6][19]=' ';
			spielfeld[7][3+x]='o';
			spielfeld[7][2+x]=' ';
			spielfeld[7][25]='|';	
		}
		if(x>24 && x<=32)
		{
			if (x == 25) {
				spielfeld[7][27]=' ';

				spielfeld[5][47]=' ';
				spielfeld[6][47]=' ';	// PC-'|' von 5/6 nach 9/10 in einem Zug? oO
				spielfeld[9][47]='|';
				spielfeld[10][47]='|';
			}
			spielfeld[8][3+x]='o';
			spielfeld[8][2+x]=' ';
		}
		if(x>32 && x<=43)
		{
			if (x == 33) spielfeld[8][35]=' ';
			spielfeld[9][3+x]='o';
			spielfeld[9][2+x]=' ';
		}
		spielfeldausgabe(spielfeld);
	}
}
void bewegung8(char spielfeld[21][51], int &y)
{
	PlaySoundA("pong.wav", NULL,SND_ASYNC); 
	// spielfeld[9][47]='|'; spielfeld[10][47]='|'; // Stand nach bewegung7

    for (int x=0;x<=43;x++)	// erst for (int x=0;x<=47;x++), aber unten max. bis if (x == 43) ...
    {
		spielerbewegung(spielfeld,y);
        if(x<=6)
        {
          	spielfeld[9][46-x]='o';
      		if (x != 0) spielfeld[9][47-x]=' ';
        }  
		if(x>6 && x<=12)
		{
			if (x == 7) {
				spielfeld[9][40]=' ';
				spielfeld[8][47]='|';  
				spielfeld[10][47]=' ';
			}
            spielfeld[8][46-x]='o';
            spielfeld[8][47-x]=' ';
        }            
        if(x>12 && x<=18)
		{
			if (x == 13) {
				spielfeld[8][34]=' ';
				spielfeld[7][47]='|';  
				spielfeld[9][47]=' ';
			}
            spielfeld[7][46-x]='o';
            spielfeld[7][47-x]=' ';
        }           
        if(x>18 && x<=20)
		{
			if (x == 19) {
				spielfeld[7][28]=' ';
				spielfeld[6][47]='|';  
				spielfeld[8][47]=' ';
			}
			spielfeld[6][46-x]='o';
            spielfeld[6][47-x]=' '; 
        }
		if (x == 21) { spielfeld[6][26]=' '; }
        if(x>22&& x<=30)
		{
			if (x == 27)  {
				spielfeld[5][20]=' ';
				spielfeld[5][47]='|';  
				spielfeld[7][47]=' ';
			}
            spielfeld[5][46-x]='o';
            spielfeld[5][47-x]=' ';
        }
        if(x>30&& x<=36)
		{
			if (x == 31) {
				spielfeld[5][16]=' ';
				spielfeld[4][47]='|';  
				spielfeld[6][47]=' ';
			}
			spielfeld[4][46-x]='o';
            spielfeld[4][47-x]=' ';
	    }             
        if(x>36 && x<=41)
        {
			if (x == 37) {
				spielfeld[4][10]=' ';
				spielfeld[3][47]='|';  
				spielfeld[5][47]=' ';
			}
			spielfeld[3][46-x]='o';
            spielfeld[3][47-x]=' ';
		}              
        if(x==42)	// x>41 && x<=42 -> x = 42
        {
			spielfeld[3][5]=' ';	// für x = 41 aus obiger if 
            spielfeld[2][46-x]='o';
            spielfeld[2][47-x]=' ';

			spielfeld[2][47]='|';  
			spielfeld[4][47]=' ';
        }             
        if(x==43)	// x>42 && x<=43 -> x = 43
        {
			spielfeld[2][4]=' ';
            spielfeld[1][46-x]='o';
			spielfeld[1][47]='|';  
			spielfeld[3][47]=' ';
        }

		spielfeldausgabe(spielfeld);
    }
}

void spielfeldausgabe(char spielfeld[21][51])
{
	for(int x=0; x<=20;x++)        //For Schleife wird 21 Mal hochgezählt für die Spaltenanzahl des Arrays
	{
		for(int y=0;y<=50;y++)     //For Schleife wird 51 Mal hochgezählt für die Zeilenanzahl des Arrays
		{
			cout<<spielfeld[x][y]; //Spielfeld Spalte[x] Zeile [y] wird ausgegeben
		}
		cout<<endl;				   //Je Spalte[x] wird eine Zeile nach unten gesprungen		

	}
	system("cls");				   //CMD-Bildschirminhalt wird gelöscht
}

void spielerbewegung(char spielfeld[21][51], int &y)
{	
	spielfeld[y][2]=' ';				//Vorherige Schläger(1) Position wird gelöscht
	spielfeld [y+1][2]=' ';				//Vorherige Schläger(2) Position wird gelöscht	
	if (GetAsyncKeyState(VK_DOWN))		//Wenn PfeilTaste "Unten" gedrück wird: 
	{
		y++;							//Schlagerwert(1&2) Y wird hochgezählt
		if (y > 17)
		{
			y = 17;						//Fals Schläger an Zeile 17 ist behalte ihn dort sonnst => Arrayüberlauf
		}
	}
		if (GetAsyncKeyState(VK_UP))	//Wenn PfeilTaste "Oben" gedrück wird: 
	{
		y--;							//Schlagerwert(1&2) Y wird runtergezählt
		if (y < 1)
		{
		 y = 1;							//Fals Schläger an Zeile 1 ist behalte ihn dort sonnst => Arrayüberlauf
		}
	}
	spielfeld[y][2]='|';				//Schläger 1 wird Ausgegeben hierbei immer in Zeile 2
	spielfeld [y+1][2]='|';             //Schläger 2 wird Ausgegeben hierbei immer in Zeile 2
}

void verloren(int *pscore)
{
PlaySoundA("ohnoes.wav", NULL,SND_ASYNC);	  // Sound "ohnoes.wav" wird aufgerufen und abgespielt
system("cls");
char verloren[1000]=						  // Array-Feld verloren wird deklariert und initialisiert
{
	" **      **                 **                                   \n"                
	"/**     /**                /**                                   \n"                 
	"/**     /**  *****  ****** /**  ******  ******  *****  *******  \n"             
	"//**    **  **///**//**//* /** **////**//**//* **///**//**///** \n"         
	" //**  **  /******* /** /  /**/**   /** /** / /******* /**  /** \n"     
	"  //****   /**////  /**    /**/**   /** /**   /**////  /**  /** \n" 
	"   //**    //******/***    ***//****** /***   //****** ***  /** \n" 
	"    //      ////// ///    ///  //////  ///     ////// ///   //   \n" 

};

cout<<verloren<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;
											//Array-Feld verloren wird ausgegben
Sleep(2000);								//Unterbrechung des Programmes für 2000ms(entspricht 2s)
if(*pscore <=40)							//Wenn der Punktestand(Wert des Pointer Score) unter 40 liegt: "schlecht"
{
	cout<<"Schlecht! Sie haben einen Punktestand von nur "<<*pscore<<" Points erreicht :(";
}
if (*pscore > 40 && *pscore <=80)			//Wenn der Punktestand(Wert des Pointer Score)über 40 und unter 81 liegt: "schade"
{
	cout<<"Schade, Sie haben leider nur einen Punktestand von "<<*pscore<<" Points erreicht :(";
}
if(*pscore > 80 && *pscore <=160)			//Wenn der Punktestand(Wert des Pointer Score)über 80 unter 161 liegt: "gut"
{
	cout<<"Gut, Sie haben  einen Punktestand von "<<*pscore<<" Points erreicht :)";
}
if(*pscore > 160 && *pscore <=240)			//Wenn der Punktestand(Wert des Pointer Score)über 160 unter 241 liegt: "prima"
{
	cout<<"Prima Sie haben  einen Punktestand von "<<*pscore<<" Points erreicht :)";
}
if(*pscore > 240)							//Wenn der Punktestand(Wert des Pointer Score)über 240 liegt "umwerfend"			
{
	cout<<"Umwerfend! Sie haben  einen Punktestand von "<<*pscore<<" Points erreicht :)";
}
cout <<endl;
Sleep(5000);								//Unterbrechung des Programmes für 5000ms(entspricht 5s)
highscore(pscore);							//Funktion highscore wird aufgerufen und der Pointer pscore übergeben

}

void highscore(int *pscore)
{
	int ia=0, ib=1, ic=2;			//Drei Variablen werden deklariert und initalisiert
	int &a=ia, &b=ib, &c=ic;		//Refernezen werden deklariert und zeigen auf die oberen Variablen 
	lesen(a,b,c);					//lesen-Funktion wird aufgerufen und die Referenzen a,b,c übergeben
	vergleich(pscore,a,b,c);		//schreiben-Funktion wird aufgerufen und die Referenzen a,b,c übergeben, sowie der Pointer pscore
	Sleep(5000);					//Programm wird angewiesen 5 Sekunden zu warten
	start();						//Die Funktion start wird aufgerufen
}

void highscoreausgabe()
{
	int score1, score2, score3;
	char highscore[10000]=						  // Array-Feld verloren wird deklariert und initialisiert
{
 " _______  __                                              \n"
 "|   _   ||__|.-----..-----.   .-----..-----..-----..-----.\n"
 "|   _   ||  ||     ||  _  |   |  _  ||  _  ||     ||  _  |\n"
 "|   ____||__||__|__||___  |   |   __||_____||__|__||___  |\n"
 "|   |               |_____|   |__|                 |_____|\n"
 "|   |                                                     \n"
 "`---'                                                     \n"
 " ___                                 __  __     __        \n"
 "|   |.--------..-----..-----..-----.|__||  |--.|  |.-----.\n"
 "|   ||        ||  _  ||__ --||__ --||  ||  _  ||  ||  -__|\n"
 "|   ||__|__|__||   __||_____||_____||__||_____||__||_____|\n"
 "|   |          |__|                                       \n"
 "|   |                                                     \n"
 "`---'                                                        \n"                                                     
 " __     __         __                               \n"
 "|  |--.|__|.-----.|  |--..-----..-----..----..-----.\n"
 "|     ||  ||  _  ||     ||__ --||  _  ||   _||  -__|\n"
 "|__|__||__||___  ||__|__||_____||_____||__|  |_____|\n"
	} ;     

 	cout<<highscore<<endl<<endl<<endl;

			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 9);

	FILE *platz1;

	cout<<"			PLATZ1: ";
	if((platz1 = fopen("platz1.txt","r")) !=NULL)
	{
		score1=fgetc(platz1);
		while(!feof(platz1))
		{
			putchar(score1);
			score1=fgetc(platz1);
		}
		fclose(platz1);
	}
	cout<<endl;
	FILE *platz2;

			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 4);
	cout<<"			PLATZ2: ";
	if((platz2 = fopen("platz2.txt","r")) !=NULL)
	{
		score2=fgetc(platz2);
		while(!feof(platz2))
		{
			putchar(score2);
			score2=fgetc(platz2);
		}
		fclose(platz2);
	}
		cout<<endl;
	FILE *platz3;
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
	cout<<"			PLATZ3: ";
	if((platz3 = fopen("platz3.txt","r")) !=NULL)
	{
		score3=fgetc(platz3);
		while(!feof(platz3))
		{
			putchar(score3);
			score1=fgetc(platz3);
		}
		Sleep(10000);
		fclose(platz3);
	}
	start();
}
void lesen(int &a, int &b, int &c)
{

	FILE *platz1;										//Der Pointer platz1 wird mit dem Datentyp FILE deklariert
	int score1, score2, score3;							//Die Variablen score1,score2,score3 werden initialisiert

	if((platz1 = fopen("platz1.txt","r")) != NULL)		//Durch fopen wird platz1.txt geöffnet(r=lesen) und wird mit einer Bedingung für das erfolgreiche Öffnen verknüpft 
	{
		char xy [5];									//Das Array xy wird deklariert und wird für 5 Ziffern reserviert
		fgets (xy, 5, platz1);
		score1 = atoi(xy);
		a=score1;
	}

	FILE *platz2;										//Der Pointer platz2 wird mit dem Datentyp FILE deklariert
	if((platz2 = fopen("platz2.txt","r")) != NULL)		//Durch fopen wird platz1.txt geöffnet(r=lesen) und wird mit einer Bedingung für das erfolgreiche Öffnen verknüpft 
	{
		char xy [5];									//Das Array xy wird deklariert und wird für 5 Ziffern reserviert
		fgets (xy, 5, platz2);
		score2 = atoi(xy);
		b=score2;
	}

	FILE *platz3;										//Der Pointer platz3 wird mit dem Datentyp FILE deklariert
	if((platz3 = fopen("platz3.txt","r")) != NULL)		//Durch fopen wird platz1.txt geöffnet(r=lesen) und wird mit einer Bedingung für das erfolgreiche Öffnen verknüpft 
	{
		char xy [5];									//Das Array xy wird deklariert und wird für 5 Ziffern reserviert
		fgets (xy, 5, platz3);
		score3 = atoi(xy);
		c=score3;
	}

}
void vergleich(int *punkte,int &a, int &b, int &c)
{

	int feld[3]={a,b,c};

	if(*punkte>=feld[0])
	{

		feld[2]=feld[1];
		feld[1]=feld[0];
		feld[0]=*punkte;
	}

	if(*punkte>=feld[1]&&*punkte<feld[0])
	{
		feld[2]=feld[1];
		feld[1]=*punkte;
	}
	if(*punkte>=feld[2]&&*punkte<feld[1])
	{
		feld[2]=*punkte;
	}

	speichern(feld[0],feld[1],feld[2]);

}
void speichern(int feld0,int feld1,int feld2)
{
	char highscore[10000]=						  // Array-Feld verloren wird deklariert und initialisiert
{
 " _______  __                                              \n"
 "|   _   ||__|.-----..-----.   .-----..-----..-----..-----.\n"
 "|   _   ||  ||     ||  _  |   |  _  ||  _  ||     ||  _  |\n"
 "|   ____||__||__|__||___  |   |   __||_____||__|__||___  |\n"
 "|   |               |_____|   |__|                 |_____|\n"
 "|   |                                                     \n"
 "`---'                                                     \n"
 " ___                                 __  __     __        \n"
 "|   |.--------..-----..-----..-----.|__||  |--.|  |.-----.\n"
 "|   ||        ||  _  ||__ --||__ --||  ||  _  ||  ||  -__|\n"
 "|   ||__|__|__||   __||_____||_____||__||_____||__||_____|\n"
 "|   |          |__|                                       \n"
 "|   |                                                     \n"
 "`---'                                                        \n"                                                     
 " __     __         __                               \n"
 "|  |--.|__|.-----.|  |--..-----..-----..----..-----.\n"
 "|     ||  ||  _  ||     ||__ --||  _  ||   _||  -__|\n"
 "|__|__||__||___  ||__|__||_____||_____||__|  |_____|\n"

};
	system("cls");
	cout<<highscore<<endl<<endl<<endl;
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10);
	cout<<"			PLATZ1:	"<<feld0<<endl;
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 4);
	cout<<"			PLATZ2:	"<<feld1<<endl;
			SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 9);
	cout<<"			PLATZ3:	"<<feld2<<endl;

	FILE *platz1;
	if((platz1=fopen("platz1.txt","w")) != NULL)
	{
		fprintf(platz1,"%i",feld0);
		fclose(platz1);
	}

	FILE *platz2;
	if((platz2=fopen("platz2.txt","w")) != NULL)
	{
		fprintf(platz2,"%i",feld1);
		fclose(platz2);
	}

	FILE *platz3;
	if((platz3=fopen("platz3.txt","w")) != NULL)
	{
		fprintf(platz3,"%i",feld2);
		fclose(platz3);
	}

}
void abschluss()
{
system("cls");	
char spielende[1000]=										//Spielende(Logo) wird als Array-Feld derklariert und  initialisiert	
{
" _______  _______  ___   _______  ___      _______  __    _  ______   _______ \n"
"|       ||       ||   | |       ||   |    |       ||  |  | ||      | |       |\n"
"|  _____||    _  ||   | |    ___||   |    |    ___||   |_| ||  _    ||    ___|\n"
"| |_____ |   |_| ||   | |   |___ |   |    |   |___ |       || | |   ||   |___ \n"
"|_____  ||    ___||   | |    ___||   |___ |    ___||  _    || |_|   ||    ___|\n"
" _____| ||   |    |   | |   |___ |       ||   |___ | | |   ||       ||   |___ \n"
"|_______||___|    |___| |_______||_______||_______||_|  |__||______| |_______|\n"
};
	cout <<spielende<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl<<endl;											
															//Gibt das Spielende(-Logo) auf den Bildschirm aus
	PlaySoundA("outro.wav",NULL,SND_LOOP|SND_ASYNC);	    //Outro.wave wird in einer Dauerschleife augegeben 	
Sleep(2000);												//Unterbrechung des Programmes für 2000ms(entspricht 2s)
	cout <<"Danke f"<<(char (129))<<"rs Spielen!!!"<<endl<<endl;  
	cout<<char (169)<<" Jan Ackermann, Bardia Eghtesadinia, (Marwan Khalid)"<<endl;
getch();												   //Programm wartet vor Beendung auf eine beliebige Eingabe
}

void bildhalten()
{
	getch();		//Wartet auf Beliebige Tasteneingabe (getchar)

BTW Kritiken sind gerne erlaubt hab nächste woche den Vortrag

namespace invader

Cpong schrieb:

#include <iostream>

Das ist ja gar kein C.

namespace invader schrieb:

Cpong schrieb:

#include <iostream>

Das ist ja gar kein C.

Gruselig. Programmiert 1000 Zeilen Code und hat kein blassen Schimmer in welche Sprache er das programmiert hat.

wir benutzen in der schule grad ein zwischending, da wir ein halbes jahr lang in C programmiert haben und langsam mit C++ anfangen.

Cpong schrieb:

wir benutzen in der schule grad ein zwischending, da wir ein halbes jahr lang in C programmiert haben und langsam mit C++ anfangen.

Mein Beileid.

namespace invader

Cpong schrieb:

wir benutzen in der schule grad ein zwischending

Das muss wohl diese mysteriöse Sprache "C/C++" sein, von der man immer so oft hört.

kA warum ihr euch so beschwert, das ist ganz normales C , dass einzige was an C++ grenzt sind die Referenzen und cin,cout.

omg2222 schrieb:

kA warum ihr euch so beschwert, das ist ganz normales C.

Es ist kein C. Du hast keine Funktion benutzt die ANSI-C gehört. Alles C++. Und das gehört eher ins Projektforum.

omg3333 schrieb:

omg2222 schrieb:

kA warum ihr euch so beschwert, das ist ganz normales C.

Es ist kein C. Du hast keine Funktion benutzt die ANSI-C gehört. Alles C++. Und das gehört eher ins Projektforum.

bin nicht OP.

jep, das Teil macht laune.
Schonmal was von Einfallswinkel = Ausfallswinkel gehört ? Das Teil kommt waagerecht auf der anderen Seite an und wird dann plötzlich um ~45 °C abgelenkt

Ja hat ich mir zuerst auch überleg war mit dann aber zu viel arbeit und ich bin noch nich so weit wenn jemand will kann ich noch 24 seiten Quelltext analyse hochladen xD

C++ Forumbot

Dieser Thread wurde von Moderator/in rüdiger aus dem Forum ANSI C in das Forum DOS und Win32-Konsole verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

cobra11freak

Ich finde das cool was du gemacht hast, auch wenn es C++ ist aber immerhin machst du irgendwas, das ist doch der wesentliche Punkt um Programmieren zu lernen. Du dachtest wahrscheinlich dü würdest kein C++ verwenden, da du keine Klassen benutzt oder so, dass ist ja nicht verwerflich...
Also weiter so...

Mfg cobra11freak

danke hat mir weiter geholfen beim Ping Pong selbst programmieren!