Asteroids-Minigame/Asteroids/Menü.cpp

#include "Menü.h"
#include "Initialisierung.h"
#include <MausEreignis.h>
#include <Textfeld.h>
#include <InitDatei.h>
#include <Text.h>
#include <Datei.h>
#include <TastaturEreignis.h>
#include <KSGTDatei.h>
#include <Schrift.h>
#include <DateiSystem.h>
#include <Rahmen.h>
#include <AsynchronCall.h>
#include <Bildschirm.h>

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

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

// nicht constant
int MenüVerloren::doMausEreignis( MausEreignis &me )
{
    bool vera = me.verarbeitet;
    int ret = 0;
    neu->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        ret = 1;
    beenden->doMausEreignis( me );
    if( !vera && me.verarbeitet && !ret && me.id == ME_RLinks )
        ret = 2;
    return ret;
}

bool MenüVerloren::tick( double tickVal )
{
    bool ret = verloren->tick( tickVal );
    ret |= neu->tick( tickVal );
    ret |= beenden->tick( tickVal );
    return ret;
}

void MenüVerloren::render( Bild &zRObj )
{
    zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
    verloren->render( zRObj );
    neu->render( zRObj );
    beenden->render( zRObj );
    ram->render( zRObj );
}

// Reference Counting
MenüVerloren *MenüVerloren::getThis()
{
    ref++;
    return this;
}

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


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

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

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

void MenüSpiel::doMausEreignis( MausEreignis &me )
{
    bool vera = me.verarbeitet;
    beenden->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        map->speichern();
        beendet = 1;
    }
    map->doMausEreignis( me );
    if( map->istBeendet() )
    {
        int ak = verloren->doMausEreignis( me );
        if( ak == 1 )
            reset();
        if( ak == 2 )
            beendet = 1;
    }
}

void MenüSpiel::doTastaturEreignis( TastaturEreignis &te )
{
    if( map->istBeendet() )
    {
        if( te.id == TE_Release && te.taste == T_Enter )
            reset();
        if( te.id == TE_Release && te.taste == T_BackSpace )
            beendet = 1;
        return;
    }
    map->doTastaturEreignis( te );
}

bool MenüSpiel::tick( double tickVal )
{
    timePuffer += tickVal;
    
    bool ret = beenden->tick( tickVal );
    while( timePuffer >= 0.02 )
    {
        ret |= map->tick( 0.02 );
        timePuffer -= 0.02;
    }
    if( map->istBeendet() )
        ret |= verloren->tick( tickVal );
    scoreT->setText( "Score: " );
    scoreT->zText()->append( map->getScore() );
    return ret;
}

void MenüSpiel::render( Bild &zRObj )
{
    map->render( zRObj );
    scoreT->render( zRObj );
    beenden->render( zRObj );
    if( map->istBeendet() )
        verloren->render( zRObj );
}

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

// Reference Counting
MenüSpiel *MenüSpiel::getThis()
{
    ref++;
    return this;
}

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


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

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

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

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

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

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

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

// Reference Counting
MenüWiederhohlung *MenüWiederhohlung::getThis()
{
    ref++;
    return this;
}

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


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

// Destruktor
MenüStatistik::~MenüStatistik()
{
    int anz = gesammtT->getZeilenAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        for( int j = 0; j < 7; j++ )
            ( (TextFeld*)gesammtT->zZeichnung( j, 0 ) )->release();
        gesammtT->removeZeile( 0 );
    }
    for( int j = 0; j < 7; j++ )
        ( (TextFeld*)optionenT->zZeichnung( j, 0 ) )->release();
    while( !asyncFinished )
    {
        Sleep( 100 );
    }
    anz = worldBestT->getZeilenAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        for( int j = 0; j < 8; j++ )
        {
            if( j == 2 )
                ( (Knopf*)worldBestT->zZeichnung( j, 0 ) )->release();
            else
                ( (TextFeld*)worldBestT->zZeichnung( j, 0 ) )->release();
        }
        worldBestT->removeZeile( 0 );
    }
    worldBestT->release();
    ansichtT->release();
    ansicht->release();
    optionen->release();
    gesammtT->release();
    optionenT->release();
    gesammtD->release();
    optionenD->release();
    remove->release();
    zurück->release();
    schrift->release();
    klient->release();
    if( wiederH )
        wiederH->release();
    screen->release();
}

