#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>
#include <AsynchronCall.h>
#include <Bildschirm.h>

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

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

// nicht constant
int MenüVerloren::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	int ret = 0;
	neu->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
		ret = 1;
	beenden->doPublicMausEreignis(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);
}


// Inhalt der MenüSpiel Klasse aus Menü.h
// Konstruktor
MenüSpiel::MenüSpiel(UIInit& uiFactory, KSGClient::MinigameServerClient* klient)
	: ReferenceCounter()
{
	scoreT = initTextFeld(690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0");
	beenden = initKnopf(690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden");
	map = new Map(klient);
	verloren = new MenüVerloren(uiFactory);
	beendet = 0;
	timePuffer = 0;
}

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

// nicht constant
void MenüSpiel::reset()
{
	timePuffer = 0;
	Text optionen = "Width=";
	InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
	if (!opd->laden())
		DateiPfadErstellen("data/Minigames/Asteroids/data/optionen.ini");
	if (opd->wertExistiert("Breite"))
		optionen += (int)*opd->zWert("Breite");
	else
	{
		opd->addWert("Breite", "1600");
		optionen += "1600";
	}
	optionen += ",Height=";
	if (opd->wertExistiert("Höhe"))
		optionen += (int)*opd->zWert("Höhe");
	else
	{
		opd->addWert("Höhe", "1000");
		optionen += "1000";
	}
	optionen += ",Size=";
	if (opd->wertExistiert("Größe"))
		optionen += (int)*opd->zWert("Größe");
	else
	{
		opd->addWert("Größe", "1000");
		optionen += 1000;
	}
	optionen += ",Timer=";
	if (opd->wertExistiert("Timer"))
		optionen += (int)*opd->zWert("Timer");
	else
	{
		opd->addWert("Timer", "5000");
		optionen += 5000;
	}
	optionen += ",Ship=";
	if (opd->wertExistiert("Ship"))
		optionen += (int)*opd->zWert("Ship");
	else
	{
		opd->addWert("Ship", "0");
		optionen += 0;
	}
	optionen += ",Fortsetzen=";
	if (opd->wertExistiert("Fortsetzen"))
		optionen += (int)*opd->zWert("Fortsetzen") != 0;
	else
	{
		opd->addWert("Fortsetzen", "0");
		optionen += 0;
	}
	optionen += ",AutoKam=";
	if (opd->wertExistiert("AutoKam"))
		optionen += (int)*opd->zWert("AutoKam") != 0;
	else
	{
		opd->addWert("AutoKam", "0");
		optionen += 0;
	}
	opd->speichern();
	opd->release();
	map->reset(&optionen);
	beendet = 0;
	scoreT->setText("Score: ");
	scoreT->zText()->append(map->getScore());
}

void MenüSpiel::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	beenden->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
	{
		map->speichern();
		beendet = 1;
	}
	map->doPublicMausEreignis(me);
	if (map->istBeendet())
	{
		int ak = verloren->doPublicMausEreignis(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)
{
	timePuffer += tickVal;

	bool ret = beenden->tick(tickVal);
	while (timePuffer >= 0.02)
	{
		ret |= map->tick(0.02);
		timePuffer -= 0.02;
	}
	if (map->istBeendet())
		ret |= verloren->tick(tickVal);
	scoreT->setText("Score: ");
	scoreT->zText()->append(map->getScore());
	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;
}


// Inhalt der MenüWiederhohlung Klasse
// Konstruktor
MenüWiederhohlung::MenüWiederhohlung(UIInit& uiFactory, Datei* datei, Text* zOptionen)
	: ReferenceCounter()
{
	scoreT = initTextFeld(690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0");
	beenden = initKnopf(690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden");
	this->datei = datei;
	if (!datei->istOffen())
		datei->open(Datei::Style::lesen);
	__int64 seed;
	datei->lese((char*)&seed, 8);
	zOptionen->append(",Fortsetzen=0,AutoKam=0,Seed=");
	zOptionen->append(seed);
	map = new Map(0);
	map->reset(zOptionen);
	beendet = 0;
	nowTime = 0;
	nextTime = 0;
	tastenStände = 0;
	datei->lese((char*)&nextTime, 8);
	timePuffer = 0;
}

// Destruktor
MenüWiederhohlung::~MenüWiederhohlung()
{
	scoreT->release();
	beenden->release();
	map->release();
	datei->close();
	datei->release();
}

// nicht constant
void MenüWiederhohlung::doPublicMausEreignis(MausEreignis& me)
{
	bool vera = me.verarbeitet;
	beenden->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
		beendet = 1;
	if (map->istBeendet())
		beendet = 1;
}

void MenüWiederhohlung::doTastaturEreignis(TastaturEreignis& te)
{}

bool MenüWiederhohlung::tick(double tickVal)
{
	bool ret = beenden->tick(tickVal);
	// TODO Replay Activity
	while (nextTime >= 0 && nowTime + tickVal >= nextTime)
	{
		while (nowTime < nextTime)
		{
			ret |= map->tick(0.02);
			tickVal -= 0.02;
			nowTime += 0.02;
		}
		char aktion;
		datei->lese(&aktion, 1);
		if (datei->istEnde())
			nextTime = -1;
		else
			datei->lese((char*)&nextTime, 8);
		TastaturEreignis te;
		te.verarbeitet = 0;
		if ((aktion | 16) == aktion)
		{
			te.id = TE_Press;
			te.taste = T_Space;
		}
		else if (aktion != tastenStände)
		{
			if ((aktion & ~1) == (tastenStände & ~1))
			{
				te.taste = T_Oben;
				te.id = ((aktion | 1) == aktion) ? TE_Press : TE_Release;
			}
			if ((aktion & ~2) == (tastenStände & ~2))
			{
				te.taste = T_Rechts;
				te.id = ((aktion | 2) == aktion) ? TE_Press : TE_Release;
			}
			if ((aktion & ~4) == (tastenStände & ~4))
			{
				te.taste = T_Links;
				te.id = ((aktion | 4) == aktion) ? TE_Press : TE_Release;
			}
			if ((aktion & ~8) == (tastenStände & ~8))
			{
				te.taste = T_Space;
				te.id = ((aktion | 8) == aktion) ? TE_Press : TE_Release;
			}
			tastenStände = aktion;
		}
		map->doTastaturEreignis(te);
	}
	timePuffer += tickVal;
	while (timePuffer > 0)
	{
		ret |= map->tick(0.02);
		nowTime += 0.02;
		timePuffer -= 0.02;
	}
	scoreT->setText("Score: ");
	scoreT->zText()->append(map->getScore());
	return ret;
}

void MenüWiederhohlung::render(Bild& zRObj)
{
	map->render(zRObj);
	scoreT->render(zRObj);
	beenden->render(zRObj);
}

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


// Inhalt der MenüStatistik Klasse aus Menü.h
// Konstruktor
MenüStatistik::MenüStatistik(UIInit& uiFactory, KSGClient::MinigameServerClient* klient)
{
	this->klient = klient;
	wiederH = 0;
	ansichtT = initTextFeld(245, 10, 50, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:");
	ansicht = initAuswahlBox(295, 10, 120, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" });
	optionen = initKontrollKnopf(425, 10, 130, 20, uiFactory, KontrollKnopf::Style::Normal, "Optionen beachten");
	worldBestT = initObjTabelle(115, 40, 570, 120, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, {"Ansehen", 55, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20);
	gesammtT = initObjTabelle(115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20);
	optionenT = initObjTabelle(115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20);
	gesammtD = initLinienDiagramm(100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0);
	optionenD = initLinienDiagramm(100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0);
	remove = initKnopf(10, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurücksetzen");
	zurück = initKnopf(350, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurück");
	this->uiFactory = uiFactory;
	tr = new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
	asyncFinished = 1;
}

// Destruktor
MenüStatistik::~MenüStatistik()
{
	while (!asyncFinished)
		Sleep(100);
	tr->release();
	worldBestT->release();
	ansichtT->release();
	ansicht->release();
	optionen->release();
	gesammtT->release();
	optionenT->release();
	gesammtD->release();
	optionenD->release();
	remove->release();
	zurück->release();
	klient->release();
	if (wiederH)
		wiederH->release();
}

// nicht constant
void MenüStatistik::reset()
{
	if (wiederH)
		wiederH = (MenüWiederhohlung*)wiederH->release();
	ObjTabelle* tmpWBT = dynamic_cast<ObjTabelle*>(worldBestT->getThis());
	KSGClient::MinigameServerClient* tmpKlient = dynamic_cast<KSGClient::MinigameServerClient*>(klient->getThis());
	asyncFinished = 0;
	new AsynchronCall([this, tmpWBT, tmpKlient]()
		{
			Array< int > score;
			RCArray< Text > player;
			RCArray< Text > option;
			int anz = tmpKlient->getMinigameBestscoreList("Asteroids", &score, &player, &option);
			for (int i = 0; i < anz; i++)
			{
				TextFeld* scoreT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, Text(score.get(i)));
				TextFeld* spielerT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z(i)->getText());
				Text optionen = option.z(i)->getText();
				Text* breite = optionen.getTeilText(optionen.positionVon('=') + 1, optionen.positionVon(','));
				Text* höhe = optionen.getTeilText(optionen.positionVon('=', 1) + 1, optionen.positionVon(',', 1));
				Text* größe = optionen.getTeilText(optionen.positionVon('=', 2) + 1, optionen.positionVon(',', 2));
				Text* timer = optionen.getTeilText(optionen.positionVon('=', 3) + 1, optionen.positionVon(',', 3));
				Text* ship = optionen.getTeilText(optionen.positionVon('=', 4) + 1);
				switch ((int)*ship)
				{
				case 0:
					ship->setText("Normal");
					break;
				case 1:
					ship->setText("Enterprise");
					break;
				}
				TextFeld* breiteT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText());
				breite->release();
				TextFeld* höheT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText());
				höhe->release();
				TextFeld* größeT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, größe->getText());
				größe->release();
				TextFeld* timerT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, timer->getText());
				timer->release();
				TextFeld* shipT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, ship->getText());
				ship->release();
				Knopf* ansehenK = initKnopf(0, 0, 0, 0, uiFactory, Knopf::Style::Normal, "Ansehen");
				ansehenK->setMausEreignis([this, optionen](void* p, void* obj, MausEreignis me) -> bool
					{
						if (me.id == ME_RLinks && !me.verarbeitet)
						{
							((Knopf*)obj)->removeStyle(Knopf::Style::Erlaubt);
							getThis();
							new AsynchronCall([this, optionen, obj]()
								{
									Datei* d = klient->downloadGameCapture("Asteroids", optionen);
									((Knopf*)obj)->addStyle(Knopf::Style::Erlaubt);
									if (wiederH)
										wiederH = (MenüWiederhohlung*)wiederH->release();
									Text options = optionen.getText();
									wiederH = new MenüWiederhohlung(uiFactory, d, &options);
									release();
								});
						}
						return 1;
					});
				tmpWBT->addZeile(optionen.getText());
				tmpWBT->setZeichnungZ(0, i + 1, scoreT);
				tmpWBT->setZeichnungZ(1, i + 1, spielerT);
				tmpWBT->setZeichnungZ(2, i + 1, ansehenK);
				tmpWBT->setZeichnungZ(3, i + 1, breiteT);
				tmpWBT->setZeichnungZ(4, i + 1, höheT);
				tmpWBT->setZeichnungZ(5, i + 1, größeT);
				tmpWBT->setZeichnungZ(6, i + 1, timerT);
				tmpWBT->setZeichnungZ(7, i + 1, shipT);
			}
			tmpKlient->release();
			tmpWBT->release();
		}, &asyncFinished);
	InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
	opd->laden();
	if (!opd->wertExistiert("Breite"))
		opd->addWert("Breite", "1600");
	if (!opd->wertExistiert("Höhe"))
		opd->addWert("Höhe", "1000");
	if (!opd->wertExistiert("Größe"))
		opd->addWert("Größe", "1000");
	if (!opd->wertExistiert("Timer"))
		opd->addWert("Timer", "5000");
	if (!opd->wertExistiert("Ship"))
		opd->addWert("Ship", "0");
	if (!opd->wertExistiert("Fortsetzen"))
		opd->addWert("Fortsetzen", "0");
	if (!opd->wertExistiert("AutoKam"))
		opd->addWert("AutoKam", "0");
	opd->speichern();
	KSGTDatei* stb = new KSGTDatei("data/Minigames/Asteroids/data/score.ksgt");
	stb->laden();
	int 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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 1)->getText());
			TextFeld* datumT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 0)->getText());
			TextFeld* breiteT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 2)->getText());
			TextFeld* höheT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 3)->getText());
			TextFeld* größeT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 5)->getText());
			TextFeld* timerT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 4)->getText());
			TextFeld* shipT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 6)->getText());
			int ship = (int)*stb->zFeld(p, 6);
			switch (ship)
			{
			case 0:
				shipT->setText("Normal");
				break;
			case 1:
				shipT->setText("Enterprise");
				break;
			}
			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, größeT);
			gesammtT->setZeichnungZ(5, i + 1, timerT);
			gesammtT->setZeichnungZ(6, i + 1, shipT);
			if (breiteT->zText()->istGleich(opd->zWert("Breite")->getText()) &&
				höheT->zText()->istGleich(opd->zWert("Höhe")->getText()) &&
				größeT->zText()->istGleich(opd->zWert("Größe")->getText()) &&
				timerT->zText()->istGleich(opd->zWert("Timer")->getText()) &&
				stb->zFeld(p, 6)->istGleich(opd->zWert("Ship")->getText()))
			{
				optionenT->addZeile(Text() += p);
				int n = optionenT->getZeilenNummer(Text() += p);
				optionenT->setZeichnungZ(0, n, dynamic_cast<Zeichnung*>(scoreT->getThis()));
				optionenT->setZeichnungZ(1, n, dynamic_cast<Zeichnung*>(datumT->getThis()));
				optionenT->setZeichnungZ(2, n, dynamic_cast<Zeichnung*>(breiteT->getThis()));
				optionenT->setZeichnungZ(3, n, dynamic_cast<Zeichnung*>(höheT->getThis()));
				optionenT->setZeichnungZ(4, n, dynamic_cast<Zeichnung*>(größeT->getThis()));
				optionenT->setZeichnungZ(5, n, dynamic_cast<Zeichnung*>(timerT->getThis()));
				optionenT->setZeichnungZ(6, n, dynamic_cast<Zeichnung*>(shipT->getThis()));
				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("Höhe") &&
			(int)*stb->zFeld(i, 5) == (int)*opd->zWert("Größe") &&
			(int)*stb->zFeld(i, 4) == (int)*opd->zWert("Timer") &&
			(int)*stb->zFeld(i, 6) == (int)*opd->zWert("Ship"))
		{
			optionenD->addPunkt(0, j, (int)*stb->zFeld(i, 1));
			j++;
		}
	}
	stb->release();
	opd->release();
	beendet = 0;
}

