#include "StatistikTabelle.h"
#include "../../Initialisierung/Initialisierung.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

// Inhalt der StatistikTabelle Klasse aus StatistikTabelle.h
// Konstruktor
StatistikTabelle::StatistikTabelle( Array< SSDGesamtSpieler* > *ssdgs, Array< SSDGesamtTeam* > *ssdgt,
									Array< SSDRunde* > *ssdr, Schrift *zSchrift, Bildschirm *zScreen, bool historie )
: schrift( zSchrift->getThis() ),
  ssdgs( ssdgs ),
  ssdgt( ssdgt ),
  ssdr( ssdr ),
  stAuswahl( initAuswahlBox( 10, 10, 120, 20, zSchrift, ABSTYLE, { "Spieler", "Teams" } ) ),
  grAuswahl( initAuswahlBox( 140, 10, 120, 20, zSchrift, ABSTYLE, { "Gesamt" } ) ),
  sortAuswahlGS( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe", "Teamfarbe",
																		"Gewonnene Runden", "Punkte", "Linienlänge", "Zeit am Leben",
																		"Zeit tod", "Kills", "Tode" } ) ),
  sortAuswahlGT( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe", "Gewonnene Runden", "Punkte",
																		"Linienlänge", "Kills", "Tode" } ) ),
  sortAuswahlRS( new RCArray< AuswahlBox >() ),
  sortAuswahlRT( new RCArray< AuswahlBox >() ),
  sortRichtungGS( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
  sortRichtungGT( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
  sortRichtungRS( new RCArray< AuswahlBox >() ),
  sortRichtungRT( new RCArray< AuswahlBox >() ),
  gesamtSpieler( initObjTabelle( 10, 40, 500, 245, zSchrift, 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, zSchrift, 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 ),
  ref( 1 )
{
	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, zSchrift, ABSTYLE, { "Spielername", "Teamname", "Spielerfarbe",
										 "Teamfarbe", "Linienlänge", "Kills", "Todeszeit" } );
		initToolTip( ab, "Spalte nach der sortiert werden soll.", schrift->getThis(), zScreen );
		sortAuswahlRS->add( ab );
		ab = initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe", "Ergebnis",
							 "Linienlänge", "Kills", "Tode" } );
		initToolTip( ab, "Spalte nach der sortiert werden soll.", schrift->getThis(), zScreen );
		sortAuswahlRT->add( ab );
		ab = initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } );
		initToolTip( ab, "Richtung nach der sortiert werden soll.", schrift->getThis(), zScreen );
		sortRichtungRS->add( ab );
		ab = initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } );
		initToolTip( ab, "Richtung nach der sortiert werden soll.", schrift->getThis(), zScreen );
		sortRichtungRT->add( ab );
		rundeSpieler->add( initObjTabelle( 10, 40, 500, 245, zSchrift, 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, zSchrift, 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 );
	schrift->release();
	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 sAnz = zT->getSpaltenAnzahl();
	int zAnz = zT->getZeilenAnzahl();
	for( int i = !überschrift; i < zAnz; i++ )
	{
		for( int j = 0; j < sAnz; j++ )
			( (TextFeld*)zT->zZeichnung( j, !überschrift ) )->release();
		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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->spielerName ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->teamName ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, 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( 0, 0, 0, 0, 0, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->gewonneneRunden ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, 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( 0, 0, 0, 0, schrift, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitTod ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgt->get( i )->teamName ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->gewonneneRunden ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->punkte ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->linienLänge ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->kills ) );
			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrs->get( i )->spielerName ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrs->get( i )->teamName ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, 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( 0, 0, 0, 0, 0, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrs->get( i )->linienLänge ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, 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( 0, 0, 0, 0, schrift, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdrt->get( i )->teamName ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, 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( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ergebnis ? Text( "Gewonnen" ) : Text( "Verloren" ) ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Linienlänge" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->linienLänge ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->kills ) );
				zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdrt->get( i )->tode ) );
			}
			return;
		}
	}
}

// nicht constant
void StatistikTabelle::doMausEreignis( MausEreignis &me )
{
	// Auswahl Boxen
	int ausw = stAuswahl->getAuswahl();
	stAuswahl->doMausEreignis( me );
	if( ausw != stAuswahl->getAuswahl() )
	{
		teamS = stAuswahl->zEintragText( stAuswahl->getAuswahl() )->istGleich( "Teams" );
		stAuswahl->einklappen();
	}
	ausw = grAuswahl->getAuswahl();
	grAuswahl->doMausEreignis( 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->doMausEreignis( me );
			if( ausw != sortAuswahlGT->getAuswahl() )
			{ // Sortierungs Spalte ändert sich
				tabelleLehren( gesamtTeam, 0 );
				tabelleFüllen( gesamtTeam );
				sortAuswahlGT->einklappen();
			}
			ausw = sortRichtungGT->getAuswahl();
			sortRichtungGT->doMausEreignis( me );
			if( ausw != sortRichtungGT->getAuswahl() )
			{ // Sortierungs Richtung ändert sich
				tabelleLehren( gesamtTeam, 0 );
				tabelleFüllen( gesamtTeam );
				sortRichtungGT->einklappen();
			}
			gesamtTeam->doMausEreignis( me );
		}
		else
		{ // Spieler Statistik
			int ausw = sortAuswahlGS->getAuswahl();
			sortAuswahlGS->doMausEreignis( me );
			if( ausw != sortAuswahlGS->getAuswahl() )
			{ // Sortierungs Spalte ändert sich
				tabelleLehren( gesamtSpieler, 0 );
				tabelleFüllen( gesamtSpieler );
				sortAuswahlGS->einklappen();
			}
			ausw = sortRichtungGS->getAuswahl();
			sortRichtungGS->doMausEreignis( me );
			if( ausw != sortRichtungGS->getAuswahl() )
			{ // Sortierungs Richtung ändert sich
				tabelleLehren( gesamtSpieler, 0 );
				tabelleFüllen( gesamtSpieler );
				sortRichtungGS->einklappen();
			}
			gesamtSpieler->doMausEreignis( me );
		}
	}
	else
	{ // Statistik von einer Runde
		if( teamS )
		{ // Team Statistik
			if( sortAuswahlRT->z( rundeAusw ) )
			{
				int ausw = sortAuswahlRT->z( rundeAusw )->getAuswahl();
				sortAuswahlRT->z( rundeAusw )->doMausEreignis( 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 )->doMausEreignis( 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 )->doMausEreignis( me );
		}
		else
		{ // Spieler Statistik
			if( sortAuswahlRS->z( rundeAusw ) )
			{
				int ausw = sortAuswahlRS->z( rundeAusw )->getAuswahl();
				sortAuswahlRS->z( rundeAusw )->doMausEreignis( 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 )->doMausEreignis( 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 )->doMausEreignis( 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;
}

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

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