Highscore in Kniffel

[Knodan]

Hallo zusammen,

ich habe ein Problem..
Ich habe Kniffel für den Schulunterricht programmieren müssen. Es funktioniert soweit ..

Aber ..

Ich möchte nun eine Highscore miteinbinden?
Weiß aber nicht wie das geht..
Quellcode:

#pragma hdrstop
#include <iostream>
#include <string>
#include <conio>
#include <fstream>
#include "colors.h"                   // header Datei für Farbenzuweisung
using namespace std;

#define UNBENUTZT	-1
#define BONUS_MIN	63
#define BONUS		35

// ###################################################################
// die benoetigten Datentypen
// ###################################################################

// hier das Kniffelblatt, in dem die Würfelergebnisse abgelegt werden 

#define	E_EINSER	0
#define	E_ZWEIER	1
#define	E_DREIER	2
#define	E_VIERER	3
#define	E_FUENFER	4
#define	E_SECHSER	5
#define	E_ZWSUMMEOBEN	6
#define	E_BONUS		7
#define	E_SUMMEOBEN	8
#define	E_DREIERPASCH	9
#define	E_VIERERPASCH	10
#define	E_FULLHOUSE	11
#define	E_KLEINESTRASSE	12
#define	E_GROSSESTRASSE	13
#define	E_KNIFFEL	14
#define	E_CHANCE	15
#define	E_SUMMEUNTEN	16
#define	E_ENDSUMME	17
#define E_N		E_ENDSUMME+1

typedef int Ergebnis[E_N];

// hier die Infos zu einem Wuerfel (fixiert=true: nicht wuerfeln)

typedef struct Wuerfel {
	int	wert;
	bool	fixiert;
	} Wuerfel;

#define ANZAHL_WUERFEL	5
#define ANZAHL_WUERFE	3
#define WUERFEL_AUGEN	6
#define ANZAHL_RUNDEN	13
				// 1-6 oben + 7 unten = 13
				// nur 1 Kniffel möglich!

// ###################################################################
// die benoetigten Daten (Variablen)
// ###################################################################

static Ergebnis	ergebnis;
static Wuerfel	wuerfel[ANZAHL_WUERFEL];
static int	wuerfe;		// wie oft gewuerfelt?		0-3
static int	runden;		// wieviel runden gespielt?	0-13

static int	analyse[WUERFEL_AUGEN];
				// welche Augenzahl ist wie oft vertreten?

// ###################################################################
// Initialisierungsfunktionen
// ###################################################################

static void	InitialisiereErgebnis() {
	for( int i = 0 ; i < E_N; i++ )
        	ergebnis[i]=UNBENUTZT;
}

static void	InitialisiereWuerfel() {
	for( int i = 0; i < ANZAHL_WUERFEL; i++ ) {
		wuerfel[i].wert		= UNBENUTZT;
		wuerfel[i].fixiert	= false;
	}
}

static void	InitialisiereAnalyse() {
	for( int i = 0 ; i < WUERFEL_AUGEN; i++ )
        	analyse[i]=0;
}

static void	Initialisieren() {
	InitialisiereErgebnis();
	InitialisiereWuerfel();
	wuerfe=0;
	runden=0;
	srand(time(NULL));		// initialisiert den Zufallsgenerator
}

// ###################################################################
// Speicherfunktionen
// ###################################################################

static bool IndexUnbenutzt(int index, char c) {
	int zahl = index + 1;
	if (ergebnis[index] == UNBENUTZT )
		return true;
	else {
		cout << "Wert fuer " << c << " bereits gespeichert, ignoriert (" << index << ").\n";
		return false;
	}
}

static bool ZahlSpeichern(int index) {
	int zahl = index + 1;
	char c = zahl + '0';
	int summe = 0;
	if ( ! IndexUnbenutzt(index,c))
		return false;
	for( int i = 0; i < ANZAHL_WUERFEL; i++ ) {
		if ( wuerfel[i].wert == zahl )
			summe+=zahl;
	}
	ergebnis[index]=summe;
	cout << "Wert " << summe << " fuer " << c << " [" << index << "] gespeichert.\n";
	return true;
}

