#include "StatistikTabelle.h"
#include <TextFeld.h>

#define ABSTYLE     AuswahlBox::Style::Sichtbar | AuswahlBox::Style::Erlaubt | AuswahlBox::Style::Rahmen | AuswahlBox::Style::AuswahlBuffer | AuswahlBox::Style::MausBuffer | AuswahlBox::Style::MaxHeight | AuswahlBox::Style::Hintergrund | AuswahlBox::Style::VScroll
#define OTSTYLE     ObjTabelle::Style::Sichtbar | ObjTabelle::Style::Erlaubt | ObjTabelle::Style::Rahmen | ObjTabelle::Style::Raster | ObjTabelle::Style::scroll | ObjTabelle::Style::SpaltenBreiteMax | ObjTabelle::Style::SpaltenBreiteMin | ObjTabelle::Style::SpaltenBreiteChangeable | ObjTabelle::Style::SpaltenBeweglich

struct OBJTabelleSpalteIni
{
	const char* name;
	int breite;
	int minBreite;
	int maxBreite;
};

AuswahlBox* initAuswahlBox(int x, int y, int br, int hö, UIInit& uiFactory, int style, std::initializer_list< const char* > values)
{
	AuswahlBox* ret = uiFactory.createAuswahlBox(uiFactory.initParam);
	ret->addStyle(style);
	ret->setPosition(x, y);
	ret->setSize(br, hö);
	if ((style | AuswahlBox::Style::Hintergrund) == style)
		ret->setHintergrundFarbe(0xFF000000);
	if ((style | AuswahlBox::Style::Erlaubt) == style)
		ret->setMausEreignis(_ret1ME);
	if ((style | AuswahlBox::Style::Rahmen) == style)
	{
		ret->setRahmenBreite(1);
		ret->setRahmenFarbe(0xFFFFFFFF);
	}
	if ((style | AuswahlBox::Style::MaxHeight) == style)
		ret->setMaxAuskappHeight(100);
	if ((style | AuswahlBox::Style::MausRahmen) == style)
	{
		ret->setMausRahmenBreite(1);
		ret->setMausRahmenFarbe(0xFF005500);
	}
	if ((style | AuswahlBox::Style::MausBuffer) == style)
	{
		ret->setMausAlphaFeldFarbe(0x00008700);
		ret->setMausAlphaFeldStrength(-8);
	}
	if ((style | AuswahlBox::Style::AuswahlRahmen) == style)
	{
		ret->setAuswRahmenBreite(1);
		ret->setAuswRahmenFarbe(0xFF00FF00);
	}
	if ((style | AuswahlBox::Style::AuswahlBuffer) == style)
	{
		ret->setAuswAlphaFeldFarbe(0x0000FF00);
		ret->setAuswAlphaFeldStrength(-8);
	}
	for (auto i = values.begin(); i != values.end(); i++)
	{
		ret->addEintrag(*i);
	}
	return ret;
}

ObjTabelle* initObjTabelle(int x, int y, int br, int hö, UIInit& uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe)
{
	ObjTabelle* ret = uiFactory.createObjTabelle(uiFactory.initParam);
	ret->addStyle(style);
	ret->setPosition(x, y);
	ret->setSize(br, hö);
	if ((style | ObjTabelle::Style::Erlaubt) == style)
		ret->setMausEreignis(_ret1ME);
	if ((style | ObjTabelle::Style::Rahmen) == style)
	{
		ret->setRahmenBreite(1);
		ret->setRahmenFarbe(0xFFFFFFFF);
	}
	if ((style | ObjTabelle::Style::Raster) == style)
	{
		ret->setRasterBreite(1);
		ret->setRasterFarbe(0xFFFFFFFF);
	}
	if ((style | ObjTabelle::Style::VScroll) == style)
		ret->setVertikalKlickScroll(5);
	if ((style | ObjTabelle::Style::HScroll) == style)
		ret->setHorizontalKlickScroll(5);
	for (auto i = spalten.begin(); i != spalten.end(); i++)
	{
		ret->addSpalte(i->name);
		ret->setSpaltenBreite(i->name, i->breite);
		if ((style | ObjTabelle::Style::SpaltenBreiteMin) == style)
			ret->setMinSpaltenBreite(i->name, i->minBreite);
		if ((style | ObjTabelle::Style::SpaltenBreiteMax) == style)
			ret->setMaxSpaltenBreite(i->name, i->maxBreite);
		if (überschriftHöhe)
		{
			if (ret->getZeilenNummer("Überschrift") < 0)
			{
				ret->addZeile(0, "Überschrift");
				ret->setZeilenHeight(0, 20);
			}
			TextFeld* tf = uiFactory.createTextFeld(uiFactory.initParam);
			tf->setSize(i->breite, 20);
			tf->setText(i->name);
			ret->setZeichnungZ(i->name, "Überschrift", tf);
		}
	}
	return ret;
}

TextFeld* initTextFeld(UIInit& uiFactory, int style, const char* txt)
{
	TextFeld* ret = uiFactory.createTextFeld(uiFactory.initParam);
	ret->setStyle(style);
	if (txt)
		ret->setText(txt);
	return ret;
}

