#include "Menü.h"
#include "Initialisierung.h"
#include <MausEreignis.h>
#include <Textfeld.h>
#include <InitDatei.h>
#include <Text.h>
#include <Datei.h>
#include <TastaturEreignis.h>
#include <KSGTDatei.h>
#include <Schrift.h>
#include <DateiSystem.h>
#include <Rahmen.h>

// Inhalt der MenüVerloren Klasse aus Menü.h
// Kontruktor
MenüVerloren::MenüVerloren( Schrift *zSchrift )
{
	ram = new LRahmen();
	ram->setSize( 160, 100 );
	ram->setPosition( 320, 200 );
	ram->setFarbe( 0xFFFFFFFF );
	verloren = initTextFeld( 325, 210, 150, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
	neu = initKnopf( 350, 240, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
	beenden = initKnopf( 350, 270, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
	ref = 1;
}

// Destruktor
MenüVerloren::~MenüVerloren()
{
	verloren->release();
	neu->release();
	beenden->release();
	ram->release();
}

// nicht constant
int MenüVerloren::doMausEreignis( MausEreignis &me )
{
	bool vera = me.verarbeitet;
	int ret = 0;
	neu->doMausEreignis( me );
	if( !vera && me.verarbeitet && me.id == ME_RLinks )
		ret = 1;
	beenden->doMausEreignis( me );
	if( !vera && me.verarbeitet && !ret && me.id == ME_RLinks )
		ret = 2;
	return ret;
}

bool MenüVerloren::tick( double tickVal )
{
	bool ret = verloren->tick( tickVal );
	ret |= neu->tick( tickVal );
	ret |= beenden->tick( tickVal );
	return ret;
}

void MenüVerloren::render( Bild &zRObj )
{
	zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
	verloren->render( zRObj );
	neu->render( zRObj );
	beenden->render( zRObj );
	ram->render( zRObj );
}

// Reference Counting
MenüVerloren *MenüVerloren::getThis()
{
	ref++;
	return this;
}

MenüVerloren *MenüVerloren::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}


// Inhalt der MenüSpiel Klasse aus Menü.h
// Konstruktor
MenüSpiel::MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen )
{
	scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
	beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
	map = new Map();
	verloren = new MenüVerloren( zSchrift );
	beendet = 0;
	ref = 1;
}

// Destruktor
MenüSpiel::~MenüSpiel()
{
	scoreT->release();
	beenden->release();
	map->release();
	verloren->release();
}

// nicht constant
void MenüSpiel::reset()
{
	map->reset();
	beendet = 0;
	scoreT->setText( "Score: " );
	scoreT->zText()->append( map->getScore() );
}

void MenüSpiel::doMausEreignis( MausEreignis &me )
{
	bool vera = me.verarbeitet;
	beenden->doMausEreignis( me );
	if( !vera && me.verarbeitet && me.id == ME_RLinks )
	{
		map->speichern();
		beendet = 1;
	}
	map->doMausEreignis( me );
	scoreT->setText( "Score: " );
	scoreT->zText()->append( map->getScore() );
	if( map->istBeendet() )
	{
		int ak = verloren->doMausEreignis( me );
		if( ak == 1 )
			reset();
		if( ak == 2 )
			beendet = 1;
	}
}

void MenüSpiel::doTastaturEreignis( TastaturEreignis &te )
{
	if( map->istBeendet() )
	{
		if( te.id == TE_Release && te.taste == T_Enter )
			reset();
		if( te.id == TE_Release && te.taste == T_BackSpace )
			beendet = 1;
		return;
	}
	map->doTastaturEreignis( te );
}

bool MenüSpiel::tick( double tickVal )
{
	bool ret = beenden->tick( tickVal );
	ret |= map->tick( tickVal );
	if( map->istBeendet() )
		ret |= verloren->tick( tickVal );
	return ret;
}

void MenüSpiel::render( Bild &zRObj )
{
	map->render( zRObj );
	scoreT->render( zRObj );
	beenden->render( zRObj );
	if( map->istBeendet() )
		verloren->render( zRObj );
}

// constant
bool MenüSpiel::istBeendet() const
{
	return beendet;
}

// Reference Counting
MenüSpiel *MenüSpiel::getThis()
{
	ref++;
	return this;
}

MenüSpiel *MenüSpiel::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}


