KSG-Client/KSGClient/NachLogin/Spiele/Karte Auswahl/KarteAuswahl.cpp

#include "KarteAuswahl.h"
#include <Text.h>
#include <Rahmen.h>
#include <Punkt.h>
#include <Schrift.h>
#include <AlphaFeld.h>
#include <TextFeld.h>
#include <Datei.h>
#include <DateiSystem.h>
#include "..\..\..\Global\Initialisierung.h"
#include <MausEreignis.h>
#include "..\..\..\Global\Variablen.h"
#include "..\..\..\Leser\KartenLeser.h"
#include <Globals.h>

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


KarteDaten::Loader::Loader( KarteDaten *kd, int aktion )
{
    this->aktion = aktion;
    this->kd = kd;
    ref = 2;
    start();
}

void KarteDaten::Loader::thread()
{
    if( !aktion )
    {
        kd->geladen = 0;
        if( kd->hintergrund )
            kd->hintergrund = kd->hintergrund->release();
        if( kd->beschreibung )
        {
            kd->beschreibung->zurücksetzen();
            kd->beschreibung = dynamic_cast<KSGScriptObj*>(kd->beschreibung->release());
        }
        kd->rend = 1;
        if( kd->ksgs )
        {
            Framework::getDLLRegister()->releaseDLL( "KSGScript.dll" );
            kd->ksgs = 0;
        }
    }
    else
    {
        KartenLeser *mapReader = KartenLeser::getInstance();
        mapReader->lock();
        mapReader->setKarteId( kd->karteId );
        if( aktion == 1 )
        {
            if( !kd->hintergrund )
                kd->hintergrund = mapReader->getKartenTitelBild( kd->schrift );
            if( !kd->geladen )
                kd->geladen = 1;
            kd->rend = 1;
        }
        if( aktion == 2 )
        {
            if( !mapReader->getKartenBeschreibung() )
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Beschreibung nicht gefunden." ), new Text( "Ok" ) );
            if( kd->beschreibung )
            {
                kd->beschreibung->zurücksetzen();
                kd->beschreibung = dynamic_cast<KSGScriptObj*>(kd->beschreibung->release());
            }
            if( !kd->ksgs )
                kd->ksgs = Framework::getDLLRegister()->ladeDLL( "KSGScript.dll", "data/bin/KSGScript.dll" );
            if( kd->ksgs )
            {
                KSGSGetZeichnung getKSGScript = (KSGSGetZeichnung)GetProcAddress( kd->ksgs, KSGS_START_FUNKTION );
                if( getKSGScript )
                {
                    kd->beschreibung = getKSGScript();
                    kd->beschreibung->setBildschirmZ( hauptScreen->getThis() );
                    kd->beschreibung->setSchriftZ( kd->schrift->getThis() );
                    kd->beschreibung->setSize( 578, 428 );
                    kd->beschreibung->setRückrufParam( kd );
                    kd->beschreibung->setRückrufFunktion( KarteAuswahlKSGSAktion );
                    Text *pf = mapReader->getKartePfad();
                    *pf += "beschreibung.ksgs";
                    kd->beschreibung->setScriptDatei( pf );
                }
                else
                {
                    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 );
                }
            }
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                              new Text( "Die DLL-Datei 'data/bin/KSGScript.dll' konnte nicht geladen werden." ),
                                                              new Text( "Ok" ), 0 );
            }
            if( kd->beschreibung )
            {
                kd->geladen = 2;
                if( kd->ausgewählt )
                {
                    kd->beschreibung->lock();
                    kd->animation |= 0x4;
                    kd->beschreibung->neuLaden();
                    KSGSGetVariable getKSGSVar = (KSGSGetVariable)GetProcAddress( kd->ksgs, KSGS_VARIABLE_FUNKTION );
                    RCArray< KSGSVariable > *params = new RCArray< KSGSVariable >();
                    KSGSVariableDef p1;
                    p1.typId = KSGS_BOOL;
                    p1.wert = (int)kd->erlaubt;
                    params->add( getKSGSVar( kd->beschreibung, &p1 ) );
                    KSGSVariable *var = kd->beschreibung->startFunktion( kd->beschreibung->getFunktionId( "_set_Erlaubt" ), params );
                    if( var )
                        var->release();
                    kd->beschreibung->unlock();
                }
            }
            kd->rend = 1;
        }
        mapReader->unlock();
        mapReader->release();
    }
    if( !kd->erlaubt )
        kd->updateErlaubt();
    kd->rend = 1;
    release();
}

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