void MenüStatistik::doPublicMausEreignis(MausEreignis& me)
{
	if (wiederH)
	{
		wiederH->doPublicMausEreignis(me);
		return;
	}
	ansicht->doPublicMausEreignis(me);
	optionen->doPublicMausEreignis(me);
	gesammtT->doPublicMausEreignis(me);
	optionenT->doPublicMausEreignis(me);
	worldBestT->doPublicMausEreignis(me);
	bool vera = me.verarbeitet;
	remove->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
	{ // Statistik remove
		if (optionen->hatStyle(KontrollKnopf::Style::Selected))
		{ // nur bestimmte Statistik remove
			InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
			opd->laden();
			KSGTDatei* score = new KSGTDatei("data/Minigames/Asteroids/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("Höhe") &&
					(int)*score->zFeld(i, 5) == (int)*opd->zWert("Größe") &&
					(int)*score->zFeld(i, 4) == (int)*opd->zWert("Timer") &&
					(int)*score->zFeld(i, 6) == (int)*opd->zWert("Ship"))
				{
					score->removeZeile(i);
					i--;
					zeilen--;
				}
			}
			score->speichern();
			score->release();
			opd->release();
		}
		else // alles remove
			DateiRemove("data/Minigames/Asteroids/data/score.ksgt");
		reset();
	}
	vera = me.verarbeitet;
	zurück->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
		beendet = 1;
}