// nicht constant
void MenüStatistik::reset()
{
    if( wiederH )
        wiederH = wiederH->release();
    int anz = gesammtT->getZeilenAnzahl();
    for( int i = 1; i < anz; i++ )
    {
        for( int j = 0; j < 7; j++ )
            ( (TextFeld*)gesammtT->zZeichnung( j, 1 ) )->release();
        gesammtT->removeZeile( 1 );
    }
    anz = optionenT->getZeilenAnzahl();
    for( int i = 1; i < anz; i++ )
        optionenT->removeZeile( 1 );
    anz = worldBestT->getZeilenAnzahl();
    for( int i = 1; i < anz; i++ )
    {
        for( int j = 0; j < 8; j++ )
        {
            if( j == 2 )
                ( (Knopf*)worldBestT->zZeichnung( j, 1 ) )->release();
            else
                ( (TextFeld*)worldBestT->zZeichnung( j, 1 ) )->release();
        }
        worldBestT->removeZeile( 1 );
    }
    ObjTabelle *tmpWBT = worldBestT->getThis();
    KSGClient::MinigameServerClient *tmpKlient = klient->getThis();
    Schrift *tmpSchrift = schrift->getThis();
	asyncFinished = 0;
    new AsynchronCall( [ this, tmpWBT, tmpKlient, tmpSchrift ]()
    {
        Array< int > score;
        RCArray< Text > player;
        RCArray< Text > option;
        int anz = tmpKlient->getMinigameBestscoreList( "Asteroids", &score, &player, &option );
        for( int i = 0; i < anz; i++ )
        {
            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
            TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
            Text optionen = option.z( i )->getText();
            Text *breite = optionen.getTeilText( optionen.positionVon( '=' ) + 1, optionen.positionVon( ',' ) );
            Text *höhe = optionen.getTeilText( optionen.positionVon( '=', 1 ) + 1, optionen.positionVon( ',', 1 ) );
            Text *größe = optionen.getTeilText( optionen.positionVon( '=', 2 ) + 1, optionen.positionVon( ',', 2 ) );
            Text *timer = optionen.getTeilText( optionen.positionVon( '=', 3 ) + 1, optionen.positionVon( ',', 3 ) );
            Text *ship = optionen.getTeilText( optionen.positionVon( '=', 4 ) + 1 );
            switch( (int)*ship )
            {
            case 0:
                ship->setText( "Normal" );
                break;
            case 1:
                ship->setText( "Enterprise" );
                break;
            }
            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
            breite->release();
            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
            höhe->release();
            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, größe->getText() );
            größe->release();
            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, timer->getText() );
            timer->release();
            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, ship->getText() );
            ship->release();
            Knopf *ansehenK = initKnopf( 0, 0, 0, 0, tmpSchrift, Knopf::Style::Normal, "Ansehen" );
            ansehenK->setMausEreignis( [ this, optionen ]( void *p, void *obj, MausEreignis me ) -> bool
            {
                if( me.id == ME_RLinks && !me.verarbeitet )
                {
                    ( (Knopf*)obj )->removeStyle( Knopf::Style::Erlaubt );
                    getThis();
                    new AsynchronCall( [ this, optionen, obj ]()
                    {
                        Datei *d = klient->downloadGameCapture( "Asteroids", optionen );
                        ( (Knopf*)obj )->addStyle( Knopf::Style::Erlaubt );
                        if( wiederH )
                            wiederH = wiederH->release();
                        Text options = optionen.getText();
                        wiederH = new MenüWiederhohlung( schrift, screen, d, &options );
                        release();
                    } );
                }
                return 1;
            } );
            tmpWBT->addZeile( optionen.getText() );
            tmpWBT->setZeichnungZ( 0, i + 1, scoreT );
            tmpWBT->setZeichnungZ( 1, i + 1, spielerT );
            tmpWBT->setZeichnungZ( 2, i + 1, ansehenK );
            tmpWBT->setZeichnungZ( 3, i + 1, breiteT );
            tmpWBT->setZeichnungZ( 4, i + 1, höheT );
            tmpWBT->setZeichnungZ( 5, i + 1, größeT );
            tmpWBT->setZeichnungZ( 6, i + 1, timerT );
            tmpWBT->setZeichnungZ( 7, i + 1, shipT );
        }
        tmpKlient->release();
        tmpWBT->release();
        tmpSchrift->release();
    }, &asyncFinished );
    InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
    opd->laden();
    if( !opd->wertExistiert( "Breite" ) )
        opd->addWert( "Breite", "1600" );
    if( !opd->wertExistiert( "Höhe" ) )
        opd->addWert( "Höhe", "1000" );
    if( !opd->wertExistiert( "Größe" ) )
        opd->addWert( "Größe", "1000" );
    if( !opd->wertExistiert( "Timer" ) )
        opd->addWert( "Timer", "5000" );
    if( !opd->wertExistiert( "Ship" ) )
        opd->addWert( "Ship", "0" );
    if( !opd->wertExistiert( "Fortsetzen" ) )
        opd->addWert( "Fortsetzen", "0" );
    opd->speichern();
    KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
    stb->laden();
    anz = stb->getZeilenAnzahl();
    bool *fertig = new bool[ anz ];
    ZeroMemory( fertig, anz );
    int mS = 0;
    int omS = 0;
    int oAnz = 0;
    for( int i = 0; i < anz; i++ )
    {
        int maxScore = -1;
        int p = -1;
        for( int j = 0; j < anz; j++ )
        {
            if( !fertig[ j ] && maxScore < (int)*stb->zFeld( j, 1 ) )
            {
                p = j;
                maxScore = (int)*stb->zFeld( j, 1 );
            }
        }
        if( p >= 0 )
        {
            fertig[ p ] = 1;
            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
            TextFeld *datumT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 6 )->getText() );
            int ship = *stb->zFeld( p, 6 );
            switch( ship )
            {
            case 0:
                shipT->setText( "Normal" );
                break;
            case 1:
                shipT->setText( "Enterprise" );
                break;
            }
            gesammtT->addZeile( Text() += p );
            gesammtT->setZeichnungZ( 0, i + 1, scoreT );
            gesammtT->setZeichnungZ( 1, i + 1, datumT );
            gesammtT->setZeichnungZ( 2, i + 1, breiteT );
            gesammtT->setZeichnungZ( 3, i + 1, höheT );
            gesammtT->setZeichnungZ( 4, i + 1, größeT );
            gesammtT->setZeichnungZ( 5, i + 1, timerT );
            gesammtT->setZeichnungZ( 6, i + 1, shipT );
            if( breiteT->zText()->istGleich( opd->zWert( "Breite" )->getText() ) &&
                höheT->zText()->istGleich( opd->zWert( "Höhe" )->getText() ) &&
                größeT->zText()->istGleich( opd->zWert( "Größe" )->getText() ) &&
                timerT->zText()->istGleich( opd->zWert( "Timer" )->getText() ) &&
                stb->zFeld( p, 6 )->istGleich( opd->zWert( "Ship" )->getText() ) )
            {
                optionenT->addZeile( Text() += p );
                int n = optionenT->getZeilenNummer( Text() += p );
                optionenT->setZeichnungZ( 0, n, scoreT );
                optionenT->setZeichnungZ( 1, n, datumT );
                optionenT->setZeichnungZ( 2, n, breiteT );
                optionenT->setZeichnungZ( 3, n, höheT );
                optionenT->setZeichnungZ( 4, n, größeT );
                optionenT->setZeichnungZ( 5, n, timerT );
                optionenT->setZeichnungZ( 6, n, shipT );
                if( !omS )
                    omS = maxScore;
                oAnz++;
            }
        }
        if( !mS )
            mS = maxScore;
    }
    delete[] fertig;
    DiagDaten *gd = new DiagDaten();
    gd->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
    gd->hIntervallFarbe = 0xFFFFFFFF;
    gd->hIntervallName->setText( "Spiel" );
    gd->rasterDicke = 1;
    gd->rasterFarbe = 0xFF505050;
    gd->vIntervallFarbe = 0xFFFFFFFF;
    gd->vIntervallName->setText( "Score" );
    gesammtD->setDiagDatenZ( gd );
    gesammtD->addVIntervallText( mS + 1, Text() += ( mS + 1 ) );
    gesammtD->addVIntervallText( 0, "0" );
    gesammtD->addHIntervallText( 0, "1" );
    if( anz > 1 )
        gesammtD->addHIntervallText( anz - 1, Text() += anz );
    gesammtD->addWert( "Score" );
    gesammtD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
    gesammtD->setWertFarbe( 0, 0xFF00FF00 );
    gesammtD->zDiagWert( 0 )->hintergrund = 0xFF205050;
    DiagDaten *od = new DiagDaten();
    od->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
    od->hIntervallFarbe = 0xFFFFFFFF;
    od->hIntervallName->setText( "Spiel" );
    od->rasterDicke = 1;
    od->rasterFarbe = 0xFF505050;
    od->vIntervallFarbe = 0xFFFFFFFF;
    od->vIntervallName->setText( "Score" );
    optionenD->setDiagDatenZ( od );
    optionenD->addVIntervallText( omS + 1, Text() += ( omS + 1 ) );
    optionenD->addVIntervallText( 0, "0" );
    optionenD->addHIntervallText( 0, "1" );
    if( oAnz > 1 )
        optionenD->addHIntervallText( oAnz - 1, Text() += oAnz );
    optionenD->addWert( "Score" );
    optionenD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
    optionenD->setWertFarbe( 0, 0xFF00FF00 );
    optionenD->zDiagWert( 0 )->hintergrund = 0xFF205050;
    int j = 0;
    for( int i = 0; i < anz; i++ )
    {
        gesammtD->addPunkt( 0, i, (int)*stb->zFeld( i, 1 ) );
        if( (int)*stb->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
            (int)*stb->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
            (int)*stb->zFeld( i, 5 ) == (int)*opd->zWert( "Größe" ) &&
            (int)*stb->zFeld( i, 4 ) == (int)*opd->zWert( "Timer" ) &&
            (int)*stb->zFeld( i, 6 ) == (int)*opd->zWert( "Ship" ) )
        {
            optionenD->addPunkt( 0, j, (int)*stb->zFeld( i, 1 ) );
            j++;
        }
    }
    stb->release();
    opd->release();
    beendet = 0;
}

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

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