int KarteDaten::Loader::getAction() const
{
    return aktion;
}

// Inhalt der KarteDaten Klasse aus KarteAuswahl.h
// Konstruktor
KarteDaten::KarteDaten( Schrift *zSchrift, int id )
{
    hintergrund = 0;
    beschreibung = 0;
    ksgs = 0;
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    tickVal = 0;
    animation = 0;
    ausgewählt = 0;
    pos = Punkt( 0, 500 );
    gr = Punkt( 200, 100 );
    schrift = zSchrift->getThis();
    karteId = id;
    geladen = 0;
    auswahl = new AlphaFeld();
    auswahl->setFarbe( 0x0000FF00 );
    auswahl->setStrength( 8 );
    auswahl->setSize( 200, 100 );
    auswAlpha = 0;
    rend = 0;
    erlaubt = 0;
    tAlpha = 0;
    alpha = 0;
    ref = 1;
    loader = new Loader( this, 1 );
}

// Destruktor
KarteDaten::~KarteDaten()
{
    if( loader && loader->isRunning() )
        loader->warteAufThread( INT_MAX );
    loader->release();
    if( schrift )
        schrift->release();
    if( hintergrund )
        hintergrund->release();
    if( beschreibung )
    {
        beschreibung->zurücksetzen();
        beschreibung->release();
    }
    if( ksgs )
    {
        Framework::getDLLRegister()->releaseDLL( "KSGScript.dll" );
        ksgs = 0;
    }
    rahmen->release();
    auswahl->release();
}

// nicht constant
void KarteDaten::updateErlaubt()
{
    if( geladen != 2 )
        return;
    bool update = erlaubt;
    erlaubt = infoClient->istKarteErlaubt( karteId );
    if( update != erlaubt && beschreibung && ksgs )
    {

        beschreibung->lock();
        KSGSGetVariable getKSGSVar = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
        RCArray< KSGSVariable > *params = new RCArray< KSGSVariable >();
        KSGSVariableDef p1;
        p1.typId = KSGS_BOOL;
        p1.wert = (int)erlaubt;
        params->add( getKSGSVar( beschreibung, &p1 ) );
        KSGSVariable *var = beschreibung->startFunktion( beschreibung->getFunktionId( "_set_Erlaubt" ), params );
        if( var )
            var->release();
        beschreibung->unlock();
    }
}

void KarteDaten::ksgsAktion( RCArray< KSGSVariable > *parameter, KSGSVariable **retVal )
{
    if( parameter && parameter->getEintragAnzahl() > 0 )
    {
        Text *txt = parameter->z( 0 )->getText();
        if( erlaubt && txt->istGleich( "anmelden" ) )
        {
            if( nachLogin && nachLogin->zSpielenFenster() )
                nachLogin->zSpielenFenster()->anmelden( karteId );
        }
        if( erlaubt && txt->istGleich( "gruppeErstellen" ) )
        {
            if( !anmeldungClient )
                anmeldungClient = mainClient->createAnmeldungServerClient();
            if( !anmeldungClient )
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
                rend = 1;
            }
            if( !anmeldungClient->verbinde() )
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
                rend = 1;
            }
            else
            {
                int ret = anmeldungClient->gruppeErstellen( karteId );
                if( !ret && nachLogin )
                {
                    nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                  new Text( "Ok" ), 0 );
                }
                else if( nachLogin )
                    nachLogin->zSpielenFenster()->gruppeBetreten( ret );
                anmeldungClient->trenne( 0 );
            }
        }
        txt->release();
    }
}

void KarteDaten::setSichtbar( bool sichtbar )
{
    if( sichtbar )
        animation |= 0x1;
    else
    {
        animation &= ~0x1;
        setAuswahl( 0 );
    }
    if( sichtbar && geladen != 2 && loader->getAction() != 2 )
    {
        Loader *altLoader = loader;
        loader = new Loader( this, 2 );
        altLoader->release();
    }
    rend = 1;
}