static int AugenSumme() {
	int summe = 0;
	for( int i = 0; i < ANZAHL_WUERFEL; i++ )
		summe+=wuerfel[i].wert;
	return summe;
}

static bool DreierpaschSpeichern(int index) {	// Punkte = Augen aller Wuerfel
	bool treffer = false;
	if ( ! IndexUnbenutzt(index,'d'))
		return false;
	// ist irgendeine Augenzahl 3mal vorhanden?
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (analyse[i] == 3) {
			treffer = true;
			break;
		}
	}
	if ( treffer )
		ergebnis[index]=AugenSumme();
	else
		ergebnis[index]=0;
	cout << "Wert " << ergebnis[index] << " fuer d [" << index << "] gespeichert.\n";
	return true;
}

static bool ViererpaschSpeichern(int index) {	// Punkte = Augen aller Wuerfel
	bool treffer = false;
	if ( ! IndexUnbenutzt(index,'v'))
		return false;
	// ist irgendeine Augenzahl 4mal vorhanden?
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (analyse[i] == 4) {
			treffer = true;
			break;
		}
	}
	if ( treffer )
		ergebnis[index]=AugenSumme();
	else
		ergebnis[index]=0;
	cout << "Wert " << ergebnis[index] << " fuer v [" << index << "] gespeichert.\n";
	return true;
}

static bool FullhouseSpeichern(int index) {	                // Punkte = 25
	bool treffer2 = false;
	bool treffer3 = false;
	if ( ! IndexUnbenutzt(index,'f'))
		return false;
	// ist irgendeine Augenzahl 2mal und eine andere 3mal vorhanden?
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (analyse[i] == 2) {
			treffer2 = true;
			break;
		}
	}
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (analyse[i] == 3) {
			treffer3 = true;
			break;
		}
	}
	if ( treffer2 && treffer3 )
		ergebnis[index]=25;
	else
		ergebnis[index]=0;
	cout << "Wert " << ergebnis[index] << " fuer f [" << index << "] gespeichert.\n";
	return true;
}

static bool KleineStrasseSpeichern(int index) {	                // Punkte = 30
	bool treffer = false;
	int  start   = UNBENUTZT;
	if ( ! IndexUnbenutzt(index,'k'))
		return false;
	// gibt es 4 aufeinanderfolgende Augenzahlen?
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (start == UNBENUTZT) {
			// bisher noch keine Würfel gefunden
			if (analyse[i] == 0)
				// und immer noch kein Würfel gefunden
				continue;
                        if (analyse[i+1] == 0)
				// und immer noch kein Würfel gefunden
				continue;
			// i+2 ist die erste Augenzahl, die mindestens ein Wuerfel zeigt
			start=i;
			if (i > 2)
				// wenn das hier eine 3 ist (also Augenzahl 4),
				// kann es keine kleine Straße mehr werden
				break;
		}
		else {
			if (analyse[i] != 0)  {
				// auch mit dieser Augenzahl i+1 gibt es mindestens einen Wuerfel
				if ( (i-start+1) >= 4 ) {
					// wir haben jetzt 4 aufeinanderfolgende Augenzahlen gehabt
					treffer = true;
					break;
				}
			}
			else {
				// wohl keine kleine Strasse
				break;
			}
		}
	}
	if ( treffer )
		ergebnis[index]=30;
	else
		ergebnis[index]=0;
	cout << "Wert " << ergebnis[index] << " fuer k [" << index << "] gespeichert.\n";
	return true;
}