void MenüStatistik::render( Bild &zRObj )
{
    if( wiederH )
    {
        wiederH->render( zRObj );
        return;
    }
    schrift->setSchriftSize( 12 );
    Text weltScore = "Welt Score:";
    schrift->setDrawPosition( 10, 40 );
    schrift->renderText( &weltScore, zRObj, 0xFFFFFFFF );
    Text localScore = "Dein Score:";
    schrift->setDrawPosition( 10, 170 );
    schrift->renderText( &localScore, zRObj, 0xFFFFFFFF );
    worldBestT->render( zRObj );
    if( !ansicht->getAuswahl() )
    {
        if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
            optionenT->render( zRObj );
        else
            gesammtT->render( zRObj );
    }
    else
    {
        if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
            optionenD->render( zRObj );
        else
            gesammtD->render( zRObj );
    }
    ansichtT->render( zRObj );
    ansicht->render( zRObj );
    optionen->render( zRObj );
    remove->render( zRObj );
    zurück->render( zRObj );
}

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

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

// Reference Counting
MenüStatistik *MenüStatistik::getThis()
{
    ref++;
    return this;
}

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


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

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

// nicht constant
void MenüOptionen::reset()
{
    InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
    if( !opd->laden() )
        DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
    breite->setText( "1600" );
    if( opd->wertExistiert( "Breite" ) )
        breite->setText( Text() += (int)*opd->zWert( "Breite" ) );
    else
        opd->addWert( "Breite", "1600" );
    höhe->setText( "1000" );
    if( opd->wertExistiert( "Höhe" ) )
        höhe->setText( Text() += (int)*opd->zWert( "Höhe" ) );
    else
        opd->addWert( "Höhe", "1000" );
    aGröße->setText( "1000" );
    if( opd->wertExistiert( "Größe" ) )
        aGröße->setText( Text() += (int)*opd->zWert( "Größe" ) );
    else
        opd->addWert( "Größe", "1000" );
    timer->setText( "5000" );
    if( opd->wertExistiert( "Timer" ) )
        timer->setText( Text() += (int)*opd->zWert( "Timer" ) );
    else
        opd->addWert( "Timer", "5000" );
    ship->setAuswahl( 0 );
    if( opd->wertExistiert( "Ship" ) )
        ship->setAuswahl( *opd->zWert( "Ship" ) );
    else
        opd->addWert( "Ship", "0" );
    fortsetzen->removeStyle( KontrollKnopf::Style::Selected );
    if( opd->wertExistiert( "Fortsetzen" ) )
        fortsetzen->setStyle( KontrollKnopf::Style::Selected, (int)*opd->zWert( "Fortsetzen" ) != 0 );
    else
        opd->addWert( "Fortsetzen", "0" );
    beendet = 0;
    opd->speichern();
    opd->release();
}