bool MenüStatistik::tick(double tickVal)
{
	if (wiederH)
	{
		bool ret = wiederH->tick(tickVal);
		if (wiederH->istBeendet())
			wiederH = (MenüWiederhohlung*)wiederH->release();
		return ret;
	}
	bool ret = ansicht->tick(tickVal);
	ret |= optionen->tick(tickVal);
	ret |= remove->tick(tickVal);
	ret |= zurück->tick(tickVal);
	ret |= gesammtT->tick(tickVal);
	ret |= optionenT->tick(tickVal);
	ret |= gesammtD->tick(tickVal);
	ret |= optionenD->tick(tickVal);
	ret |= worldBestT->tick(tickVal);
	return ret;
}

void MenüStatistik::render(Bild& zRObj)
{
	if (wiederH)
	{
		wiederH->render(zRObj);
		return;
	}
	tr->setSchriftSize(12);
	Text weltScore = "Welt Score:";
	tr->renderText(10, 40, weltScore, zRObj, 0xFFFFFFFF);
	Text localScore = "Dein Score:";
	tr->renderText(10, 170, localScore, zRObj, 0xFFFFFFFF);
	worldBestT->render(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);
	remove->render(zRObj);
	zurück->render(zRObj);
}

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

bool MenüStatistik::istWiederhohlung() const
{
	return wiederH != 0;
}