static bool GrosseStrasseSpeichern(int index) {	                // Punkte = 40
	bool treffer = false;
	int  start   = UNBENUTZT;
	if ( ! IndexUnbenutzt(index,'g'))
		return false;
	// gibt es 5 aufeinanderfolgende Augenzahlen?
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (start == UNBENUTZT) {
			// bisher noch keine Würfel gefunden
			if (analyse[i] == 0) 
				// und immer noch kein Würfel gefunden
				continue;
			// i+1 ist die erste Augenzahl, die mindestens ein Wuerfel zeigt
			start=i;
			if (i > 1)
				// wenn das hier eine 2 ist (also Augenzahl 3),
				// kann es keine große Straße mehr werden
				break;
		}
		else {
			if (analyse[i] != 0)  {
				// auch mit dieser Augenzahl i+1 gibt es mindestens einen Wuerfel
				if ( (i-start+1) >= 5 ) {
					// wir haben jetzt 5 aufeinanderfolgende Augenzahlen gehabt
					treffer = true;
					break;
				}
			}
			else {
				// wohl keine kleine Strasse
				break;
			}
		}
	}
	if ( treffer )
		ergebnis[index]=40;
	else
		ergebnis[index]=0;
	cout << "Wert " << ergebnis[index] << " fuer g [" << index << "] gespeichert.\n";
	return true;
}

static bool KniffelSpeichern(int index) {	                // Punkte = 50
	bool treffer = false;
	if ( ! IndexUnbenutzt(index,'K'))
		return false;
	// gibt es 5 gleiche Augenzahlen?
	for( int i = 0; i < WUERFEL_AUGEN; i++ ) {
		if (analyse[i] == 5) {
			treffer = true;
			break;
		}
	}
	if ( treffer )
		ergebnis[index]=50;
	else
		ergebnis[index]=0;
	cout << "Wert " << ergebnis[index] << " fuer K [" << index << "] gespeichert.\n";
	return true;
}

static bool ChanceSpeichern(int index) {	// Punkte = Augen aller Wuerfel
	if ( ! IndexUnbenutzt(index,'c'))
		return false;
	ergebnis[index]=AugenSumme();
	cout << "Wert " << ergebnis[index] << " fuer c [" << index << "] gespeichert.\n";
	return true;
}

// ###################################################################
// Analysefunktion
// ###################################################################

static void	AnalyseDurchfuehren();

static bool WurfSpeichern(char *zeile) {
	bool ok = false;
	if ( wuerfe == 0 ) {
		cout << color_Rot << "\n    ==> Es wurde noch nicht gewuerfelt. <==\n" << color_Gruen;
	}
	else {
		InitialisiereAnalyse();
		AnalyseDurchfuehren();
		switch( zeile[1] ) {
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':	ok=ZahlSpeichern(zeile[1]-'1');break;
		case 'd':	ok=DreierpaschSpeichern(E_DREIERPASCH);break;
		case 'v':	ok=ViererpaschSpeichern(E_VIERERPASCH);break;
		case 'f':	ok=FullhouseSpeichern(E_FULLHOUSE);break;
		case 'k':	ok=KleineStrasseSpeichern(E_KLEINESTRASSE);break;
		case 'g':	ok=GrosseStrasseSpeichern(E_GROSSESTRASSE);break;
		case 'K':	ok=KniffelSpeichern(E_KNIFFEL);break;
		case 'c':	ok=ChanceSpeichern(E_CHANCE);break;
		default:	cout << color_Rot << "Unbekannter Speicherort ( " << color_Weiss << zeile[1] <<color_Rot <<" ), ignoriert.\n" << color_Gruen;
		}
		if (ok) {
			wuerfe=0;
			runden++;
		}
	}
	return ok;
}

// ###################################################################
// Berechnungsfunktionen
// ###################################################################

static void	AnalyseDurchfuehren() {
	for( int i = 0; i < ANZAHL_WUERFEL; i++ )
		analyse[wuerfel[i].wert-1]++;
	cout << "\nAnalyse:   ";
	for( int i = 0; i < WUERFEL_AUGEN; i++ )
		cout << " " << analyse[i] << "x" << i+1;
	cout << ".\n";
}