void MenüOptionen::doMausEreignis( MausEreignis &me )
{
    breite->doMausEreignis( me );
    höhe->doMausEreignis( me );
    aGröße->doMausEreignis( me );
    timer->doMausEreignis( me );
    ship->doMausEreignis( me );
    fortsetzen->doMausEreignis( me );
    bool vera = me.verarbeitet;
    abbrechen->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        beendet = 1;
    vera = me.verarbeitet;
    ok->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
        if( !opd->laden() )
            DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
        if( (int)*breite->zText() > 10000 )
            breite->setText( "10000" );
        if( (int)*breite->zText() < 800 )
            breite->setText( "800" );
        if( opd->wertExistiert( "Breite" ) )
            opd->setWert( "Breite", Text() += (int)*breite->zText() );
        else
            opd->addWert( "Breite", Text() += (int)*breite->zText() );
        if( (int)*höhe->zText() > 10000 )
            höhe->setText( "10000" );
        if( (int)*höhe->zText() < 500 )
            höhe->setText( "500" );
        if( opd->wertExistiert( "Höhe" ) )
            opd->setWert( "Höhe", Text() += (int)*höhe->zText() );
        else
            opd->addWert( "Höhe", Text() += (int)*höhe->zText() );
        if( (int)*aGröße->zText() > 10000 )
            aGröße->setText( "10000" );
        if( (int)*aGröße->zText() < 10 )
            aGröße->setText( "10" );
        if( opd->wertExistiert( "Größe" ) )
            opd->setWert( "Größe", Text() += (int)*aGröße->zText() );
        else
            opd->addWert( "Größe", Text() += (int)*aGröße->zText() );
        if( (int)*timer->zText() < 500 )
            timer->setText( "500" );
        if( opd->wertExistiert( "Timer" ) )
            opd->setWert( "Timer", Text() += (int)*timer->zText() );
        else
            opd->addWert( "Timer", Text() += (int)*timer->zText() );
        if( opd->wertExistiert( "Ship" ) )
            opd->setWert( "Ship", Text() += ship->getAuswahl() );
        else
            opd->addWert( "Ship", Text() += ship->getAuswahl() );
        if( opd->wertExistiert( "Fortsetzen" ) )
            opd->setWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
        else
            opd->addWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
        opd->speichern();
        opd->release();
        beendet = 1;
    }
}