void KarteDaten::setSichtbar()
{
    animation |= 0x1;
    if( ausgewählt && geladen == 2 )
    {
        animation |= 0x4;
        beschreibung->setPosition( beschreibung->getX(), 0 );
    }
    if( geladen != 2 && loader->getAction() != 2 )
    {
        Loader *altLoader = loader;
        loader = new Loader( this, 2 );
        altLoader->release();
    }
    rend = 1;
}

void KarteDaten::setAuswahl( bool auswahl )
{
    if( ausgewählt == auswahl )
        return;
    ausgewählt = auswahl;
    if( auswahl )
    {
        animation |= 0x4;
        if( beschreibung && ksgs )
        {
            beschreibung->lock();
            beschreibung->neuLaden();
            KSGSGetVariable getKSGSVar = (KSGSGetVariable)GetProcAddress( ksgs, KSGS_VARIABLE_FUNKTION );
            RCArray< KSGSVariable > *params = new RCArray< KSGSVariable >();
            KSGSVariableDef p1;
            p1.typId = KSGS_BOOL;
            p1.wert = (int)erlaubt;
            params->add( getKSGSVar( beschreibung, &p1 ) );
            KSGSVariable *var = beschreibung->startFunktion( beschreibung->getFunktionId( "_set_Erlaubt" ), params );
            if( var )
                var->release();
            beschreibung->unlock();
        }
    }
    else
        animation &= ~0x4;
    rend = 1;
}

void KarteDaten::setPosition( int lPos )
{
    pos.y = lPos * 100;
    rend = 1;
}

