framework changes

Linie/Aufzeichnung/Chat/VideoChat.cpp

@@ -9,77 +9,77 @@
 
 // Inhalt der VideoChat Klasse aus VideoChat.h
 // Konstruktor
-VideoChat::VideoChat( UIInit &uiFactory )
-    : ReferenceCounter()
+VideoChat::VideoChat(UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    verlauf = uiFactory.createTextFeld( uiFactory.initParam );
-    verlauf->setStyle( TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt );
-    verlauf->setRahmenFarbe( 0xFF909090 );
-    verlauf->setText( "" );
-    verlauf->setPosition( 20, BildschirmGröße().y - 210 );
-    verlauf->setSize( 450, 200 );
+	verlauf = uiFactory.createTextFeld(uiFactory.initParam);
+	verlauf->setStyle(TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt);
+	verlauf->setRahmenFarbe(0xFF909090);
+	verlauf->setText("");
+	verlauf->setPosition(20, BildschirmGröße().y - 210);
+	verlauf->setSize(450, 200);
 }
 
 // Destruktor
 VideoChat::~VideoChat()
 {
-    verlauf->release();
+	verlauf->release();
 }
 
 // nicht constant
-void VideoChat::addNachricht( char *nachricht )
+void VideoChat::addNachricht(const char* nachricht)
 {
-    verlauf->addZeile( nachricht, 0xFFFFFFFF );
-    verlauf->updateVScroll();
+	verlauf->addZeile(nachricht, 0xFFFFFFFF);
+	verlauf->updateVScroll();
 }
 
-void VideoChat::addNachricht( char *nachricht, int farbe )
+void VideoChat::addNachricht(const  char* nachricht, int farbe)
 {
-    verlauf->addZeile( nachricht, farbe );
-    verlauf->updateVScroll();
+	verlauf->addZeile(nachricht, farbe);
+	verlauf->updateVScroll();
 }
 
-void VideoChat::removeNachricht( char *nachricht )
+void VideoChat::removeNachricht(const char* nachricht)
 {
-    Text *txt = new Text( nachricht );
-    txt->append( "\n" );
-    TextRenderer *textRd = verlauf->zTextRenderer();
-    if( textRd )
-    {
-        textRd->setSchriftSize( 12 );
-        textRd->textFormatieren( txt, verlauf->getBreite() - 15 - 2 );
-    }
-    int n = txt->anzahlVon( '\n' );
-    int n2 = verlauf->zText()->anzahlVon( '\n' );
-    if( n2 > n )
-        verlauf->zText()->remove( verlauf->zText()->positionVon( '\n', n2 - n - 1 ) + 1 );
-    else
-        verlauf->setText( "" );
-    verlauf->updateVScroll();
+	Text* txt = new Text(nachricht);
+	txt->append("\n");
+	TextRenderer* textRd = verlauf->zTextRenderer();
+	if (textRd)
+	{
+		textRd->setSchriftSize(12);
+		textRd->textFormatieren(txt, verlauf->getBreite() - 15 - 2);
+	}
+	int n = txt->anzahlVon('\n');
+	int n2 = verlauf->zText()->anzahlVon('\n');
+	if (n2 > n)
+		verlauf->zText()->remove(verlauf->zText()->positionVon('\n', n2 - n - 1) + 1);
+	else
+		verlauf->setText("");
+	verlauf->updateVScroll();
 }
 
-void VideoChat::doPublicMausEreignis( MausEreignis &me )
+void VideoChat::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    verlauf->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet )
-    {
-        verlauf->setRahmenFarbe( 0xFFFFFFFF );
-        verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
-    }
-    else
-    {
-        verlauf->setRahmenFarbe( 0xFF909090 );
-        verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
-    }
+	bool vera = me.verarbeitet;
+	verlauf->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet)
+	{
+		verlauf->setRahmenFarbe(0xFFFFFFFF);
+		verlauf->setVertikalScrollFarbe(0xFF808080, 0);
+	}
+	else
+	{
+		verlauf->setRahmenFarbe(0xFF909090);
+		verlauf->setVertikalScrollFarbe(0xFF404040, 0);
+	}
 }
 
-void VideoChat::tick( double z )
+void VideoChat::tick(double z)
 {
-    verlauf->tick( z );
+	verlauf->tick(z);
 }
 
-void VideoChat::render( Bild &zRObj )
+void VideoChat::render(Bild& zRObj)
 {
-    verlauf->render( zRObj );
+	verlauf->render(zRObj);
 }

Linie/Aufzeichnung/Chat/VideoChat.h

@@ -9,20 +9,20 @@ using namespace Framework;
 class VideoChat : public virtual ReferenceCounter
 {
 private:
-    TextFeld *verlauf;
+	TextFeld* verlauf;
 
 public:
-    // Konstruktor
-    VideoChat( UIInit &uiFactory );
-    // Destruktor
-    ~VideoChat();
-    // nicht constant
-    void addNachricht( char *nachricht );
-    void addNachricht( char *nachricht, int farbe );
-    void removeNachricht( char *nachricht );
-    void doPublicMausEreignis( MausEreignis &me );
-    void tick( double z );
-    void render( Bild &zRObj );
+	// Konstruktor
+	VideoChat(UIInit& uiFactory);
+	// Destruktor
+	~VideoChat();
+	// nicht constant
+	void addNachricht(const char* nachricht);
+	void addNachricht(const char* nachricht, int farbe);
+	void removeNachricht(const char* nachricht);
+	void doPublicMausEreignis(MausEreignis& me);
+	void tick(double z);
+	void render(Bild& zRObj);
 };
 
 #endif

Linie/SpielStatistik/Tabelle/StatistikTabelle.cpp

@@ -6,857 +6,857 @@
 
 struct OBJTabelleSpalteIni
 {
-    char *name;
-    int breite;
-    int minBreite;
-    int maxBreite;
+	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< char * > values )
+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;
+	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* 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;
+	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, char *txt )
+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;
+	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 )
+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 );
-        }
-    }
+	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();
+	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 )
+void StatistikTabelle::tabelleLehren(ObjTabelle* zT, bool überschrift)
 {
-    int zAnz = zT->getZeilenAnzahl();
-    for( int i = !überschrift; i < zAnz; i++ )
-        zT->removeZeile( !überschrift );
+	int zAnz = zT->getZeilenAnzahl();
+	for (int i = !überschrift; i < zAnz; i++)
+		zT->removeZeile(!überschrift);
 }
 
-void StatistikTabelle::tabelleFüllen( ObjTabelle *zT )
+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;
-        }
-    }
+	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 )
+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 );
-        }
-    }
+	// 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 )
+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;
+	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 )
+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 );
+	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;
+	return rundeAusw;
 }