// Inhalt der MenüStatistik Klasse aus Menü.h
// Konstruktor
MenüStatistik::MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen )
{
	ansichtT = initTextFeld( 245, 10, 50, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
	ansicht = initAuswahlBox( 295, 10, 120, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
	optionen = initKontrollKnopf( 425, 10, 130, 20, zSchrift, KontrollKnopf::Style::Normal, "Optionen beachten" );
	gesammtT = initObjTabelle( 150, 40, 500, 420, zSchrift, ObjTabelle::Style::normal, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Height", 70, 0, 0 }, { "Farben", 70, 0, 0 }, { "Tempo", 70, 0, 0 } }, 20 );
	optionenT = initObjTabelle( 150, 40, 500, 420, zSchrift, ObjTabelle::Style::normal, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Height", 70, 0, 0 }, { "Farben", 70, 0, 0 }, { "Tempo", 70, 0, 0 } }, 20 );
	gesammtD = initLinienDiagramm( 100, 40, 600, 420, zSchrift, LDiag::Style::DatenRahmen, 0 );
	optionenD = initLinienDiagramm( 100, 40, 600, 420, zSchrift, LDiag::Style::DatenRahmen, 0 );
	removen = initKnopf( 10, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurücksetzen" );
	zurück = initKnopf( 350, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurück" );
	schrift = zSchrift->getThis();
}

// Destruktor
MenüStatistik::~MenüStatistik()
{
	int anz = gesammtT->getZeilenAnzahl();
	for( int i = 0; i < anz; i++ )
	{
		for( int j = 0; j < 6; j++ )
			( (TextFeld*)gesammtT->zZeichnung( j, 0 ) )->release();
		gesammtT->removeZeile( 0 );
	}
	for( int j = 0; j < 6; j++ )
		( (TextFeld*)optionenT->zZeichnung( j, 0 ) )->release();
	ansichtT->release();
	ansicht->release();
	optionen->release();
	gesammtT->release();
	optionenT->release();
	gesammtD->release();
	optionenD->release();
	removen->release();
	zurück->release();
	schrift->release();
}

// nicht constant
void MenüStatistik::reset()
{
	int anz = gesammtT->getZeilenAnzahl();
	for( int i = 1; i < anz; i++ )
	{
		for( int j = 0; j < 6; j++ )
			( (TextFeld*)gesammtT->zZeichnung( j, 1 ) )->release();
		gesammtT->removeZeile( 1 );
	}
	anz = optionenT->getZeilenAnzahl();
	for( int i = 1; i < anz; i++ )
		optionenT->removeZeile( 1 );
	InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
	opd->laden();
	if( !opd->wertExistiert( "Breite" ) )
		opd->addWert( "Breite", "20" );
	if( !opd->wertExistiert( "Height" ) )
		opd->addWert( "Height", "12" );
	if( !opd->wertExistiert( "Farben" ) )
		opd->addWert( "Farben", "5" );
	if( !opd->wertExistiert( "Geschwindigkeit" ) )
		opd->addWert( "Geschwindigkeit", "4000" );
	if( !opd->wertExistiert( "Fortsetzen" ) )
		opd->addWert( "Fortsetzen", "0" );
	opd->speichern();
	KSGTDatei *stb = new KSGTDatei( "data/Minigames/Blöcke/data/score.ksgt" );
	stb->laden();
	anz = stb->getZeilenAnzahl();
	bool *fertig = new bool[ anz ];
	ZeroMemory( fertig, anz );
	int mS = 0;
	int omS = 0;
	int oAnz = 0;
	for( int i = 0; i < anz; i++ )
	{
		int maxScore = -1;
		int p = -1;
		for( int j = 0; j < anz; j++ )
		{
			if( !fertig[ j ] && maxScore < (int)*stb->zFeld( j, 1 ) )
			{
				p = j;
				maxScore = (int)*stb->zFeld( j, 1 );
			}
		}
		if( p >= 0 )
		{
			fertig[ p ] = 1;
			TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
			TextFeld *datumT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
			TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
			TextFeld *höheT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
			TextFeld *farbenT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
			TextFeld *tempoT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
			gesammtT->addZeile( Text() += p );
			gesammtT->setZeichnungZ( 0, i + 1, scoreT );
			gesammtT->setZeichnungZ( 1, i + 1, datumT );
			gesammtT->setZeichnungZ( 2, i + 1, breiteT );
			gesammtT->setZeichnungZ( 3, i + 1, höheT );
			gesammtT->setZeichnungZ( 4, i + 1, farbenT );
			gesammtT->setZeichnungZ( 5, i + 1, tempoT );
			if( breiteT->zText()->istGleich( opd->zWert( "Breite" )->getText() ) &&
				höheT->zText()->istGleich( opd->zWert( "Height" )->getText() ) &&
				farbenT->zText()->istGleich( opd->zWert( "Farben" )->getText() ) &&
				tempoT->zText()->istGleich( opd->zWert( "Geschwindigkeit" )->getText() ) )
			{
				optionenT->addZeile( Text() += p );
				int n = optionenT->getZeilenNummer( Text() += p );
				optionenT->setZeichnungZ( 0, n, scoreT );
				optionenT->setZeichnungZ( 1, n, datumT );
				optionenT->setZeichnungZ( 2, n, breiteT );
				optionenT->setZeichnungZ( 3, n, höheT );
				optionenT->setZeichnungZ( 4, n, farbenT );
				optionenT->setZeichnungZ( 5, n, tempoT );
				if( !omS )
					omS = maxScore;
				oAnz++;
			}
		}
		if( !mS )
			mS = maxScore;
	}
	delete[] fertig;
	DiagDaten *gd = new DiagDaten();
	gd->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
	gd->hIntervallFarbe = 0xFFFFFFFF;
	gd->hIntervallName->setText( "Spiel" );
	gd->rasterDicke = 1;
	gd->rasterFarbe = 0xFF505050;
	gd->vIntervallFarbe = 0xFFFFFFFF;
	gd->vIntervallName->setText( "Score" );
	gesammtD->setDiagDatenZ( gd );
	gesammtD->addVIntervallText( mS + 1, Text() += ( mS + 1 ) );
	gesammtD->addVIntervallText( 0, "0" );
	gesammtD->addHIntervallText( 0, "1" );
	if( anz > 1 )
		gesammtD->addHIntervallText( anz - 1, Text() += anz );
	gesammtD->addWert( "Score" );
	gesammtD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
	gesammtD->setWertFarbe( 0, 0xFF00FF00 );
	gesammtD->zDiagWert( 0 )->hintergrund = 0xFF205050;
	DiagDaten *od = new DiagDaten();
	od->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
	od->hIntervallFarbe = 0xFFFFFFFF;
	od->hIntervallName->setText( "Spiel" );
	od->rasterDicke = 1;
	od->rasterFarbe = 0xFF505050;
	od->vIntervallFarbe = 0xFFFFFFFF;
	od->vIntervallName->setText( "Score" );
	optionenD->setDiagDatenZ( od );
	optionenD->addVIntervallText( omS + 1, Text() += ( omS + 1 ) );
	optionenD->addVIntervallText( 0, "0" );
	optionenD->addHIntervallText( 0, "1" );
	if( oAnz > 1 )
		optionenD->addHIntervallText( oAnz - 1, Text() += oAnz );
	optionenD->addWert( "Score" );
	optionenD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
	optionenD->setWertFarbe( 0, 0xFF00FF00 );
	optionenD->zDiagWert( 0 )->hintergrund = 0xFF205050;
	int j = 0;
	for( int i = 0; i < anz; i++ )
	{
		gesammtD->addPunkt( 0, i, (int)*stb->zFeld( i, 1 ) );
		if( (int)*stb->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
			(int)*stb->zFeld( i, 3 ) == (int)*opd->zWert( "Height" ) &&
			(int)*stb->zFeld( i, 5 ) == (int)*opd->zWert( "Farben" ) &&
			(int)*stb->zFeld( i, 4 ) == (int)*opd->zWert( "Geschwindigkeit" ) )
		{
			optionenD->addPunkt( 0, j, (int)*stb->zFeld( i, 1 ) );
			j++;
		}
	}
	stb->release();
	opd->release();
	beendet = 0;
}

void MenüStatistik::doMausEreignis( MausEreignis &me )
{
	ansicht->doMausEreignis( me );
	optionen->doMausEreignis( me );
	bool vera = me.verarbeitet;
	removen->doMausEreignis( me );
	if( !vera && me.verarbeitet && me.id == ME_RLinks )
	{ // Statistik removen
		if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
		{ // nur bestimmte Statistik removen
			InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
			opd->laden();
			KSGTDatei *score = new KSGTDatei( "data/Minigames/Blöcke/data/score.ksgt" );
			score->laden();
			int zeilen = score->getZeilenAnzahl();
			for( int i = 0; i < zeilen; i++ )
			{
				if( (int)*score->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
					(int)*score->zFeld( i, 3 ) == (int)*opd->zWert( "Height" ) &&
					(int)*score->zFeld( i, 5 ) == (int)*opd->zWert( "Farben" ) &&
					(int)*score->zFeld( i, 4 ) == (int)*opd->zWert( "Geschwindigkeit" ) )
				{
					score->removeZeile( i );
					i--;
					zeilen--;
				}
			}
			score->speichern();
			score->release();
			opd->release();
		}
		else // alles removen
			DateiRemove( "data/Minigames/Blöcke/data/score.ksgt" );
		reset();
	}
	vera = me.verarbeitet;
	zurück->doMausEreignis( me );
	if( !vera && me.verarbeitet && me.id == ME_RLinks )
		beendet = 1;
}

bool MenüStatistik::tick( double tickVal )
{
	bool ret = ansicht->tick( tickVal );
	ret |= optionen->tick( tickVal );
	ret |= removen->tick( tickVal );
	ret |= zurück->tick( tickVal );
	ret |= gesammtT->tick( tickVal );
	ret |= optionenT->tick( tickVal );
	ret |= gesammtD->tick( tickVal );
	ret |= optionenD->tick( tickVal );
	return ret;
}

void MenüStatistik::render( Bild &zRObj )
{
	if( !ansicht->getAuswahl() )
	{
		if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
			optionenT->render( zRObj );
		else
			gesammtT->render( zRObj );
	}
	else
	{
		if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
			optionenD->render( zRObj );
		else
			gesammtD->render( zRObj );
	}
	ansichtT->render( zRObj );
	ansicht->render( zRObj );
	optionen->render( zRObj );
	removen->render( zRObj );
	zurück->render( zRObj );
}

// constant
bool MenüStatistik::istBeendet() const
{
	return beendet;
}

// Reference Counting
MenüStatistik *MenüStatistik::getThis()
{
	ref++;
	return this;
}

MenüStatistik *MenüStatistik::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}


// Inhalt der MenüOptionen aus Menü.h
// Konstruktor
MenüOptionen::MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen )
{
	breiteT = initTextFeld( 310, 140, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
	breite = initTextFeld( 440, 140, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
	breite->setTastaturEreignis( _nurNummernTE );
	höheT = initTextFeld( 310, 180, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Height:" );
	höhe = initTextFeld( 440, 180, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
	höhe->setTastaturEreignis( _nurNummernTE );
	bAnzahlT = initTextFeld( 310, 220, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Verschiedene Farben:" );
	bAnzahl = initTextFeld( 440, 220, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
	bAnzahl->setTastaturEreignis( _nurNummernTE );
	tempoT = initTextFeld( 310, 260, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
	tempo = initTextFeld( 440, 260, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
	tempo->setTastaturEreignis( _nurNummernTE );
	fortsetzen = initKontrollKnopf( 310, 300, 180, 20, zSchrift, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
	fortsetzen->setMausEreignis( _ret1ME );
	abbrechen = initKnopf( 310, 340, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
	ok = initKnopf( 405, 340, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Ok" );
	beendet = 0;
	ref = 1;
}

// Destruktor
MenüOptionen::~MenüOptionen()
{
	breiteT->release();
	breite->release();
	höheT->release();
	höhe->release();
	bAnzahlT->release();
	bAnzahl->release();
	tempoT->release();
	tempo->release();
	fortsetzen->release();
	abbrechen->release();
	ok->release();
}

// nicht constant
void MenüOptionen::reset()
{
	InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
	if( !opd->laden() )
		DateiPfadErstellen( "data/Minigames/Blöcke/data/optionen.ini" );
	breite->setText( "20" );
	if( opd->wertExistiert( "Breite" ) )
		breite->setText( Text() += (int)*opd->zWert( "Breite" ) );
	else
		opd->addWert( "Breite", "20" );
	höhe->setText( "12" );
	if( opd->wertExistiert( "Height" ) )
		höhe->setText( Text() += (int)*opd->zWert( "Height" ) );
	else
		opd->addWert( "Height", "12" );
	bAnzahl->setText( "5" );
	if( opd->wertExistiert( "Farben" ) )
		bAnzahl->setText( Text() += (int)*opd->zWert( "Farben" ) );
	else
		opd->addWert( "Farben", "5" );
	tempo->setText( "4000" );
	if( opd->wertExistiert( "Geschwindigkeit" ) )
		tempo->setText( Text() += (int)*opd->zWert( "Geschwindigkeit" ) );
	else
		opd->addWert( "Geschwindigkeit", "4000" );
	fortsetzen->removeStyle( KontrollKnopf::Style::Selected );
	if( opd->wertExistiert( "Fortsetzen" ) )
		fortsetzen->setStyle( KontrollKnopf::Style::Selected, (int)*opd->zWert( "Fortsetzen" ) != 0 );
	else
		opd->addWert( "Fortsetzen", "0" );
	beendet = 0;
	opd->speichern();
	opd->release();
}

void MenüOptionen::doMausEreignis( MausEreignis &me )
{
	breite->doMausEreignis( me );
	höhe->doMausEreignis( me );
	bAnzahl->doMausEreignis( me );
	tempo->doMausEreignis( me );
	fortsetzen->doMausEreignis( me );
	bool vera = me.verarbeitet;
	abbrechen->doMausEreignis( me );
	if( !vera && me.verarbeitet && me.id == ME_RLinks )
		beendet = 1;
	vera = me.verarbeitet;
	ok->doMausEreignis( me );
	if( !vera && me.verarbeitet && me.id == ME_RLinks )
	{
		InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
		if( !opd->laden() )
			DateiPfadErstellen( "data/Minigames/Blöcke/data/optionen.ini" );
		if( (int)*breite->zText() > 100 )
			breite->setText( "100" );
		if( (int)*breite->zText() < 10 )
			breite->setText( "10" );
		if( opd->wertExistiert( "Breite" ) )
			opd->setWert( "Breite", Text() += (int)*breite->zText() );
		else
			opd->addWert( "Breite", Text() += (int)*breite->zText() );
		if( (int)*höhe->zText() > 100 )
			höhe->setText( "100" );
		if( (int)*höhe->zText() < 10 )
			höhe->setText( "10" );
		if( opd->wertExistiert( "Height" ) )
			opd->setWert( "Height", Text() += (int)*höhe->zText() );
		else
			opd->addWert( "Height", Text() += (int)*höhe->zText() );
		if( (int)*bAnzahl->zText() > 10 )
			bAnzahl->setText( "10" );
		if( (int)*bAnzahl->zText() < 3 )
			bAnzahl->setText( "3" );
		if( opd->wertExistiert( "Farben" ) )
			opd->setWert( "Farben", Text() += (int)*bAnzahl->zText() );
		else
			opd->addWert( "Farben", Text() += (int)*bAnzahl->zText() );
		if( (int)*tempo->zText() < 100 )
			tempo->setText( "100" );
		if( opd->wertExistiert( "Geschwindigkeit" ) )
			opd->setWert( "Geschwindigkeit", Text() += (int)*tempo->zText() );
		else
			opd->addWert( "Geschwindigkeit", Text() += (int)*tempo->zText() );
		if( opd->wertExistiert( "Fortsetzen" ) )
			opd->setWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
		else
			opd->addWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
		opd->speichern();
		opd->release();
		beendet = 1;
	}
}

void MenüOptionen::doTastaturEreignis( TastaturEreignis &te )
{
	breite->doTastaturEreignis( te );
	höhe->doTastaturEreignis( te );
	bAnzahl->doTastaturEreignis( te );
	tempo->doTastaturEreignis( te );
}

bool MenüOptionen::tick( double tickVal )
{
	bool ret = breite->tick( tickVal );
	ret |= höhe->tick( tickVal );
	ret |= bAnzahl->tick( tickVal );
	ret |= tempo->tick( tickVal );
	ret |= fortsetzen->tick( tickVal );
	ret |= abbrechen->tick( tickVal );
	ret |= ok->tick( tickVal );
	return ret;
}

void MenüOptionen::render( Bild &zRObj )
{
	breiteT->render( zRObj );
	breite->render( zRObj );
	höheT->render( zRObj );
	höhe->render( zRObj );
	bAnzahlT->render( zRObj );
	bAnzahl->render( zRObj );
	tempoT->render( zRObj );
	tempo->render( zRObj );
	fortsetzen->render( zRObj );
	abbrechen->render( zRObj );
	ok->render( zRObj );
}

// constant
bool MenüOptionen::istBeendet() const
{
	return beendet;
}

// Reference Counting
MenüOptionen *MenüOptionen::getThis()
{
	ref++;
	return this;
}

MenüOptionen *MenüOptionen::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}


// Inhalt der Menü Klasse aus Menü.h
// Konstruktor
Menü::Menü( Schrift *zSchrift, Bildschirm *zScreen )
{
	spielen = initKnopf( 350, 180, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Spielen" );
	spielenF = new MenüSpiel( zSchrift, zScreen );
	optionen = initKnopf( 350, 220, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Optionen" );
	optionenF = new MenüOptionen( zSchrift, zScreen );
	statistik = initKnopf( 350, 260, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Statistik" );
	statistikF = new MenüStatistik( zSchrift, zScreen );
	beenden = initKnopf( 350, 300, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
	ram = new LRahmen();
	ram->setFarbe( 0xFFFFFFFF );
	beendet = 0;
	status = 0;
	LTDBDatei *bgd = new LTDBDatei();
	bgd->setDatei( new Text( "data/Minigames/Blöcke/bilder/hintergrund.ltdb" ) );
	bgd->leseDaten( 0 );
	hintergrund = bgd->laden( 0, new Text( "bg.jpg" ) );
	bgd->release();
	ref = 1;
}

// Destruktor
Menü::~Menü()
{
	spielen->release();
	spielenF->release();
	optionen->release();
	optionenF->release();
	statistik->release();
	statistikF->release();
	beenden->release();
	if( hintergrund )
		hintergrund->release();
	ram->release();
}

// nicht constant
void Menü::reset()
{
	status = 0;
	beendet = 0;
}

void Menü::doMausEreignis( MausEreignis &me )
{
	switch( status )
	{
	case 0:
		if( 1 )
		{
			bool vera = me.verarbeitet;
			spielen->doMausEreignis( me );
			if( !vera && me.verarbeitet && me.id == ME_RLinks )
			{
				spielenF->reset();
				status = 3;
			}
			vera = me.verarbeitet;
			optionen->doMausEreignis( me );
			if( !vera && me.verarbeitet && me.id == ME_RLinks )
			{
				optionenF->reset();
				status = 1;
			}
			vera = me.verarbeitet;
			statistik->doMausEreignis( me );
			if( !vera && me.verarbeitet && me.id == ME_RLinks )
			{
				statistikF->reset();
				status = 2;
			}
			vera = me.verarbeitet;
			beenden->doMausEreignis( me );
			if( !vera && me.verarbeitet && me.id == ME_RLinks )
				beendet = 1;
		}
		break;
	case 1:
		optionenF->doMausEreignis( me );
		break;
	case 2:
		statistikF->doMausEreignis( me );
		break;
	case 3:
		spielenF->doMausEreignis( me );
	}
}

void Menü::doTastaturEreignis( TastaturEreignis &te )
{
	if( status == 1 )
		optionenF->doTastaturEreignis( te );
	if( status == 3 )
		spielenF->doTastaturEreignis( te );
}

bool Menü::tick( double z )
{
	switch( status )
	{
	case 0:
		if( 1 )
		{
			bool ret = spielen->tick( z );
			ret |= statistik->tick( z );
			ret |= optionen->tick( z );
			ret |= beenden->tick( z );
			return ret;
		}
	case 1:
		if( optionenF->istBeendet() )
		{
			status = 0;
			return 1;
		}
		return optionenF->tick( z );
	case 2:
		if( statistikF->istBeendet() )
		{
			status = 0;
			return 1;
		}
		return statistikF->tick( z );
	case 3:
		if( spielenF->istBeendet() )
		{
			status = 0;
			return 1;
		}
		return spielenF->tick( z );
	}
	return 0;
}

void Menü::render( Bild &zRObj )
{
	if( status != 3 )
		zRObj.drawBild( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), *hintergrund );
	switch( status )
	{
	case 0:
		ram->setPosition( 300, 170 );
		ram->setSize( 200, 160 );
		zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
		ram->render( zRObj );
		spielen->render( zRObj );
		statistik->render( zRObj );
		optionen->render( zRObj );
		beenden->render( zRObj );
		break;
	case 1:
		ram->setPosition( 300, 130 );
		ram->setSize( 200, 240 );
		zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
		ram->render( zRObj );
		optionenF->render( zRObj );
		break;
	case 2:
		zRObj.alphaRegion( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), 0xD0000000 );
		statistikF->render( zRObj );
		break;
	case 3:
		spielenF->render( zRObj );
	}
}

// constant
bool Menü::istBeendet() const
{
	return beendet;
}

// Reference Counting
Menü *Menü::getThis()
{
	ref++;
	return this;
}

Menü *Menü::release()
{
	ref--;
	if( !ref )
		delete this;
	return 0;
}