bool KarteDaten::tick( double tickVal )
{
    if( beschreibung )
    {
        beschreibung->lock();
        rend |= beschreibung->tick( tickVal );
        beschreibung->unlock();
    }
    this->tickVal += tickVal * 500;
    int val = ( int ) this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 17 )
        val = 17;
    this->tickVal -= val;
    if( ausgewählt )
    {
        if( auswAlpha != 0xF0 )
        {
            auswAlpha += val;
            if( auswAlpha > 0xF0 )
                auswAlpha = 0xF0;
            rend = 1;
        }
    }
    else
    {
        if( auswAlpha != 0 )
        {
            auswAlpha -= val;
            if( auswAlpha > 0xF0 )
                auswAlpha = 0;
            rend = 1;
        }
    }
    if( ( animation | 0x1 ) == animation ) // sichtbar
    {
        if( tAlpha != 255 )
        {
            if( tAlpha + val > 255 )
                tAlpha = 255;
            else
                tAlpha += val;
            rend = 1;
        }
    }
    else // unsichtbar
    {
        if( tAlpha != 0 )
        {
            if( tAlpha - val < 0 )
                tAlpha = 0;
            else
                tAlpha -= val;
            rend = 1;
        }
    }
    if( ( animation | 0x4 ) == animation ) // auswählen
    {
        if( beschreibung )
        {
            if( alpha != 255 )
            {
                if( alpha + val < 255 )
                    alpha += val;
                else
                    alpha = 255;
                rend = 1;
            }
        }
    }
    else // abwählen
    {
        int a = ( auswahl->getFarbe() >> 24 ) & 0xFF;
        if( a != 0 )
        {
            a -= val;
            if( a < 0 )
                a = 0;
            auswahl->setFarbe( ( ( a << 24 ) & 0xFF000000 ) | ( auswahl->getFarbe() & 0xFFFFFF ) );
            rend = 1;
        }
        if( beschreibung )
        {
            if( alpha != 0 )
            {
                if( alpha - val > 0 )
                    alpha -= val;
                else
                    alpha = 0;
                rend = 1;
            }
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void KarteDaten::doPublicMausEreignis( MausEreignis &me )
{
    me.mx -= gr.x;
    if( beschreibung )
        beschreibung->doPublicMausEreignis( me );
    me.mx += gr.x;
}

void KarteDaten::render( Bild &zRObj )
{
    int x = pos.x;
    int y = pos.y;
    int br = gr.x;
    int hö = gr.y;
    if( !zRObj.setDrawOptions( x, y, br, hö ) )
        return;
    zRObj.setAlpha( tAlpha );
    rahmen->setSize( br, hö );
    rahmen->render( zRObj );
    int rbr = rahmen->getRBreite();
    if( geladen && hintergrund )
        zRObj.drawBild( rbr, rbr, br - rbr * 2, hö - rbr * 2, *hintergrund );
    if( auswAlpha && auswahl )
    {
        auswahl->setFarbe( ( auswahl->getFarbe() & 0x00FFFFFF ) | ( auswAlpha << 24 ) );
        auswahl->setPosition( rbr, rbr );
        auswahl->setSize( br - rbr * 2, hö - rbr * 2 );
        auswahl->render( zRObj );
    }
    zRObj.releaseDrawOptions();
    x = br;
    y = 0;
    br = 580;
    hö = 480;
    if( !zRObj.setDrawOptions( x, y, br, hö ) )
    {
        zRObj.releaseAlpha();
        return;
    }
    if( geladen == 2 )
    {
        zRObj.setAlpha( alpha );
        if( beschreibung )
            beschreibung->render( zRObj );
        zRObj.releaseAlpha();
    }
    zRObj.releaseDrawOptions();
    zRObj.releaseAlpha();
}

// constant
int KarteDaten::getKarteId() const
{
    return karteId;
}

bool KarteDaten::istausgewählt() const
{
    return ausgewählt;
}

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

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

// Inhalt der KarteAuswahlFenster Klasse aus KarteAuswahl.h
// Konstruktor
KarteAuswahlFenster::KarteAuswahlFenster( Schrift *zSchrift )
{
    schrift = zSchrift->getThis();
    tr = new TextRenderer( schrift->getThis() );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 760, 500 );
    members = new RCArray< KarteDaten >();
    anzahl = 0;
    animation = 0;
    auswahl = -1;
    tickVal = 0;
    seite = 0;
    pos = Punkt( 10, 10 );
    gr = Punkt( 780, 430 );
    spielId = 0;
    rend = 0;
    alpha = 0;
}

// Destruktor
KarteAuswahlFenster::~KarteAuswahlFenster()
{
    if( schrift )
        schrift->release();
    if( rahmen )
        rahmen->release();
    if( members )
        members->release();
    tr->release();
}

// nicht constant
void KarteAuswahlFenster::setSpielId( int id )
{
    spielId = id;
    members->leeren();
    anzahl = 0;
    start();
}

void KarteAuswahlFenster::setSichtbar( bool sichtbar )
{
    if( sichtbar )
    {
        animation |= 0x1;
        start();
    }
    else
    {
        auswahl = -1;
        for( int i = seite * 4; i >= 0 && i < anzahl && i < seite * 4 + 4; i++ )
            members->z( i )->setSichtbar( 0 );
        animation &= ~0x1;
    }
    rend = 1;
}

void KarteAuswahlFenster::blättern( bool oben )
{
    for( int i = seite * 4; i >= 0 && i < anzahl && i < seite * 4 + 4; i++ )
        members->z( i )->setSichtbar( 0 );
    seite += oben ? 1 : -1;
    for( int i = seite * 4; i >= 0 && i < anzahl && i < seite * 4 + 4; i++ )
    {
        members->z( i )->setPosition( i % 4 );
        members->z( i )->setSichtbar( 1 );
    }
    auswahl = -1;
    rend = 1;
}

void KarteAuswahlFenster::updateListe()
{
    if( run )
        return;
    start();
}

void KarteAuswahlFenster::thread()
{
    Array< int > *liste = infoClient->getAccountKarteListe( spielId );
    if( !liste )
    {
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( infoClient->getLetzterFehler() ),
                                                      new Text( "Ok" ), 0 );
        run = 0;
        return;
    }
    int anz = liste->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        bool gefunden = 0;
        for( int j = 0; j < anzahl; j++ )
        {
            KarteDaten *tmp = members->z( j );
            if( liste->hat( i ) && tmp->getKarteId() == liste->get( i ) )
            {
                gefunden = 1;
                break;
            }
        }
        if( !gefunden )
        {
            KarteDaten *tmp = new KarteDaten( schrift, liste->hat( i ) ? liste->get( i ) : 0 );
            members->add( tmp, anzahl );
            anzahl++;
        }
    }
    if( liste )
        liste->release();
    for( int i = 0; i < anzahl; i++ )
        members->z( i )->updateErlaubt();
    for( int i = seite * 4; i < anzahl && i >= 0 && i < seite * 4 + 4; i++ )
    {
        members->z( i )->setPosition( i % 4 );
        members->z( i )->setSichtbar();
    }
    rend = 1;
    run = 0;
}