// Inhalt der StatistikTabelle Klasse aus StatistikTabelle.h
// Konstruktor
StatistikTabelle::StatistikTabelle(Array< SSDGesamtSpieler* >* ssdgs, Array< SSDGesamtTeam* >* ssdgt,
	Array< SSDRunde* >* ssdr, UIInit& uiFactory, bool historie)
	: ReferenceCounter(),
	uiFactory(uiFactory),
	ssdgs(ssdgs),
	ssdgt(ssdgt),
	ssdr(ssdr),
	stAuswahl(initAuswahlBox(10, 10, 120, 20, uiFactory, ABSTYLE, { "Spieler", "Teams" })),
	grAuswahl(initAuswahlBox(140, 10, 120, 20, uiFactory, ABSTYLE, { "Gesamt" })),
	sortAuswahlGS(initAuswahlBox(270, 10, 120, 20, uiFactory, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe", "Teamfarbe",
																		  "Gewonnene Runden", "Punkte", "Linienlänge", "Zeit am Leben",
																		  "Zeit tod", "Kills", "Tode" })),
	sortAuswahlGT(initAuswahlBox(270, 10, 120, 20, uiFactory, ABSTYLE, { "Teamname", "Teamfarbe", "Gewonnene Runden", "Punkte",
																		  "Linienlänge", "Kills", "Tode" })),
	sortAuswahlRS(new RCArray< AuswahlBox >()),
	sortAuswahlRT(new RCArray< AuswahlBox >()),
	sortRichtungGS(initAuswahlBox(400, 10, 120, 20, uiFactory, ABSTYLE, { "Aufwärts", "Abwärts" })),
	sortRichtungGT(initAuswahlBox(400, 10, 120, 20, uiFactory, ABSTYLE, { "Aufwärts", "Abwärts" })),
	sortRichtungRS(new RCArray< AuswahlBox >()),
	sortRichtungRT(new RCArray< AuswahlBox >()),
	gesamtSpieler(initObjTabelle(10, 40, 500, 245, uiFactory, OTSTYLE, { { "Spielername", 120, 20, 200 }, { "Teamname", 120, 20, 120 },
	{ "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 }, { "Gewonnene Runden", 130, 20, 130 }, { "Punkte", 50, 20, 50 },
	{ "Linienlänge", 120, 20, 120 }, { "Zeit Am Leben", 120, 20, 120 }, { "Zeit tod", 60, 20, 60 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20)),
	gesamtTeam(initObjTabelle(10, 40, 500, 245, uiFactory, OTSTYLE, { { "Teamname", 120, 20, 120 }, { "Teamfarbe", 100, 20, 100 },
	{ "Gewonnene Runden", 130, 20, 130 }, { "Punkte", 50, 20, 50 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20)),
	rundeSpieler(new RCArray< ObjTabelle >()),
	rundeTeam(new RCArray< ObjTabelle >()),
	teamS(0),
	rundeAusw(-1),
	rend(0)
{
	tabelleFüllen(gesamtSpieler);
	tabelleFüllen(gesamtTeam);
	int anz = ssdr->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
	{
		if (!ssdr->hat(i))
			continue;
		Text rName("Runde ");
		rName += ssdr->get(i)->rundenNummer + 1;
		grAuswahl->addEintrag(rName);
		AuswahlBox* ab = initAuswahlBox(270, 10, 120, 20, uiFactory, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe",
										 "Teamfarbe", "Linienlänge", "Kills", "Todeszeit" });
		ab->setToolTipText("Spalte nach der sortiert werden soll.", uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
		sortAuswahlRS->add(ab);
		ab = initAuswahlBox(270, 10, 120, 20, uiFactory, ABSTYLE, { "Teamname", "Teamfarbe", "Ergebnis",
							 "Linienlänge", "Kills", "Tode" });
		ab->setToolTipText("Spalte nach der sortiert werden soll.", uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
		sortAuswahlRT->add(ab);
		ab = initAuswahlBox(400, 10, 120, 20, uiFactory, ABSTYLE, { "Aufwärts", "Abwärts" });
		ab->setToolTipText("Richtung nach der sortiert werden soll.", uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
		sortRichtungRS->add(ab);
		ab = initAuswahlBox(400, 10, 120, 20, uiFactory, ABSTYLE, { "Aufwärts", "Abwärts" });
		ab->setToolTipText("Richtung nach der sortiert werden soll.", uiFactory.initParam.bildschirm, uiFactory.initParam.schrift);
		sortRichtungRT->add(ab);
		rundeSpieler->add(initObjTabelle(10, 40, 500, 245, uiFactory, OTSTYLE, { { "Spielername", 120, 20, 200 }, { "Teamname", 120, 20, 120 },
		{ "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Todeszeit", 80, 20, 80 } }, 20));
		rundeTeam->add(initObjTabelle(10, 40, 500, 245, uiFactory, OTSTYLE, { { "Teamname", 120, 20, 120 }, { "Teamfarbe", 100, 20, 100 },
		{ "Ergebnis", 80, 20, 80 }, { "Linienlänge", 120, 20, 120 }, { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20));
		tabelleFüllen(rundeSpieler->z(i));
		tabelleFüllen(rundeTeam->z(i));
	}
	if (historie)
	{
		sortRichtungGS->setSize(110, 20);
		sortRichtungGT->setSize(110, 20);
		gesamtSpieler->setSize(500, 380);
		gesamtTeam->setSize(500, 380);
		for (int i = 0; i < anz; i++)
		{
			rundeSpieler->z(i)->setSize(500, 380);
			rundeTeam->z(i)->setSize(500, 380);
			sortRichtungRS->z(i)->setSize(110, 20);
			sortRichtungRT->z(i)->setSize(110, 20);
		}
	}
}

// Destruktor
StatistikTabelle::~StatistikTabelle()
{
	tabelleLehren(gesamtSpieler, 1);
	tabelleLehren(gesamtTeam, 1);
	int anz = rundeSpieler->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
		tabelleLehren(rundeSpieler->z(i), 1);
	anz = rundeTeam->getEintragAnzahl();
	for (int i = 0; i < anz; i++)
		tabelleLehren(rundeTeam->z(i), 1);
	ssdgs->release();
	ssdgt->release();
	ssdr->release();
	stAuswahl->release();
	grAuswahl->release();
	sortAuswahlGS->release();
	sortAuswahlGT->release();
	sortAuswahlRS->release();
	sortAuswahlRT->release();
	sortRichtungGS->release();
	sortRichtungGT->release();
	sortRichtungRS->release();
	sortRichtungRT->release();
	gesamtSpieler->release();
	gesamtTeam->release();
	rundeSpieler->release();
	rundeTeam->release();
}

// privat
void StatistikTabelle::tabelleLehren(ObjTabelle* zT, bool überschrift)
{
	int zAnz = zT->getZeilenAnzahl();
	for (int i = !überschrift; i < zAnz; i++)
		zT->removeZeile(!überschrift);
}

void StatistikTabelle::tabelleFüllen(ObjTabelle* zT)
{
	if (zT == gesamtSpieler)
	{
		if (!sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl()))
			return;
		if (!sortRichtungGS->zEintragText(sortRichtungGS->getAuswahl()))
			return;
		Array< int > reihenfolge;
		bool aufsteigend = sortRichtungGS->zEintragText(sortRichtungGS->getAuswahl())->istGleich("Aufwärts");
		int anz = ssdgs->getEintragAnzahl();
		bool* fertig = new bool[anz];
		ZeroMemory(fertig, anz);
		bool spielername = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Spielername");
		bool teamname = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Teamname");
		bool spielerfarbe = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Spielerfarbe");
		bool teamfarbe = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Teamfarbe");
		bool gewonnenerunden = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Gewonnene Runden");
		bool punkte = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Punkte");
		bool linienlänge = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Linienlänge");
		bool zeitamleben = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Zeit am Leben");
		bool zeittod = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Zeit tod");
		bool kills = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Kills");
		bool tode = sortAuswahlGS->zEintragText(sortAuswahlGS->getAuswahl())->istGleich("Tode");
		for (int i = 0; i < anz; i++)
		{
			Text minMaxT;
			int minMax;
			int pos = -1;
			for (int j = 0; j < anz; j++)
			{
				if (!ssdgs->hat(j) || fertig[j])
					continue;
				if (spielername && (pos < 0 || (aufsteigend && ssdgs->get(j)->spielerName < minMaxT) || (!aufsteigend && ssdgs->get(j)->spielerName > minMaxT)))
				{ // Sortiert nach Spieler Name
					minMaxT = ssdgs->get(j)->spielerName.getText();
					pos = j;
				}
				if (teamname && (pos < 0 || (aufsteigend && ssdgs->get(j)->teamName < minMaxT) || (!aufsteigend && ssdgs->get(j)->teamName > minMaxT)))
				{ // Sortiert nach Team Name
					minMaxT = ssdgs->get(j)->teamName.getText();
					pos = j;
				}
				if (spielerfarbe && (pos < 0 || (aufsteigend && ssdgs->get(j)->spielerFarbe < minMax) || (!aufsteigend && ssdgs->get(j)->spielerFarbe > minMax)))
				{ // Sortiert nach Spieler Farbe
					minMax = ssdgs->get(j)->spielerFarbe;
					pos = j;
				}
				if (teamfarbe && (pos < 0 || (aufsteigend && ssdgs->get(j)->teamFarbe < minMax) || (!aufsteigend && ssdgs->get(j)->teamFarbe > minMax)))
				{ // Sortiert nach Team Farbe
					minMax = ssdgs->get(j)->teamFarbe;
					pos = j;
				}
				if (gewonnenerunden && (pos < 0 || (aufsteigend && ssdgs->get(j)->gewonneneRunden < minMax) || (!aufsteigend && ssdgs->get(j)->gewonneneRunden > minMax)))
				{ // Sortiert nach Gewonnenen Runden
					minMax = ssdgs->get(j)->gewonneneRunden;
					pos = j;
				}
				if (punkte && (pos < 0 || (aufsteigend && ssdgs->get(j)->punkte < minMax) || (!aufsteigend && ssdgs->get(j)->punkte > minMax)))
				{ // Sortiert nach Punkten
					minMax = ssdgs->get(j)->punkte;
					pos = j;
				}
				if (linienlänge && (pos < 0 || (aufsteigend && ssdgs->get(j)->linienLänge < minMax) || (!aufsteigend && ssdgs->get(j)->linienLänge > minMax)))
				{ // Sortiert nach Linienlängen
					minMax = ssdgs->get(j)->linienLänge;
					pos = j;
				}
				if (zeitamleben && (pos < 0 || (aufsteigend && ssdgs->get(j)->zeitAmLeben < minMax) || (!aufsteigend && ssdgs->get(j)->zeitAmLeben > minMax)))
				{ // Sortiert nach Zeit Am Leben
					minMax = ssdgs->get(j)->zeitAmLeben;
					pos = j;
				}
				if (zeittod && (pos < 0 || (aufsteigend && ssdgs->get(j)->zeitTod < minMax) || (!aufsteigend && ssdgs->get(j)->zeitTod > minMax)))
				{ // Sortiert nach Zeit Tod
					minMax = ssdgs->get(j)->zeitTod;
					pos = j;
				}
				if (kills && (pos < 0 || (aufsteigend && ssdgs->get(j)->kills < minMax) || (!aufsteigend && ssdgs->get(j)->kills > minMax)))
				{ // Sortiert nach Kills
					minMax = ssdgs->get(j)->kills;
					pos = j;
				}
				if (tode && (pos < 0 || (aufsteigend && ssdgs->get(j)->tode < minMax) || (!aufsteigend && ssdgs->get(j)->tode > minMax)))
				{ // Sortiert nach Toden
					minMax = ssdgs->get(j)->tode;
					pos = j;
				}
			}
			if (pos >= 0)
			{
				reihenfolge.add(pos);
				fertig[pos] = 1;
			}
			else
				break;
		}
		delete[] fertig;
		anz = reihenfolge.getEintragAnzahl();
		for (int j = 0; j < anz; j++)
		{
			int i = reihenfolge.get(j);
			zT->addZeile(Text("Spieler ") += ssdgs->get(i)->spielerNummer);
			int zNum = zT->getZeilenNummer(Text("Spieler ") += ssdgs->get(i)->spielerNummer);
			zT->setZeichnungZ(zT->getSpaltenNummer("Spielername"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ssdgs->get(i)->spielerName));
			zT->setZeichnungZ(zT->getSpaltenNummer("Teamname"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ssdgs->get(i)->teamName));
			zT->setZeichnungZ(zT->getSpaltenNummer("Spielerfarbe"), zNum, initTextFeld(uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0));
			((TextFeld*)zT->zZeichnung(zT->getSpaltenNummer("Spielerfarbe"), zNum))->setHintergrundFarbe(ssdgs->get(i)->spielerFarbe);
			zT->setZeichnungZ(zT->getSpaltenNummer("Teamfarbe"), zNum, initTextFeld(uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0));
			((TextFeld*)zT->zZeichnung(zT->getSpaltenNummer("Teamfarbe"), zNum))->setHintergrundFarbe(ssdgs->get(i)->teamFarbe);
			zT->setZeichnungZ(zT->getSpaltenNummer("Gewonnene Runden"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgs->get(i)->gewonneneRunden));
			zT->setZeichnungZ(zT->getSpaltenNummer("Punkte"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgs->get(i)->punkte));
			zT->setZeichnungZ(zT->getSpaltenNummer("Linienlänge"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgs->get(i)->linienLänge));
			Text zeitAmLeben;
			zeitAmLeben += ssdgs->get(i)->zeitAmLeben / 60;
			zeitAmLeben += ":";
			zeitAmLeben += ssdgs->get(i)->zeitAmLeben % 60;
			zT->setZeichnungZ(zT->getSpaltenNummer("Zeit Am Leben"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, zeitAmLeben));
			Text zeitTod;
			zeitTod += ssdgs->get(i)->zeitTod / 60;
			zeitTod += ":";
			zeitTod += ssdgs->get(i)->zeitTod % 60;
			zT->setZeichnungZ(zT->getSpaltenNummer("Zeit tod"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, zeitTod));
			zT->setZeichnungZ(zT->getSpaltenNummer("Kills"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgs->get(i)->kills));
			zT->setZeichnungZ(zT->getSpaltenNummer("Tode"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgs->get(i)->tode));
		}
		return;
	}
	if (zT == gesamtTeam)
	{
		if (!sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl()))
			return;
		if (!sortRichtungGS->zEintragText(sortRichtungGS->getAuswahl()))
			return;
		Array< int > reihenfolge;
		bool aufsteigend = sortRichtungGT->zEintragText(sortRichtungGT->getAuswahl())->istGleich("Aufwärts");
		int anz = ssdgt->getEintragAnzahl();
		bool* fertig = new bool[anz];
		ZeroMemory(fertig, anz);
		bool teamname = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Teamname");
		bool teamfarbe = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Teamfarbe");
		bool gewonnenerunden = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Gewonnene Runden");
		bool punkte = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Punkte");
		bool linienlänge = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Linienlänge");
		bool kills = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Kills");
		bool tode = sortAuswahlGT->zEintragText(sortAuswahlGT->getAuswahl())->istGleich("Tode");
		for (int i = 0; i < anz; i++)
		{
			Text minMaxT;
			int minMax;
			int pos = -1;
			for (int j = 0; j < anz; j++)
			{
				if (!ssdgt->hat(j) || fertig[j])
					continue;
				if (teamname && (pos < 0 || (aufsteigend && ssdgt->get(j)->teamName < minMaxT) || (!aufsteigend && ssdgt->get(j)->teamName > minMaxT)))
				{ // Sortiert nach Team Name
					minMaxT = ssdgt->get(j)->teamName.getText();
					pos = j;
				}
				if (teamfarbe && (pos < 0 || (aufsteigend && ssdgt->get(j)->teamFarbe < minMax) || (!aufsteigend && ssdgt->get(j)->teamFarbe > minMax)))
				{ // Sortiert nach Team Farbe
					minMax = ssdgt->get(j)->teamFarbe;
					pos = j;
				}
				if (gewonnenerunden && (pos < 0 || (aufsteigend && ssdgt->get(j)->gewonneneRunden < minMax) || (!aufsteigend && ssdgt->get(j)->gewonneneRunden > minMax)))
				{ // Sortiert nach Gewonnenen Runden
					minMax = ssdgt->get(j)->gewonneneRunden;
					pos = j;
				}
				if (punkte && (pos < 0 || (aufsteigend && ssdgt->get(j)->punkte < minMax) || (!aufsteigend && ssdgt->get(j)->punkte > minMax)))
				{ // Sortiert nach Punkten
					minMax = ssdgt->get(j)->punkte;
					pos = j;
				}
				if (linienlänge && (pos < 0 || (aufsteigend && ssdgt->get(j)->linienLänge < minMax) || (!aufsteigend && ssdgt->get(j)->linienLänge > minMax)))
				{ // Sortiert nach Linienlängen
					minMax = ssdgt->get(j)->linienLänge;
					pos = j;
				}
				if (kills && (pos < 0 || (aufsteigend && ssdgt->get(j)->kills < minMax) || (!aufsteigend && ssdgt->get(j)->kills > minMax)))
				{ // Sortiert nach Kills
					minMax = ssdgt->get(j)->kills;
					pos = j;
				}
				if (tode && (pos < 0 || (aufsteigend && ssdgt->get(j)->tode < minMax) || (!aufsteigend && ssdgt->get(j)->tode > minMax)))
				{ // Sortiert nach Toden
					minMax = ssdgt->get(j)->tode;
					pos = j;
				}
			}
			if (pos >= 0)
			{
				reihenfolge.add(pos);
				fertig[pos] = 1;
			}
			else
				break;
		}
		delete[] fertig;
		anz = reihenfolge.getEintragAnzahl();
		for (int j = 0; j < anz; j++)
		{
			int i = reihenfolge.get(j);
			zT->addZeile(Text("Team ") += ssdgt->get(i)->teamNummer);
			int zNum = zT->getZeilenNummer(Text("Team ") += ssdgt->get(i)->teamNummer);
			zT->setZeichnungZ(zT->getSpaltenNummer("Teamname"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ssdgt->get(i)->teamName));
			zT->setZeichnungZ(zT->getSpaltenNummer("Teamfarbe"), zNum, initTextFeld(uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0));
			((TextFeld*)zT->zZeichnung(zT->getSpaltenNummer("Teamfarbe"), zNum))->setHintergrundFarbe(ssdgt->get(i)->teamFarbe);
			zT->setZeichnungZ(zT->getSpaltenNummer("Gewonnene Runden"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgt->get(i)->gewonneneRunden));
			zT->setZeichnungZ(zT->getSpaltenNummer("Punkte"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgt->get(i)->punkte));
			zT->setZeichnungZ(zT->getSpaltenNummer("Linienlänge"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgt->get(i)->linienLänge));
			zT->setZeichnungZ(zT->getSpaltenNummer("Kills"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgt->get(i)->kills));
			zT->setZeichnungZ(zT->getSpaltenNummer("Tode"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdgt->get(i)->tode));
		}
		return;
	}
	int anz = rundeSpieler->getEintragAnzahl();
	for (int h = 0; h < anz; h++)
	{
		if (zT == rundeSpieler->z(h))
		{
			if (!ssdr->hat(h))
				return;
			Array< SSDRundeSpieler* >* ssdrs = &ssdr->get(h)->spieler;
			AuswahlBox* sortAuswahl = sortAuswahlRS->z(h);
			AuswahlBox* sortRichtung = sortRichtungRS->z(h);
			if (!sortAuswahl || !sortAuswahl->zEintragText(sortAuswahl->getAuswahl()))
				return;
			if (!sortRichtung || !sortRichtung->zEintragText(sortRichtung->getAuswahl()))
				return;
			Array< int > reihenfolge;
			bool aufsteigend = sortRichtung->zEintragText(sortRichtung->getAuswahl())->istGleich("Aufwärts");
			int anz = ssdrs->getEintragAnzahl();
			bool* fertig = new bool[anz];
			ZeroMemory(fertig, anz);
			bool spielername = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Spielername");
			bool teamname = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Teamname");
			bool spielerfarbe = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Spielerfarbe");
			bool teamfarbe = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Teamfarbe");
			bool linienlänge = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Linienlänge");
			bool kills = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Kills");
			bool todeszeit = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Todeszeit");
			for (int i = 0; i < anz; i++)
			{
				Text minMaxT;
				int minMax;
				int pos = -1;
				for (int j = 0; j < anz; j++)
				{
					if (!ssdrs->hat(j) || fertig[j])
						continue;
					if (spielername && (pos < 0 || (aufsteigend && ssdrs->get(j)->spielerName < minMaxT) || (!aufsteigend && ssdrs->get(j)->spielerName > minMaxT)))
					{ // Sortiert nach Spieler Name
						minMaxT = ssdrs->get(j)->spielerName.getText();
						pos = j;
					}
					if (teamname && (pos < 0 || (aufsteigend && ssdrs->get(j)->teamName < minMaxT) || (!aufsteigend && ssdrs->get(j)->teamName > minMaxT)))
					{ // Sortiert nach Team Name
						minMaxT = ssdrs->get(j)->teamName.getText();
						pos = j;
					}
					if (spielerfarbe && (pos < 0 || (aufsteigend && ssdrs->get(j)->spielerFarbe < minMax) || (!aufsteigend && ssdrs->get(j)->spielerFarbe > minMax)))
					{ // Sortiert nach Spieler Farbe
						minMax = ssdrs->get(j)->spielerFarbe;
						pos = j;
					}
					if (teamfarbe && (pos < 0 || (aufsteigend && ssdrs->get(j)->teamFarbe < minMax) || (!aufsteigend && ssdrs->get(j)->teamFarbe > minMax)))
					{ // Sortiert nach Team Farbe
						minMax = ssdrs->get(j)->teamFarbe;
						pos = j;
					}
					if (linienlänge && (pos < 0 || (aufsteigend && ssdrs->get(j)->linienLänge < minMax) || (!aufsteigend && ssdrs->get(j)->linienLänge > minMax)))
					{ // Sortiert nach Linienlängen
						minMax = ssdrs->get(j)->linienLänge;
						pos = j;
					}
					if (kills && (pos < 0 || (aufsteigend && ssdrs->get(j)->kills < minMax) || (!aufsteigend && ssdrs->get(j)->kills > minMax)))
					{ // Sortiert nach Kills
						minMax = ssdrs->get(j)->kills;
						pos = j;
					}
					if (todeszeit && (pos < 0 || (aufsteigend && ssdrs->get(j)->todesZeit < minMax) || (!aufsteigend && ssdrs->get(j)->todesZeit > minMax)))
					{ // Sortiert nach Todeszeitpunkten
						minMax = ssdrs->get(j)->todesZeit;
						pos = j;
					}
				}
				if (pos >= 0)
				{
					reihenfolge.add(pos);
					fertig[pos] = 1;
				}
				else
					break;
			}
			delete[] fertig;
			anz = reihenfolge.getEintragAnzahl();
			for (int j = 0; j < anz; j++)
			{
				int i = reihenfolge.get(j);
				zT->addZeile(Text("Spieler ") += ssdrs->get(i)->spielerNummer);
				int zNum = zT->getZeilenNummer(Text("Spieler ") += ssdrs->get(i)->spielerNummer);
				zT->setZeichnungZ(zT->getSpaltenNummer("Spielername"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ssdrs->get(i)->spielerName));
				zT->setZeichnungZ(zT->getSpaltenNummer("Teamname"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ssdrs->get(i)->teamName));
				zT->setZeichnungZ(zT->getSpaltenNummer("Spielerfarbe"), zNum, initTextFeld(uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0));
				((TextFeld*)zT->zZeichnung(zT->getSpaltenNummer("Spielerfarbe"), zNum))->setHintergrundFarbe(ssdrs->get(i)->spielerFarbe);
				zT->setZeichnungZ(zT->getSpaltenNummer("Teamfarbe"), zNum, initTextFeld(uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0));
				((TextFeld*)zT->zZeichnung(zT->getSpaltenNummer("Teamfarbe"), zNum))->setHintergrundFarbe(ssdrs->get(i)->teamFarbe);
				zT->setZeichnungZ(zT->getSpaltenNummer("Linienlänge"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdrs->get(i)->linienLänge));
				zT->setZeichnungZ(zT->getSpaltenNummer("Kills"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdrs->get(i)->kills));
				Text todesZeit;
				todesZeit += ssdrs->get(i)->todesZeit / 60;
				todesZeit += ":";
				todesZeit += ssdrs->get(i)->todesZeit % 60;
				zT->setZeichnungZ(zT->getSpaltenNummer("Todeszeit"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, todesZeit));
			}
			return;
		}
	}
	anz = rundeTeam->getEintragAnzahl();
	for (int h = 0; h < anz; h++)
	{
		if (zT == rundeTeam->z(h))
		{
			if (!ssdr->hat(h))
				return;
			Array< SSDRundeTeam* >* ssdrt = &ssdr->get(h)->teams;
			AuswahlBox* sortAuswahl = sortAuswahlRT->z(h);
			AuswahlBox* sortRichtung = sortRichtungRT->z(h);
			if (!sortAuswahl || !sortAuswahl->zEintragText(sortAuswahl->getAuswahl()))
				return;
			if (!sortRichtung || !sortRichtung->zEintragText(sortRichtung->getAuswahl()))
				return;
			Array< int > reihenfolge;
			bool aufsteigend = sortRichtung->zEintragText(sortRichtung->getAuswahl())->istGleich("Aufwärts");
			int anz = ssdrt->getEintragAnzahl();
			bool* fertig = new bool[anz];
			ZeroMemory(fertig, anz);
			bool teamname = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Teamname");
			bool teamfarbe = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Teamfarbe");
			bool ergebnis = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Ergebnis");
			bool linienlänge = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Linienlänge");
			bool kills = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Kills");
			bool tode = sortAuswahl->zEintragText(sortAuswahl->getAuswahl())->istGleich("Tode");
			for (int i = 0; i < anz; i++)
			{
				Text minMaxT;
				int minMax;
				int pos = -1;
				for (int j = 0; j < anz; j++)
				{
					if (!ssdrt->hat(j) || fertig[j])
						continue;
					if (teamname && (pos < 0 || (aufsteigend && ssdrt->get(j)->teamName < minMaxT) || (!aufsteigend && ssdrt->get(j)->teamName > minMaxT)))
					{ // Sortiert nach Team Name
						minMaxT = ssdrt->get(j)->teamName.getText();
						pos = j;
					}
					if (teamfarbe && (pos < 0 || (aufsteigend && ssdrt->get(j)->teamFarbe < minMax) || (!aufsteigend && ssdrt->get(j)->teamFarbe > minMax)))
					{ // Sortiert nach Team Farbe
						minMax = ssdrt->get(j)->teamFarbe;
						pos = j;
					}
					if (ergebnis && (pos < 0 || (aufsteigend && ssdrt->get(j)->ergebnis < minMax) || (!aufsteigend && ssdrt->get(j)->ergebnis > minMax)))
					{ // Sortiert nach Ergebnis
						minMax = ssdrt->get(j)->ergebnis;
						pos = j;
					}
					if (linienlänge && (pos < 0 || (aufsteigend && ssdrt->get(j)->linienLänge < minMax) || (!aufsteigend && ssdrt->get(j)->linienLänge > minMax)))
					{ // Sortiert nach Linienlängen
						minMax = ssdrt->get(j)->linienLänge;
						pos = j;
					}
					if (kills && (pos < 0 || (aufsteigend && ssdrt->get(j)->kills < minMax) || (!aufsteigend && ssdrt->get(j)->kills > minMax)))
					{ // Sortiert nach Kills
						minMax = ssdrt->get(j)->kills;
						pos = j;
					}
					if (tode && (pos < 0 || (aufsteigend && ssdrt->get(j)->tode < minMax) || (!aufsteigend && ssdrt->get(j)->tode > minMax)))
					{ // Sortiert nach Todeszeitpunkten
						minMax = ssdrt->get(j)->tode;
						pos = j;
					}
				}
				if (pos >= 0)
				{
					reihenfolge.add(pos);
					fertig[pos] = 1;
				}
				else
					break;
			}
			delete[] fertig;
			anz = reihenfolge.getEintragAnzahl();
			for (int j = 0; j < anz; j++)
			{
				int i = reihenfolge.get(j);
				zT->addZeile(Text("Team ") += ssdrt->get(i)->teamNummer);
				int zNum = zT->getZeilenNummer(Text("Team ") += ssdrt->get(i)->teamNummer);
				zT->setZeichnungZ(zT->getSpaltenNummer("Teamname"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ssdrt->get(i)->teamName));
				zT->setZeichnungZ(zT->getSpaltenNummer("Teamfarbe"), zNum, initTextFeld(uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0));
				((TextFeld*)zT->zZeichnung(zT->getSpaltenNummer("Teamfarbe"), zNum))->setHintergrundFarbe(ssdrt->get(i)->teamFarbe);
				zT->setZeichnungZ(zT->getSpaltenNummer("Ergebnis"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, ergebnis ? Text("Gewonnen") : Text("Verloren")));
				zT->setZeichnungZ(zT->getSpaltenNummer("Linienlänge"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdrt->get(i)->linienLänge));
				zT->setZeichnungZ(zT->getSpaltenNummer("Kills"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdrt->get(i)->kills));
				zT->setZeichnungZ(zT->getSpaltenNummer("Tode"), zNum, initTextFeld(uiFactory, TextFeld::Style::Text, Text() += ssdrt->get(i)->tode));
			}
			return;
		}
	}
}

// nicht constant
void StatistikTabelle::doPublicMausEreignis(MausEreignis& me)
{
	// Auswahl Boxen
	int ausw = stAuswahl->getAuswahl();
	stAuswahl->doPublicMausEreignis(me);
	if (ausw != stAuswahl->getAuswahl())
	{
		teamS = stAuswahl->zEintragText(stAuswahl->getAuswahl())->istGleich("Teams");
		stAuswahl->einklappen();
	}
	ausw = grAuswahl->getAuswahl();
	grAuswahl->doPublicMausEreignis(me);
	if (ausw != grAuswahl->getAuswahl())
	{
		if (grAuswahl->zEintragText(grAuswahl->getAuswahl())->istGleich("Gesamt"))
			rundeAusw = -1;
		Text* nummer = grAuswahl->zEintragText(grAuswahl->getAuswahl())->getTeilText(6);
		rundeAusw = (int)(*nummer) - 1;
		nummer->release();
		grAuswahl->einklappen();
	}
	if (rundeAusw == -1)
	{ // Statistik vom gesamtem Spiel
		if (teamS)
		{ // Team Statistik
			int ausw = sortAuswahlGT->getAuswahl();
			sortAuswahlGT->doPublicMausEreignis(me);
			if (ausw != sortAuswahlGT->getAuswahl())
			{ // Sortierungs Spalte ändert sich
				tabelleLehren(gesamtTeam, 0);
				tabelleFüllen(gesamtTeam);
				sortAuswahlGT->einklappen();
			}
			ausw = sortRichtungGT->getAuswahl();
			sortRichtungGT->doPublicMausEreignis(me);
			if (ausw != sortRichtungGT->getAuswahl())
			{ // Sortierungs Richtung ändert sich
				tabelleLehren(gesamtTeam, 0);
				tabelleFüllen(gesamtTeam);
				sortRichtungGT->einklappen();
			}
			gesamtTeam->doPublicMausEreignis(me);
		}
		else
		{ // Spieler Statistik
			int ausw = sortAuswahlGS->getAuswahl();
			sortAuswahlGS->doPublicMausEreignis(me);
			if (ausw != sortAuswahlGS->getAuswahl())
			{ // Sortierungs Spalte ändert sich
				tabelleLehren(gesamtSpieler, 0);
				tabelleFüllen(gesamtSpieler);
				sortAuswahlGS->einklappen();
			}
			ausw = sortRichtungGS->getAuswahl();
			sortRichtungGS->doPublicMausEreignis(me);
			if (ausw != sortRichtungGS->getAuswahl())
			{ // Sortierungs Richtung ändert sich
				tabelleLehren(gesamtSpieler, 0);
				tabelleFüllen(gesamtSpieler);
				sortRichtungGS->einklappen();
			}
			gesamtSpieler->doPublicMausEreignis(me);
		}
	}
	else
	{ // Statistik von einer Runde
		if (teamS)
		{ // Team Statistik
			if (sortAuswahlRT->z(rundeAusw))
			{
				int ausw = sortAuswahlRT->z(rundeAusw)->getAuswahl();
				sortAuswahlRT->z(rundeAusw)->doPublicMausEreignis(me);
				if (ausw != sortAuswahlRT->z(rundeAusw)->getAuswahl() && rundeTeam->z(rundeAusw))
				{ // Sortierungs Spalte ändert sich
					tabelleLehren(rundeTeam->z(rundeAusw), 0);
					tabelleFüllen(rundeTeam->z(rundeAusw));
					sortAuswahlRT->z(rundeAusw)->einklappen();
				}
			}
			if (sortRichtungRT->z(rundeAusw))
			{
				int ausw = sortRichtungRT->z(rundeAusw)->getAuswahl();
				sortRichtungRT->z(rundeAusw)->doPublicMausEreignis(me);
				if (ausw != sortRichtungRT->z(rundeAusw)->getAuswahl() && rundeTeam->z(rundeAusw))
				{ // Sortierungs Richtung ändert sich
					tabelleLehren(rundeTeam->z(rundeAusw), 0);
					tabelleFüllen(rundeTeam->z(rundeAusw));
					sortRichtungRT->z(rundeAusw)->einklappen();
				}
			}
			if (rundeTeam->z(rundeAusw))
				rundeTeam->z(rundeAusw)->doPublicMausEreignis(me);
		}
		else
		{ // Spieler Statistik
			if (sortAuswahlRS->z(rundeAusw))
			{
				int ausw = sortAuswahlRS->z(rundeAusw)->getAuswahl();
				sortAuswahlRS->z(rundeAusw)->doPublicMausEreignis(me);
				if (ausw != sortAuswahlRS->z(rundeAusw)->getAuswahl() && rundeSpieler->z(rundeAusw))
				{ // Sortierungs Spalte ändert sich
					tabelleLehren(rundeSpieler->z(rundeAusw), 0);
					tabelleFüllen(rundeSpieler->z(rundeAusw));
					sortAuswahlRS->z(rundeAusw)->einklappen();
				}
			}
			if (sortRichtungRS->z(rundeAusw))
			{
				int ausw = sortRichtungRS->z(rundeAusw)->getAuswahl();
				sortRichtungRS->z(rundeAusw)->doPublicMausEreignis(me);
				if (ausw != sortRichtungRS->z(rundeAusw)->getAuswahl() && rundeSpieler->z(rundeAusw))
				{ // Sortierungs Richtung ändert sich
					tabelleLehren(rundeSpieler->z(rundeAusw), 0);
					tabelleFüllen(rundeSpieler->z(rundeAusw));
					sortRichtungRS->z(rundeAusw)->einklappen();
				}
			}
			if (rundeSpieler->z(rundeAusw))
				rundeSpieler->z(rundeAusw)->doPublicMausEreignis(me);
		}
	}
}

bool StatistikTabelle::tick(double tickVal)
{
	if (rundeAusw == -1)
	{ // Statistik vom gesamtem Spiel
		if (teamS)
		{ // Team Statistik
			rend |= gesamtTeam->tick(tickVal);
			rend |= sortAuswahlGT->tick(tickVal);
			rend |= sortRichtungGT->tick(tickVal);
		}
		else
		{ // Spieler Statistik
			rend |= gesamtSpieler->tick(tickVal);
			rend |= sortAuswahlGS->tick(tickVal);
			rend |= sortRichtungGS->tick(tickVal);
		}
	}
	else
	{ // Statistik von einer Runde
		if (teamS)
		{ // Team Statistik
			if (rundeTeam->z(rundeAusw))
				rend |= rundeTeam->z(rundeAusw)->tick(tickVal);
			if (sortAuswahlRT->z(rundeAusw))
				rend |= sortAuswahlRT->z(rundeAusw)->tick(tickVal);
			if (sortRichtungRT->z(rundeAusw))
				rend |= sortRichtungRT->z(rundeAusw)->tick(tickVal);
		}
		else
		{ // Spieler Statistik
			if (rundeSpieler->z(rundeAusw))
				rend |= rundeSpieler->z(rundeAusw)->tick(tickVal);
			if (sortAuswahlRS->z(rundeAusw))
				rend |= sortAuswahlRS->z(rundeAusw)->tick(tickVal);
			if (sortRichtungRS->z(rundeAusw))
				rend |= sortRichtungRS->z(rundeAusw)->tick(tickVal);
		}
	}
	// Auswahl Boxen
	rend |= stAuswahl->tick(tickVal);
	rend |= grAuswahl->tick(tickVal);
	bool ret = rend;
	rend = 0;
	return ret;
}

void StatistikTabelle::render(Bild& zRObj)
{
	if (rundeAusw == -1)
	{ // Statistik vom gesamtem Spiel
		if (teamS)
		{ // Team Statistik
			gesamtTeam->render(zRObj);
			sortAuswahlGT->render(zRObj);
			sortRichtungGT->render(zRObj);
		}
		else
		{ // Spieler Statistik
			gesamtSpieler->render(zRObj);
			sortAuswahlGS->render(zRObj);
			sortRichtungGS->render(zRObj);
		}
	}
	else
	{ // Statistik von einer Runde
		if (teamS)
		{ // Team Statistik
			if (rundeTeam->z(rundeAusw))
				rundeTeam->z(rundeAusw)->render(zRObj);
			if (sortAuswahlRT->z(rundeAusw))
				sortAuswahlRT->z(rundeAusw)->render(zRObj);
			if (sortRichtungRT->z(rundeAusw))
				sortRichtungRT->z(rundeAusw)->render(zRObj);
		}
		else
		{ // Spieler Statistik
			if (rundeSpieler->z(rundeAusw))
				rundeSpieler->z(rundeAusw)->render(zRObj);
			if (sortAuswahlRS->z(rundeAusw))
				sortAuswahlRS->z(rundeAusw)->render(zRObj);
			if (sortRichtungRS->z(rundeAusw))
				sortRichtungRS->z(rundeAusw)->render(zRObj);
		}
	}
	// Auswahl Boxen
	stAuswahl->render(zRObj);
	grAuswahl->render(zRObj);
}

// constant
int StatistikTabelle::getRunde() const
{
	return rundeAusw;
}