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

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

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

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

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

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

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

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

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

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

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

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

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