bool KarteAuswahlFenster::tick( double tickVal )
{
    for( int i = 0; i < anzahl; i++ )
        rend |= members->z( i )->tick( tickVal );
    this->tickVal += tickVal * 750;
    int val = ( int )this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 25 )
        val = 25;
    this->tickVal -= val;
    if( ( animation | 0x1 ) == animation ) // sichtbar
    {
        if( alpha < 255 )
        {
            if( alpha + val >= 255 )
            {
                alpha = 255;
                for( int i = seite * 4; i < anzahl && i >= 0 && i < seite * 4 + 4; i++ )
                {
                    members->z( i )->setPosition( i % 4 );
                    members->z( i )->setSichtbar( 1 );
                }
            }
            else
                alpha += val;
            rend = 1;
        }
    }
    else // unsichtbar
    {
        if( alpha > 0 )
        {
            if( alpha - val < 0 )
                alpha = 0;
            else
                alpha -= val;
            rend = 1;
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void KarteAuswahlFenster::doPublicMausEreignis( MausEreignis &me )
{
    if( !members )
        return;
    if( pos.x != 10 )
        return;
    me.mx -= pos.x;
    me.my -= pos.y;
    for( int i = 0; i < anzahl; i++ )
        members->z( i )->doPublicMausEreignis( me );
    if( me.mx < 0 || me.my < 0 )
    {
        me.mx += pos.x;
        me.my += pos.y;
        return;
    }
    if( me.mx > 200 || me.my > getAnzahlAufSeite() * 100 )
    {
        me.mx += pos.x;
        me.my += pos.y;
        return;
    }
    if( me.id == ME_RLinks )
    {
        int treffer = me.my / 100 + seite * 4;
        if( treffer >= anzahl )
        {
            me.mx += pos.x;
            me.my += pos.y;
            return;
        }
        if( treffer == auswahl )
        {
            me.mx += pos.x;
            me.my += pos.y;
            return;
        }
        if( auswahl >= 0 )
            members->z( auswahl )->setAuswahl( 0 );
        members->z( treffer )->setAuswahl( 1 );
        auswahl = treffer;
        rend = 1;
    }
    me.mx += pos.x;
    me.my += pos.y;
}

void KarteAuswahlFenster::render( Bild &zrObj )
{
    int x = pos.x;
    int y = pos.y;
    int br = gr.x;
    int hö = gr.y;
    if( !zrObj.setDrawOptions( x, y, br, hö ) )
        return;
    zrObj.setAlpha( alpha );
    rahmen->setSize( br, hö );
    rahmen->render( zrObj );
    int rbr = rahmen->getRBreite();
    if( !zrObj.setDrawOptions( rbr, rbr, br - rbr * 2, hö - rbr * 2 ) )
    {
        zrObj.releaseDrawOptions();
        zrObj.releaseAlpha();
        return;
    }
    for( int i = seite * 4; i >= 0 && i < anzahl && i < seite * 4 + 4; i++ )
        members->z( i )->render( zrObj );
    zrObj.releaseDrawOptions();
    if( !anzahl )
    {
        Text t = "Dieser Account besitzt momentan noch keine Karten für dieses Spiel.\nBesuche den Shop um neue Karten zu erwerben!";
        tr->setSchriftSize( 12 );
        tr->renderText( 10, 10, t, zrObj, 0xFFFFFFFF );
    }
    zrObj.releaseDrawOptions();
    zrObj.releaseAlpha();
}

// constant
int KarteAuswahlFenster::getAnzahl() const
{
    return anzahl;
}

int KarteAuswahlFenster::getSeiteAnzahl() const
{
    return ( anzahl / 4.0 == anzahl / 4 ) ? ( anzahl / 4 ) : ( anzahl / 4 + 1 );
}

int KarteAuswahlFenster::getSeite() const
{
    return seite;
}

int KarteAuswahlFenster::getAnzahlAufSeite() const
{
    return ( anzahl < seite * 4 + 4 ) ? ( anzahl - seite * 4 ) : 4;
}

bool KarteAuswahlFenster::hatAuswahl() const
{
    return auswahl != -1;
}

KarteDaten *KarteAuswahlFenster::getAuswahl() const
{
    return members->get( auswahl );
}

// löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
Thread *KarteAuswahlFenster::release()
{
    if( ref == 2 && run )
    {
        warteAufThread( 5000 );
        ende();
    }
    return Thread::release();
}