#include "KESSVorschau.h"
#include "../../../../Global/Variablen.h"
#include "../../../../Global/Initialisierung.h"
#include <DateiSystem.h>

void kESSVorschauKSGSAktion( void *p, RCArray< KSGSVariable > *parameter, KSGSVariable **retVal )
{
    if( !p )
        return;
    ( (KESSVorschauKarteScript*)p )->ksgsAktion( parameter, retVal );
}

// Inhalt der KESSVorschauKarteScript Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschauKarteScript::KESSVorschauKarteScript( Schrift *zSchrift, TextFeld *zLog )
    : Thread()
{
    ksgs = dllDateien->ladeDLL( "KSGScript.dll", "data/bin/KSGScript.dll" );
    if( ksgs )
    {
        KSGSGetZeichnung getKSGScript = (KSGSGetZeichnung)GetProcAddress( ksgs, KSGS_START_FUNKTION );
        if( getKSGScript )
        {
            fenster = getKSGScript();
            fenster->setSchriftZ( zSchrift->getThis() );
            fenster->setGröße( 555, 380 );
            fenster->setRückrufParam( this );
            fenster->setRückrufFunktion( kESSVorschauKSGSAktion );
            fenster->setLog( zLog->getThis() );
        }
        else
        {
            fenster = 0;
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Der Einstiegspunkt '" KSGS_START_FUNKTION "' in der DLL-Datei "
                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
    }
    else
    {
        fenster = 0;
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                      new Text( "Die DLL-Datei 'data/bin/KSGScript.dll' konnte nicht geladen werden." ),
                                                      new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
    }
    ram = new LRahmen();
    ram->setGröße( 555, 380 );
    ram->setFarbe( 0xFFFFFFFF );
    pos = Punkt( 220, 10 );
    sichtbar = 0;
    besitztTestVersion = 0;
    verbleibend = 0;
    vollversionErwerbbar = 1;
    testversionErwerbbar = 1;
    vvPreis = 0;
    tvPreis = 0;
    kupfer = 0;
    alpha = 0;
    aktion = 0;
    ak = 0;
    ref = 1;
}

// Destruktor
KESSVorschauKarteScript::~KESSVorschauKarteScript()
{
    if( fenster )
    {
        fenster->zurücksetzen();
        fenster->release();
    }
    ram->release();
    if( ksgs )
        dllDateien->releaseDLL( "KSGScript.dll" );
}

// nicht constant
void KESSVorschauKarteScript::thread()
{
    sichtbar = 0;
    while( alpha )
        Sleep( 100 );
    if( ak == 1 )
    {
        pfad += "/seite/seite.ksgs";
        if( fenster )
            fenster->setScriptDatei( pfad );
    }
    fenster->neuLaden();
    sichtbar = 1;
    ak = 0;
    run = 0;
}

void KESSVorschauKarteScript::setScriptParams( bool hatTV, int tvVerb, bool vvEn, bool tvEn, int vvK, int tvK, int k )
{
    besitztTestVersion = hatTV;
    verbleibend = tvVerb;
    vollversionErwerbbar = vvEn;
    testversionErwerbbar = tvEn;
    vvPreis = vvK;
    tvPreis = tvK;
    kupfer = k;
    if( sichtbar )
    {
        ak = 2;
        start();
    }
}

void KESSVorschauKarteScript::ladeKarteSeite( char *pfad )
{
    if( run )
        warteAufThread( 5000 );
    if( run )
        ende();
    this->pfad = pfad;
    ak = 1;
    start();
}

void KESSVorschauKarteScript::ksgsAktion( RCArray< KSGSVariable > *parameter, KSGSVariable **retVal )
{
    KSGSVariable *befehl = parameter->z( 0 );
    if( !befehl )
        return;
    Text *b = befehl->getText();
    if( !b )
        return;
    if( b->istGleich( "GetBesitzStatus" ) )
    {
        int besitz = (int)besitztTestVersion;
        KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
        if( getKSGSVariable )
        {
            KSGSVariableDef def = { KSGS_INT, 0, 3, ( Text() += besitz ).getText() };
            *retVal = getKSGSVariable( fenster, &def );
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        b->release();
        return;
    }
    if( b->istGleich( "GetPreis" ) )
    {
        KSGSVariable *version = parameter->z( 1 );
        if( !version )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                                                          "Sie könnte eventuell nicht richtig funktionieren." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        else
        {
            bool testVersion = !version->getInt();
            int k = testVersion ? tvPreis : vvPreis;
            KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
            if( getKSGSVariable )
            {
                KSGSVariableDef def = { KSGS_INT, 0, 3, ( Text() += k ).getText() };
                *retVal = getKSGSVariable( fenster, &def );
            }
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                              new Text( "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
                                                              "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                              new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
            }
        }
        b->release();
        return;
    }
    if( b->istGleich( "GetTestVersionVerbleibend" ) )
    {
        KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
        if( getKSGSVariable )
        {
            KSGSVariableDef def = { KSGS_INT, 0, 3, ( Text() += verbleibend ).getText() };
            *retVal = getKSGSVariable( fenster, &def );
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        b->release();
        return;
    }
    if( b->istGleich( "GetErwerbbarStatus" ) )
    {
        int erwerbbar = ( (int)testversionErwerbbar & 0x1 ) | ( ( (int)vollversionErwerbbar << 1 ) & 0x2 );
        KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
        if( getKSGSVariable )
        {
            KSGSVariableDef def = { KSGS_INT, 0, 3, ( Text() += erwerbbar ).getText() };
            *retVal = getKSGSVariable( fenster, &def );
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        b->release();
        return;
    }
    if( b->istGleich( "GetKupfer" ) )
    {
        KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
        if( getKSGSVariable )
        {
            KSGSVariableDef def = { KSGS_INT, 0, 3, ( Text() += kupfer ).getText() };
            *retVal = getKSGSVariable( fenster, &def );
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        b->release();
        return;
    }
    if( b->istGleich( "Kaufen" ) )
    {
        KSGSVariable *version = parameter->z( 1 );
        if( !version )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                                                          "Sie könnte eventuell nicht richtig funktionieren." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        b->release();
        return;
    }
    if( b->istGleich( "GetBild" ) )
    {
        KSGSVariable *pfad = parameter->z( 1 );
        KSGSVariable *name = parameter->z( 2 );
        if( !pfad || !name )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                                                          "Sie könnte eventuell nicht richtig funktionieren." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
        }
        else
        {
            Text *pf = pfad->getText();
            Text *n = name->getText();
            if( !pf || !n )
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                              new Text( "Auf dieser Seite befindet sich ein Fehler im KSG-Script. "
                                                              "Sie könnte eventuell nicht richtig funktionieren." ),
                                                              new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
            }
            else
            {
                KSGSGetVariable getKSGSVariable = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
                if( getKSGSVariable )
                {
                    int p = n->positionVon( ".ltdb/" );
                    if( p < 0 )
                        p = 0;
                    else
                        p += 6;
                    Bild *b = bilder->get( *n );
                    if( !b )
                    {
                        LTDBDatei *dat = new LTDBDatei();
                        dat->setDatei( pf->getThis() );
                        dat->leseDaten( 0 );
                        b = dat->laden( 0, n->getTeilText( p, n->getLänge() ) );
                        dat->release();
                        if( b )
                            bilder->add( *n, b->getThis() );
                    }
                    if( b )
                    {
                        KSGSVariableDef def = { KSGS_BILD, 0, 3, "" };
                        KSGSVariable *ret = getKSGSVariable( fenster, &def );
                        KSGSSetBild setKSGSBild = (KSGSSetBild)GetProcAddress( ksgs, KSGS_SET_BILD_FUNKTION );
                        if( !setKSGSBild )
                        {
                            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                                          new Text( "Der Einstiegspunkt '" KSGS_SET_BILD_FUNKTION "' in der DLL-Datei "
                                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
                            b->release();
                        }
                        else
                            setKSGSBild( ret, b );
                        *retVal = ret;
                    }
                }
                else
                {
                    nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                                  new Text( "Der Einstiegspunkt '" KSGS_VARIABLE_FUNKTION "' in der DLL-Datei "
                                                                  "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                                  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
                }
            }
            if( pf )
                pf->release();
            if( n )
                n->release();
        }
        b->release();
        return;
    }
}

void KESSVorschauKarteScript::doMausEreignis( MausEreignis &me )
{
    me.mx -= pos.x;
    me.my -= pos.y;
    if( fenster )
        fenster->doMausEreignis( me );
    me.mx += pos.x;
    me.my += pos.y;
}

void KESSVorschauKarteScript::doTastaturEreignis( TastaturEreignis &te )
{
    if( fenster )
        fenster->doTastaturEreignis( te );
}

bool KESSVorschauKarteScript::tick( double zeit )
{
    bool rend = fenster ? fenster->tick( zeit ) : 0;
    if( !sichtbar && alpha > 0 )
    {
        if( alpha - zeit * 150 < 0 )
            alpha = 0;
        else
            alpha -= (unsigned char)( zeit * 150 );
        rend = 1;
    }
    if( sichtbar && alpha < 255 )
    {
        if( alpha + zeit * 150 > 255 )
            alpha = 255;
        else
            alpha += (unsigned char)( zeit * 150 );
        rend = 1;
    }
    return rend;
}

void KESSVorschauKarteScript::render( Bild &zRObj )
{
    if( !zRObj.setDrawOptions( pos.x, pos.y, ram->getBreite(), ram->getHöhe() ) )
        return;
    zRObj.setAlpha( alpha );
    ram->render( zRObj );
    if( fenster )
        fenster->render( zRObj );
    zRObj.releaseAlpha();
    zRObj.releaseDrawOptions();
}

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

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


// Inhalt der KESSVorschauKarte Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschauKarte::KESSVorschauKarte( Schrift *schrift )
{
    auswählen = initKnopf( 173, 73, 22, 22, 0, 0, "" );
    auswählen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Rahmen | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    auswählen->setHintergrundBildZ( bilder->get( "shop.ltdb/weiter.png" ) );
    initToolTip( auswählen, "Karte auswählen.", schrift, hauptScreen );
    auswählen->setLinienRahmenBreite( 1 );
    hintergrund = 0;
    ausgewählt = new AlphaFeld();
    ausgewählt->setPosition( 1, 1 );
    ausgewählt->setGröße( 198, 98 );
    ausgewählt->setFarbe( 0x0000FF00 );
    ausgewählt->setStärke( 10 );
    ram = new LRahmen();
    ram->setPosition( 10, 10 );
    ram->setGröße( 200, 100 );
    ram->setFarbe( 0xFFFFFFFF );
    ausw = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
KESSVorschauKarte::~KESSVorschauKarte()
{
    auswählen->release();
    if( hintergrund )
        hintergrund->release();
    ausgewählt->release();
    ram->release();
}

// nicht constant
void KESSVorschauKarte::ladeKarte( char *pfad )
{
    LTDBDatei *datei = new LTDBDatei();
    Text *bdpf = new Text( pfad );
    bdpf->anhängen( "/titelbg.ltdb" );
    datei->setDatei( bdpf );
    hintergrund = datei->laden( 0, new Text( "auswbg.jpg" ) );
    datei->release();
}

bool KESSVorschauKarte::doMausEreignis( MausEreignis &me )
{
    bool vera = me.verarbeitet;
    auswählen->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        ausw = 1;
        return 1;
    }
    return 0;
}

bool KESSVorschauKarte::tick( double zeit )
{
    rend |= ausgewählt->tick( zeit );
    rend |= auswählen->tick( zeit );
    int a = ( ausgewählt->getFarbe() >> 24 ) & 0xFF;
    if( ausw && a < 255 )
    {
        if( a + 150 * zeit > 255 )
            a = 255;
        else
            a += (int)( zeit * 150 );
        ausgewählt->setFarbe( ( ( a << 24 ) & 0xFF000000 ) | ( ausgewählt->getFarbe() & 0xFFFFFF ) );
        rend = 1;
    }
    if( !ausw && a > 0 )
    {
        if( a - 150 * zeit < 0 )
            a = 0;
        else
            a += (int)( zeit * 150 );
        ausgewählt->setFarbe( ( ( a << 24 ) & 0xFF000000 ) | ( ausgewählt->getFarbe() & 0xFFFFFF ) );
        rend = 1;
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void KESSVorschauKarte::render( Bild &zRObj )
{
    ram->render( zRObj );
    if( !zRObj.setDrawOptions( ram->getX(), ram->getY(), 200, 100 ) )
        return;
    if( hintergrund )
        zRObj.drawBild( 1, 1, 198, 98, *hintergrund );
    ausgewählt->render( zRObj );
    auswählen->render( zRObj );
    zRObj.releaseDrawOptions();
}

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

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


// Inhalt der KESSVorschau Klasse aus KESSVorschau.h
// Konstruktor
KESSVorschau::KESSVorschau( Schrift *zSchrift )
{
    schrift = zSchrift->getThis();
    log = initTextFeld( 10, 400, 860, 90, zSchrift, TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt, "Log:\n" );
    script = new KESSVorschauKarteScript( zSchrift, log );
    karte = new KESSVorschauKarte( zSchrift->getThis() );
    beenden = initKnopf( 10, 500, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurück" );
    besitztTestVersion = initAuswahlBox( 10, 120, 200, 20, zSchrift, ABSTYLE, { "Besitzt Testversion nicht", "Besitzt Testversion" } );
    spieleVerbleibend = initTextFeld( 110, 150, 100, 20, zSchrift, TextFeld::Style::TextFeld, "0" );
    spieleVerbleibend->setTastaturEreignis( _nurNummernTE );
    vvErwerbbar = initAuswahlBox( 10, 180, 200, 20, zSchrift, ABSTYLE, { "Vollversion erwerbbar", "Vollversion nicht erwerbbar" } );
    tvErwerbbar = initAuswahlBox( 10, 210, 200, 20, zSchrift, ABSTYLE, { "Testversion erwerbbar", "Testversion nicht erwerbbar" } );
    vvPreis = initTextFeld( 110, 240, 100, 20, zSchrift, TextFeld::Style::TextFeld, "0" );
    vvPreis->setTastaturEreignis( _nurNummernTE );
    tvPreis = initTextFeld( 110, 270, 100, 20, zSchrift, TextFeld::Style::TextFeld, "0" );
    tvPreis->setTastaturEreignis( _nurNummernTE );
    kupfer = initTextFeld( 110, 300, 100, 20, zSchrift, TextFeld::Style::TextFeld, "0" );
    pfad = "";
    alpha = 0;
    sichtbar = 0;
    tickVal = 0;
    aktion = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
KESSVorschau::~KESSVorschau()
{
    schrift->release();
    script->release();
    karte->release();
    beenden->release();
    besitztTestVersion->release();
    spieleVerbleibend->release();
    vvErwerbbar->release();
    tvErwerbbar->release();
    vvPreis->release();
    tvPreis->release();
    kupfer->release();
    log->release();
}

// nicht constant
int KESSVorschau::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

void KESSVorschau::ladeKarte( char *pfad )
{
    karte->ladeKarte( pfad );
    this->pfad = pfad;
}

void KESSVorschau::setSichtbar( bool sicht )
{
    sichtbar = sicht;
}

void KESSVorschau::doMausEreignis( MausEreignis &me )
{
    if( !sichtbar )
        return;
    bool paramUpdate = 0;
    int ausw = vvErwerbbar->getAuswahl();
    vvErwerbbar->doMausEreignis( me );
    if( ausw != vvErwerbbar->getAuswahl() && me.id == ME_RLinks )
    {
        vvErwerbbar->einklappen();
        paramUpdate = 1;
    }
    ausw = tvErwerbbar->getAuswahl();
    tvErwerbbar->doMausEreignis( me );
    if( ausw != tvErwerbbar->getAuswahl() && me.id == ME_RLinks )
    {
        tvErwerbbar->einklappen();
        paramUpdate = 1;
    }
    ausw = besitztTestVersion->getAuswahl();
    besitztTestVersion->doMausEreignis( me );
    if( ausw != besitztTestVersion->getAuswahl() && me.id == ME_RLinks )
    {
        besitztTestVersion->einklappen();
        paramUpdate = 1;
    }
    script->doMausEreignis( me );
    if( karte->doMausEreignis( me ) )
        script->ladeKarteSeite( pfad );
    bool vera = me.verarbeitet;
    beenden->doMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 1;
    vvPreis->doMausEreignis( me );
    tvPreis->doMausEreignis( me );
    kupfer->doMausEreignis( me );
    spieleVerbleibend->doMausEreignis( me );
    log->doMausEreignis( me );
    if( paramUpdate )
    {
        script->setScriptParams( besitztTestVersion->getAuswahl() == 1, (int)*spieleVerbleibend->zText(), vvErwerbbar->getAuswahl() == 0,
                                 tvErwerbbar->getAuswahl() == 0, (int)*vvPreis->zText(), (int)*tvPreis->zText(), (int)*kupfer->zText() );
    }
}

void KESSVorschau::doTastaturEreignis( TastaturEreignis &te )
{
    if( !sichtbar )
        return;
    if( !te.verarbeitet && te.id == TE_Release && te.taste == T_Enter )
    {
        if( spieleVerbleibend->hatStyle( TextFeld::Style::Fokus ) || vvPreis->hatStyle( TextFeld::Style::Fokus ) || tvPreis->hatStyle( TextFeld::Style::Fokus ) || kupfer->hatStyle( TextFeld::Style::Fokus ) )
        {
            script->setScriptParams( besitztTestVersion->getAuswahl() == 1, (int)*spieleVerbleibend->zText(), vvErwerbbar->getAuswahl() == 0,
                                     tvErwerbbar->getAuswahl() == 0, (int)*vvPreis->zText(), (int)*tvPreis->zText(), (int)*kupfer->zText() );
        }
    }
    script->doTastaturEreignis( te );
    spieleVerbleibend->doTastaturEreignis( te );
    vvPreis->doTastaturEreignis( te );
    tvPreis->doTastaturEreignis( te );
    kupfer->doTastaturEreignis( te );
}

bool KESSVorschau::tick( double zeit )
{
    bool ret = script->tick( zeit );
    ret |= karte->tick( zeit );
    ret |= beenden->tick( zeit );
    ret |= spieleVerbleibend->tick( zeit );
    ret |= vvPreis->tick( zeit );
    ret |= tvPreis->tick( zeit );
    ret |= kupfer->tick( zeit );
    ret |= log->tick( zeit );
    ret |= tvErwerbbar->tick( zeit );
    ret |= vvErwerbbar->tick( zeit );
    ret |= besitztTestVersion->tick( zeit );
    tickVal += zeit * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    return ret;
}

void KESSVorschau::render( Bild &zRObj )
{
    zRObj.setAlpha( alpha );
    script->render( zRObj );
    karte->render( zRObj );
    beenden->render( zRObj );
    spieleVerbleibend->render( zRObj );
    log->render( zRObj );
    vvPreis->render( zRObj );
    tvPreis->render( zRObj );
    kupfer->render( zRObj );
    schrift->lock();
    schrift->setSchriftGröße( 12 );
    Text txt = "Test Spiele:";
    schrift->setDrawPosition( 10, 154 );
    schrift->renderText( &txt, zRObj, 0xFFFFFFFF );
    txt = "Voll Preis:";
    schrift->setDrawPosition( 10, 244 );
    schrift->renderText( &txt, zRObj, 0xFFFFFFFF );
    txt = "Test Preis:";
    schrift->setDrawPosition( 10, 274 );
    schrift->renderText( &txt, zRObj, 0xFFFFFFFF );
    txt = "Kupfer Besitz:";
    schrift->setDrawPosition( 10, 304 );
    schrift->renderText( &txt, zRObj, 0xFFFFFFFF );
    txt = "Diese Werte sind nur zum\nTesten und haben keinerlei\nEinfluss auf den Shop.";
    schrift->setDrawPosition( 10, 334 );
    schrift->renderText( &txt, zRObj, 0xFFFFFFFF );
    schrift->unlock();
    tvErwerbbar->render( zRObj );
    vvErwerbbar->render( zRObj );
    besitztTestVersion->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
bool KESSVorschau::istSichtbar() const
{
    return sichtbar;
}

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

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