static void	KniffelblattBerechnen() {
	int	osumme;
	int	usumme;
	// obere summe berechnen
	osumme=0;
	for( int i = E_EINSER; i <= E_SECHSER; i++ ) {
		if (ergebnis[i] != UNBENUTZT)
			osumme+=ergebnis[i];
	}
	ergebnis[E_ZWSUMMEOBEN]=osumme;
	// bonus?
	if (ergebnis[E_ZWSUMMEOBEN] < BONUS_MIN)	
		ergebnis[E_BONUS]=0;
	else
		ergebnis[E_BONUS]=BONUS;
	ergebnis[E_SUMMEOBEN]=osumme+ergebnis[E_BONUS];
	// untere summe berechnen
	usumme=0;
	for( int i = E_DREIERPASCH; i <= E_CHANCE; i++ ) {
		if (ergebnis[i] != UNBENUTZT)
			usumme+=ergebnis[i];
	}
	ergebnis[E_SUMMEUNTEN]=usumme;
	// summe berechnen
	ergebnis[E_ENDSUMME]=ergebnis[E_SUMMEOBEN]+ergebnis[E_SUMMEUNTEN];
}

static int	Wurf() {
	return rand() % WUERFEL_AUGEN + 1;
}

static void	Wuerfeln() {
	int	i;
	if (wuerfe==ANZAHL_WUERFE)
		cout << "          ==>  !!! Keine weiteren Wuerfe moeglich (max. " << ANZAHL_WUERFE << "). !!!   <==\n";
	else {
		int n = 0;
		for( i = 0; i < ANZAHL_WUERFEL; i++ ) {
			if ( ! wuerfel[i].fixiert) {
				wuerfel[i].wert=Wurf();
				if (n==0)
					cout << color_Weiss << "\nWuerfle: " ;
				cout << " w" << i+1 << color_Weiss << " = " << color_Gruen << wuerfel[i].wert << "   " << color_Weiss;
				n++;
			}

		}
		if ( n > 0 ) {
			wuerfe++;
			cout << "\n";
		}
	}
}

static void	WuerfelErmitteln(char *zeile) {
	int	i;
	int	n = 0;
	for( i = 0; i < ANZAHL_WUERFEL; i++ )
		wuerfel[i].fixiert=true;
	if (zeile[1] == 'a') {
		for( i = 0; i < ANZAHL_WUERFEL; i++ ) {
			wuerfel[i].fixiert=false;
			n++;
		}
	}
	else {
		for( i = 1; zeile[i] != '\0' && zeile[i] != '\n'; i++ ) {
			int w = zeile[i] - '0';
			if ( w < 1 || w > ANZAHL_WUERFEL )
				cout << "Wuerfelnummer " << w << " ungueltig, ignoriert.\n";
			else {
				wuerfel[w-1].fixiert=false;
				n++;
			}
		}
	}
	if ( n == 0 )
		cout << color_Rot << "\nUnbekannte Wuerfelbezeichnung, ignoriert.\n" <<color_Gruen;
}

static void	WuerfelSetzen(char *zeile) {
	// erleichtert das Testen !!
	int	i;
	int	n = 0;
	for( i = 1; zeile[i] != '\0' && zeile[i] != '\n' && i <= 5; i++ ) {
		int w = zeile[i] - '0';
		if ( w < 1 || w > WUERFEL_AUGEN )
			cout << "Augenzahl " << w << " ungueltig, ignoriert.\n";
		else {
			wuerfel[n].wert=w;
			n++;
		}
	}
	if (wuerfe < ANZAHL_WUERFE)
		wuerfe++;
}

// ###################################################################
// Ausgabefunktionen
// ###################################################################

static void	WertAusgeben(char *name, int wert) {
	cout << name;
	if (wert!=UNBENUTZT)
		cout << wert;
	cout << "\n";
}