void MenüOptionen::doTastaturEreignis( TastaturEreignis &te )
{
    breite->doTastaturEreignis( te );
    höhe->doTastaturEreignis( te );
    aGröße->doTastaturEreignis( te );
    timer->doTastaturEreignis( te );
}

bool MenüOptionen::tick( double tickVal )
{
    bool ret = breite->tick( tickVal );
    ret |= höhe->tick( tickVal );
    ret |= aGröße->tick( tickVal );
    ret |= timer->tick( tickVal );
    ret |= ship->tick( tickVal );
    ret |= fortsetzen->tick( tickVal );
    ret |= abbrechen->tick( tickVal );
    ret |= ok->tick( tickVal );
    return ret;
}

void MenüOptionen::render( Bild &zRObj )
{
    breiteT->render( zRObj );
    breite->render( zRObj );
    höheT->render( zRObj );
    höhe->render( zRObj );
    aGrößeT->render( zRObj );
    aGröße->render( zRObj );
    timerT->render( zRObj );
    timer->render( zRObj );
    shipT->render( zRObj );
    fortsetzen->render( zRObj );
    abbrechen->render( zRObj );
    ok->render( zRObj );
    ship->render( zRObj );
}

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

// Reference Counting
MenüOptionen *MenüOptionen::getThis()
{
    ref++;
    return this;
}

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


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