// Inhalt der MenüOptionen aus Menü.h
// Konstruktor
MenüOptionen::MenüOptionen(UIInit& uiFactory)
	: ReferenceCounter()
{
	breiteT = initTextFeld(310, 120, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:");
	breite = initTextFeld(440, 120, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	breite->setTastaturEreignis(_nurNummernTE);
	höheT = initTextFeld(310, 160, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Höhe:");
	höhe = initTextFeld(440, 160, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	höhe->setTastaturEreignis(_nurNummernTE);
	aGrößeT = initTextFeld(310, 200, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Asteroiden Größe:");
	aGröße = initTextFeld(440, 200, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	aGröße->setTastaturEreignis(_nurNummernTE);
	timerT = initTextFeld(310, 240, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:");
	timer = initTextFeld(440, 240, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
	timer->setTastaturEreignis(_nurNummernTE);
	shipT = initTextFeld(310, 280, 80, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Raumschiff:");
	ship = initAuswahlBox(390, 280, 100, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Normal", "Enterprise" });
	autoKam = initKontrollKnopf(310, 320, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Kamera drehen");
	fortsetzen = initKontrollKnopf(310, 360, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen");
	abbrechen = initKnopf(310, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Abbrechen");
	ok = initKnopf(405, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Ok");
	beendet = 0;
}

// Destruktor
MenüOptionen::~MenüOptionen()
{
	breiteT->release();
	breite->release();
	höheT->release();
	höhe->release();
	aGrößeT->release();
	aGröße->release();
	timerT->release();
	timer->release();
	shipT->release();
	ship->release();
	autoKam->release();
	fortsetzen->release();
	abbrechen->release();
	ok->release();
}

// nicht constant
void MenüOptionen::reset()
{
	InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
	if (!opd->laden())
		DateiPfadErstellen("data/Minigames/Asteroids/data/optionen.ini");
	breite->setText("1600");
	if (opd->wertExistiert("Breite"))
		breite->setText(Text() += (int)*opd->zWert("Breite"));
	else
		opd->addWert("Breite", "1600");
	höhe->setText("1000");
	if (opd->wertExistiert("Höhe"))
		höhe->setText(Text() += (int)*opd->zWert("Höhe"));
	else
		opd->addWert("Höhe", "1000");
	aGröße->setText("1000");
	if (opd->wertExistiert("Größe"))
		aGröße->setText(Text() += (int)*opd->zWert("Größe"));
	else
		opd->addWert("Größe", "1000");
	timer->setText("5000");
	if (opd->wertExistiert("Timer"))
		timer->setText(Text() += (int)*opd->zWert("Timer"));
	else
		opd->addWert("Timer", "5000");
	ship->setAuswahl(0);
	if (opd->wertExistiert("Ship"))
		ship->setAuswahl((int)*opd->zWert("Ship"));
	else
		opd->addWert("Ship", "0");
	autoKam->removeStyle(KontrollKnopf::Style::Selected);
	if (opd->wertExistiert("AutoKam"))
		autoKam->setStyle(KontrollKnopf::Style::Selected, (int)*opd->zWert("AutoKam") != 0);
	else
		opd->addWert("AutoKam", "0");
	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::doPublicMausEreignis(MausEreignis& me)
{
	breite->doPublicMausEreignis(me);
	höhe->doPublicMausEreignis(me);
	aGröße->doPublicMausEreignis(me);
	timer->doPublicMausEreignis(me);
	ship->doPublicMausEreignis(me);
	autoKam->doPublicMausEreignis(me);
	fortsetzen->doPublicMausEreignis(me);
	bool vera = me.verarbeitet;
	abbrechen->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
		beendet = 1;
	vera = me.verarbeitet;
	ok->doPublicMausEreignis(me);
	if (!vera && me.verarbeitet && me.id == ME_RLinks)
	{
		InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
		if (!opd->laden())
			DateiPfadErstellen("data/Minigames/Asteroids/data/optionen.ini");
		if ((int)*breite->zText() > 10000)
			breite->setText("10000");
		if ((int)*breite->zText() < 800)
			breite->setText("800");
		if (opd->wertExistiert("Breite"))
			opd->setWert("Breite", Text() += (int)*breite->zText());
		else
			opd->addWert("Breite", Text() += (int)*breite->zText());
		if ((int)*höhe->zText() > 10000)
			höhe->setText("10000");
		if ((int)*höhe->zText() < 500)
			höhe->setText("500");
		if (opd->wertExistiert("Höhe"))
			opd->setWert("Höhe", Text() += (int)*höhe->zText());
		else
			opd->addWert("Höhe", Text() += (int)*höhe->zText());
		if ((int)*aGröße->zText() > 10000)
			aGröße->setText("10000");
		if ((int)*aGröße->zText() < 10)
			aGröße->setText("10");
		if (opd->wertExistiert("Größe"))
			opd->setWert("Größe", Text() += (int)*aGröße->zText());
		else
			opd->addWert("Größe", Text() += (int)*aGröße->zText());
		if ((int)*timer->zText() < 500)
			timer->setText("500");
		if (opd->wertExistiert("Timer"))
			opd->setWert("Timer", Text() += (int)*timer->zText());
		else
			opd->addWert("Timer", Text() += (int)*timer->zText());
		if (opd->wertExistiert("Ship"))
			opd->setWert("Ship", Text() += ship->getAuswahl());
		else
			opd->addWert("Ship", Text() += ship->getAuswahl());
		if (opd->wertExistiert("AutoKam"))
			opd->setWert("AutoKam", Text() += (int)autoKam->hatStyle(KontrollKnopf::Style::Selected));
		else
			opd->addWert("AutoKam", Text() += (int)autoKam->hatStyle(KontrollKnopf::Style::Selected));
		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);
	aGröße->doTastaturEreignis(te);
	timer->doTastaturEreignis(te);
}

bool MenüOptionen::tick(double tickVal)
{
	bool ret = breite->tick(tickVal);
	ret |= höhe->tick(tickVal);
	ret |= aGröße->tick(tickVal);
	ret |= timer->tick(tickVal);
	ret |= ship->tick(tickVal);
	ret |= autoKam->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);
	aGrößeT->render(zRObj);
	aGröße->render(zRObj);
	timerT->render(zRObj);
	timer->render(zRObj);
	shipT->render(zRObj);
	autoKam->render(zRObj);
	fortsetzen->render(zRObj);
	abbrechen->render(zRObj);
	ok->render(zRObj);
	ship->render(zRObj);
}

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


// Inhalt der Menü Klasse aus Menü.h
// Konstruktor
Menü::Menü(UIInit& uiFactory, KSGClient::MinigameServerClient* klient)
	: ReferenceCounter()
{
	spielen = initKnopf(350, 180, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Spielen");
	spielenF = new MenüSpiel(uiFactory, dynamic_cast<KSGClient::MinigameServerClient*>(klient->getThis()));
	optionen = initKnopf(350, 220, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Optionen");
	optionenF = new MenüOptionen(uiFactory);
	statistik = initKnopf(350, 260, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Statistik");
	statistikF = new MenüStatistik(uiFactory, klient);
	beenden = initKnopf(350, 300, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden");
	ram = new LRahmen();
	ram->setFarbe(0xFFFFFFFF);
	beendet = 0;
	status = 0;
	LTDBDatei* bgd = new LTDBDatei();
	bgd->setDatei(new Text("data/Minigames/Asteroids/bilder/hintergrund.ltdb"));
	bgd->leseDaten(0);
	hintergrund = bgd->laden(0, new Text("bg.jpg"));
	bgd->release();
}

// 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ü::doPublicMausEreignis(MausEreignis& me)
{
	switch (status)
	{
	case 0:
		if (1)
		{
			bool vera = me.verarbeitet;
			spielen->doPublicMausEreignis(me);
			if (!vera && me.verarbeitet && me.id == ME_RLinks)
			{
				spielenF->reset();
				status = 3;
			}
			vera = me.verarbeitet;
			optionen->doPublicMausEreignis(me);
			if (!vera && me.verarbeitet && me.id == ME_RLinks)
			{
				optionenF->reset();
				status = 1;
			}
			vera = me.verarbeitet;
			statistik->doPublicMausEreignis(me);
			if (!vera && me.verarbeitet && me.id == ME_RLinks)
			{
				statistikF->reset();
				status = 2;
			}
			vera = me.verarbeitet;
			beenden->doPublicMausEreignis(me);
			if (!vera && me.verarbeitet && me.id == ME_RLinks)
				beendet = 1;
		}
		break;
	case 1:
		optionenF->doPublicMausEreignis(me);
		break;
	case 2:
		statistikF->doPublicMausEreignis(me);
		break;
	case 3:
		spielenF->doPublicMausEreignis(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 && (status != 2 || !statistikF->istWiederhohlung()))
		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, 110);
		ram->setSize(200, 320);
		zRObj.alphaRegion(ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000);
		ram->render(zRObj);
		optionenF->render(zRObj);
		break;
	case 2:
		if (!statistikF->istWiederhohlung())
			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;
}