static void	KniffelblattAusgeben() {
	cout << color_Weiss << "\nAktuelles Kniffelblatt:\n" <<color_Gruen;
	KniffelblattBerechnen();
	WertAusgeben("  Einser              ",ergebnis[E_EINSER]);
        WertAusgeben("  Zweier              ",ergebnis[E_ZWEIER]);
        WertAusgeben("  Dreier              ",ergebnis[E_DREIER]);
        WertAusgeben("  Vierer              ",ergebnis[E_VIERER]);
        WertAusgeben("  Fuenfer             ",ergebnis[E_FUENFER]);
        WertAusgeben("  Sechser             ",ergebnis[E_SECHSER]);
	WertAusgeben("  Gesamt              ",ergebnis[E_ZWSUMMEOBEN]);
        WertAusgeben("  Bonus               ",ergebnis[E_BONUS]);
	WertAusgeben("  Gesamt oberer Teil  ",ergebnis[E_SUMMEOBEN]);
        WertAusgeben("  Dreierpasch         ",ergebnis[E_DREIERPASCH]);
        WertAusgeben("  Viererpasch         ",ergebnis[E_VIERERPASCH]);
        WertAusgeben("  Full House          ",ergebnis[E_FULLHOUSE]);
        WertAusgeben("  Kleine Strasse      ",ergebnis[E_KLEINESTRASSE]);
        WertAusgeben("  Grosse Strasse      ",ergebnis[E_GROSSESTRASSE]);
        WertAusgeben("  Kniffel             ",ergebnis[E_KNIFFEL]);
        WertAusgeben("  Chance              ",ergebnis[E_CHANCE]);
	WertAusgeben("  Gesamt unterer Teil ",ergebnis[E_SUMMEUNTEN]);
	WertAusgeben("  Gesamt oberer Teil  ",ergebnis[E_SUMMEOBEN]);
	WertAusgeben("  Endsumme            ",ergebnis[E_ENDSUMME]);
}

static void	WuerfelAusgeben() {
	int	i;
	cout << color_Weiss <<  "\nAktuelle Wuerfel (" << color_Rot << runden+1 << color_Weiss << "." << color_Rot <<"Runde" << color_Weiss << "): "<< color_Gruen <<"\n";
	if (wuerfe==0)
		cout << "  Es wurde noch nicht gewuerfelt.\n";
	else {
		cout << color_Weiss << "  nach " << color_Rot << wuerfe << color_Weiss << "." << color_Rot << "Wurf" << color_Weiss << ":" << color_Gruen;
		for ( i = 0; i < ANZAHL_WUERFEL; i++ ) {
			cout << " " << wuerfel[i].wert;
		}
		cout << "\n";
	}
}

static void	PromptAusgeben() {
        cout << "\n_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_\n";
	cout << "Kniffel (h fuer Hilfe): ";
}

static void	Hilfe() {

	cout << "\nh	diese Hilfe\n";
	cout << "l	Kniffelblatt und Wuerfel ausgeben\n";
	cout << "wa	alle Wuerfel neu wuerfeln\n";
	cout << "w135	Wuerfel 1, 3 und 5 neu wuerfeln (alle anderen bleiben liegen!)\n";
	cout << "sx	Wurf speichern unter Ergebnis x, wobei x\n";
	cout << "   	      1	        Einser\n";
	cout << "    	      2	        Zweier\n";
	cout << "      	      3	        Dreier\n";
	cout << "     	      4	        Vierer\n";
	cout << "	      5	        Fuenfer\n";
	cout << "	      6         Sechser\n";
	cout << "              d	        Dreierpasch\n";
	cout << "	      v	        Viererpasch\n";
	cout << "	      f	        Fullhouse\n";
	cout << "	      k	        kleine Strasse\n";
	cout << "	      g	        grosse Strasse\n";
	cout << "	      K	        Kniffel\n";
	cout << "	      c	        Chance\n";
	cout << "	danach wird automatisch das Kommando 'l' ausgefuehrt.\n";
	cout << "e	Spiel beenden\n";
}

// ###################################################################
// Hauptroutine zur Kommandobearbeitung
// ###################################################################