// Destruktor
Menü::~Menü()
{
    spielen->release();
    spielenF->release();
    optionen->release();
    optionenF->release();
    statistik->release();
    statistikF->release();
    beenden->release();
    if( hintergrund )
        hintergrund->release();
    ram->release();
}

// nicht constant
void Menü::reset()
{
    status = 0;
    beendet = 0;
}

void Menü::doMausEreignis( MausEreignis &me )
{
    switch( status )
    {
    case 0:
        if( 1 )
        {
            bool vera = me.verarbeitet;
            spielen->doMausEreignis( me );
            if( !vera && me.verarbeitet && me.id == ME_RLinks )
            {
                spielenF->reset();
                status = 3;
            }
            vera = me.verarbeitet;
            optionen->doMausEreignis( me );
            if( !vera && me.verarbeitet && me.id == ME_RLinks )
            {
                optionenF->reset();
                status = 1;
            }
            vera = me.verarbeitet;
            statistik->doMausEreignis( me );
            if( !vera && me.verarbeitet && me.id == ME_RLinks )
            {
                statistikF->reset();
                status = 2;
            }
            vera = me.verarbeitet;
            beenden->doMausEreignis( me );
            if( !vera && me.verarbeitet && me.id == ME_RLinks )
                beendet = 1;
        }
        break;
    case 1:
        optionenF->doMausEreignis( me );
        break;
    case 2:
        statistikF->doMausEreignis( me );
        break;
    case 3:
        spielenF->doMausEreignis( me );
    }
}

void Menü::doTastaturEreignis( TastaturEreignis &te )
{
    if( status == 1 )
        optionenF->doTastaturEreignis( te );
    if( status == 3 )
        spielenF->doTastaturEreignis( te );
}

bool Menü::tick( double z )
{
    switch( status )
    {
    case 0:
        if( 1 )
        {
            bool ret = spielen->tick( z );
            ret |= statistik->tick( z );
            ret |= optionen->tick( z );
            ret |= beenden->tick( z );
            return ret;
        }
    case 1:
        if( optionenF->istBeendet() )
        {
            status = 0;
            return 1;
        }
        return optionenF->tick( z );
    case 2:
        if( statistikF->istBeendet() )
        {
            status = 0;
            return 1;
        }
        return statistikF->tick( z );
    case 3:
        if( spielenF->istBeendet() )
        {
            status = 0;
            return 1;
        }
        return spielenF->tick( z );
    }
    return 0;
}

void Menü::render( Bild &zRObj )
{
    if( status != 3 && ( status != 2 || !statistikF->istWiederhohlung() ) )
        zRObj.drawBild( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), *hintergrund );
    switch( status )
    {
    case 0:
        ram->setPosition( 300, 170 );
        ram->setSize( 200, 160 );
        zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
        ram->render( zRObj );
        spielen->render( zRObj );
        statistik->render( zRObj );
        optionen->render( zRObj );
        beenden->render( zRObj );
        break;
    case 1:
        ram->setPosition( 300, 110 );
        ram->setSize( 200, 280 );
        zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
        ram->render( zRObj );
        optionenF->render( zRObj );
        break;
    case 2:
        if( !statistikF->istWiederhohlung() )
            zRObj.alphaRegion( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), 0xD0000000 );
        statistikF->render( zRObj );
        break;
    case 3:
        spielenF->render( zRObj );
    }
}

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

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

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