static void	KommandoEinlesenUndAusfuehren(bool *spiel_zu_ende) {
	char	zeile[1024];
	bool	gespeichert;
	// Zeile einlesen
	gets(zeile);
	// Kommando analysieren und ausfuehren
	switch( zeile[0] ) {
	case 'h':	Hilfe();break;
	case 'l':	KniffelblattAusgeben();WuerfelAusgeben();break;
	case 'w':	WuerfelErmitteln(zeile);Wuerfeln();WuerfelAusgeben();break;
	case '=':	WuerfelSetzen(zeile);WuerfelAusgeben();break;	// zum Testen
	case 'i':	Initialisieren();break;				// zum Testen
	case 's':	gespeichert=WurfSpeichern(zeile);
			if (gespeichert) {
				KniffelblattAusgeben();
			}
			if (runden == ANZAHL_RUNDEN) {
				cout << "\n\n >>>  IHR ERGEBNIS LAUTET: " << color_Gelb << ergebnis[E_ENDSUMME] << color_Gruen << " - herzlichen Glueckwunsch!  <<< \n";
				Initialisieren();
			}
			break;
	case 'q':
	case 'e':	cout << "Bye!";*spiel_zu_ende=true;return;
	default:	cout << color_Rot << "\n ==>   !!! Unbekanntes Kommando ( " << color_Weiss << zeile << color_Rot << " }, ignoriert. !!!   <== \n" <<color_Gruen;
	}
}
// ###################################################################
// Highscore
// ###################################################################

/*static void	Alserstesausgeben() {
                cout << " Geben Sie ihren Namen ein: ";
                string name;
                cin >> name;

                getchar();
}*/

// ###################################################################
// das Hauptprogramm
// ###################################################################

int main() {
        cout << color_Gruen <<" ";
	bool	spiel_zu_ende = false;
	Initialisieren();
                        //Hier müsste noch Highscore also Alserstesausgeben(); rein...
        while ( ! spiel_zu_ende ) {
		PromptAusgeben();
		KommandoEinlesenUndAusfuehren(&spiel_zu_ende);
	}
}

Danke schonmal für eure Hilfe

Knodan

[Kolumbus]

Hallo,

das nenne ich mal ein Quellcode-Posting! So erhälst Du bestimmt noch zusätzliche Tips zu Deinem Prog.
(oder der vormals interessierte Leser steigt gleich wieder aus! -sehr wahrscheinlich )
Im Allgemeinen postet man nur den Code, der für die Fragestellung unmittelbar relevant ist!

Ich bin jetzt nicht tiefer in die Materie eingestiegen, aber so grob würde ich es über eine Textdatei versuchen. In der können dann die Highscores mit Namen stehen (evtl. zu Anfang eine leere Textdatei zum Prog mitliefern). Am Ende eines Spiel's greift man dann auf die Textdatei zu und vergleicht den aktuellen Punktestand mit dem in der Highscore-Liste. Ist der aktuelle P.Stand unter dem letzen Highscore-Eintrag, war's das. Ist er drüber, muss der akt. P.Stand mit dem Spielername in die Liste einsortiert werden.
Nach dem Prog.Start kann man die H.Score-Liste natürlich dann auch schonmal anzeigen lassen o. viell. sogar während des ganzen Spiels (irgendwo an der Seite).
Zum Arbeiten mit Dateien gibts hier im Forum wirklich viele Beiträge, da ist bestimmt Alles Wichtige dabei...

MfG

[akari]

Hallo

Schau dir die FAQ im C++ Forum an, da gibts einen Thread zum Thema Dateien und Ströme.

Desweiteren ist das ein reins Konsolenprogramm und wird deshalb verschoben.

bis bald
akari

[C++ Forumbot]

Dieser Thread wurde von Moderator/in akari aus dem Forum VCL/CLX (Borland C++ Builder) in das Forum C++ verschoben.

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

Dieses Posting wurde automatisch erzeugt.

[shorty0802]

lso ich hab des so gemacht:

#include<iostream>
#include<fstream>
using namespace std;

int main()
{
//.........
 string line;
ifstream file_stream ("C:\\highscore.txt");
                                                                     while(!file_stream.eof() && getline(file_stream, line))
//einlesen und wieder geben der Highscore
//....
string line;
              ofstream file_stream("c:\\highscore.txt",ios::out);
              file_stream<<" ";
              file_stream.close();
//inhalt löschen
//....
ofstream file_stream("C:\\highscore.txt",ios::app);
                                                                                               file_stream <<vorname<<" "<<name<<"\n";
                                                                                               file_stream.close();
//Vorname und nachname in ein txt document speicern(mit dem Datum hab ich mich noch net beschäftigt)