KSG-Client/KSGClient/Leser/KartenLeser.cpp

#include "KartenLeser.h"
#include "..\Global\Variablen.h"
#include <Datei.h>
#include <DateiSystem.h>
#include <KSGTDatei.h>
#include <Bild.h>
#include <Punkt.h>

KartenLeser KartenLeser::instance;

KartenLeser *KartenLeser::getInstance()
{
    return instance.getThis();
}

void KartenLeser::cleanUp()
{
    instance = KartenLeser();
}

KartenLeser &KartenLeser::operator=( const KartenLeser &l )
{
    if( kartenClient )
        kartenClient->release();
    letzterFehler->release();
    letzterFehler = new Text( l.letzterFehler->getText() );
    kartenClient = 0;
    karteId = 0;
    ref = 1;
    return *this;
}

// Inhalt der KartenLeser Klasse aus KartenLeser.h
// Konstruktor
KartenLeser::KartenLeser()
{
    letzterFehler = new Text( "" );
    kartenClient = 0;
    karteId = 0;
    ref = 1;
}

// Destruktor
KartenLeser::~KartenLeser()
{
    if( kartenClient )
        kartenClient->release();
    letzterFehler->release();
}

// nicht constant
void KartenLeser::setKarteId( int karteId )
{
    cs.lock();
    this->karteId = karteId;
    if( kartenClient )
        kartenClient->release();
    kartenClient = infoClient->createKartenServerClient( karteId );
    cs.unlock();
}

void KartenLeser::lock()
{
    cs.lock();
}

void KartenLeser::unlock()
{
    cs.unlock();
}

// constant
Bild *KartenLeser::getKartenTitelBild( Schrift *zSchrift )
{
    bool ok = 1;
    int port = 0;
    Text ip;
    cs.lock();
    if( !kartenClient->verbinde() )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        ok = 0;
    }
    if( !kartenClient->downloadKarteTitel( karteId ) )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        ok = 0;
    }
    kartenClient->trenne( 0 );
    cs.unlock();
    Bild *ret = 0;
    if( ok )
    {
        Text *pfad = getKartePfad();
        pfad->append( "titel.ltdb" );
        LTDBDatei *datei = new LTDBDatei();
        datei->setDatei( pfad );
        datei->leseDaten( 0 );
        ret = datei->laden( 0, datei->zBildListe()->get( 0 ) );
        datei->release();
    }
    if( !ret )
    {
        ret = new Bild();
        ret->neuBild( 200, 100, 0xFF000000 );
        zSchrift->lock();
        zSchrift->setSchriftSize( 12 );
        zSchrift->setDrawPosition( 10, 10 );
        Text *kn = getKarteName();
        zSchrift->renderText( kn, *ret, 0xFFFFFFFF );
        kn->release();
        zSchrift->unlock();
    }
    return ret;
}

Bild *KartenLeser::getKartenVorschauBild()
{
    int port = 0;
    Text ip;
    cs.lock();
    if( !kartenClient->verbinde() )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        return 0;
    }
    if( !kartenClient->downloadKarteMinimap( karteId ) )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        return 0;
    }
    kartenClient->trenne( 0 );
    cs.unlock();
    Text *pfad = getKartePfad();
    pfad->append( "minimap.ltdb" );
    Bild *ret = 0;
    LTDBDatei *datei = new LTDBDatei();
    datei->setDatei( pfad );
    datei->leseDaten( 0 );
    ret = datei->laden( 0, datei->zBildListe()->get( 0 ) );
    datei->release();
    if( !ret )
        letzterFehler->append( "Bild nicht gefunden." );
    return ret;
}

Bild *KartenLeser::getLadeBild()
{
    int port = 0;
    Text ip;
    cs.lock();
    if( !kartenClient->verbinde() )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        return 0;
    }
    if( !kartenClient->downloadKarteLadebild( karteId ) )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        return 0;
    }
    kartenClient->trenne( 0 );
    cs.unlock();
    Text *pfad = getKartePfad();
    pfad->append( "ladebild.ltdb" );
    Bild *ret = 0;
    LTDBDatei *datei = new LTDBDatei();
    datei->setDatei( pfad );
    datei->leseDaten( 0 );
    ret = datei->laden( 0, datei->zBildListe()->get( 0 ) );
    datei->release();
    if( !ret )
        letzterFehler->append( "Bild nicht gefunden." );
    return ret;
}

bool KartenLeser::getKartenBeschreibung()
{
    int port = 0;
    Text ip;
    cs.lock();
    if( !kartenClient->verbinde() )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        return 0;
    }
    if( !kartenClient->downloadKarteBeschreibung( karteId ) )
    {
        letzterFehler->setText( kartenClient->getLetzterFehler() );
        return 0;
    }
    kartenClient->trenne( 0 );
    cs.unlock();
    return 1;
}

int KartenLeser::getSpielId() const
{
    if( !karteId )
    {
        letzterFehler->setText( "Karte Id ist nicht gesetzt." );
        return 0;
    }
    if( infoClient )
    {
        int id = infoClient->getSpielId( karteId );
        if( !id )
            letzterFehler->setText( infoClient->getLetzterFehler() );
        return id;
    }
    else
        letzterFehler->setText( "Informations Klient ist nicht Initialisiert." );
    return 0;
}

int KartenLeser::getKarteId() const
{
    return karteId;
}

Text *KartenLeser::getSpielName() const
{
    if( infoClient )
    {
        int id = getSpielId();
        if( !id )
            return 0;
        Text *name = infoClient->getSpielName( id );
        if( !name )
            letzterFehler->setText( infoClient->getLetzterFehler() );
        return name;
    }
    else
        letzterFehler->setText( "Informations Klient ist nicht Initialisiert." );
    return 0;
}

Text *KartenLeser::getSpielPfad() const
{
    int sId = getSpielId();
    int dg = infoClient->getDateiGruppeIdVonSpiel( sId );
    Text *pfad = infoClient->getDateiGruppePfad( dg );
    if( !pfad )
    {
        letzterFehler->setText( "Der Pfad des Spieles konnte nicht ermittelt werden." );
        return 0;
    }
    pfad->append( "/" );
    return pfad;
}

Text *KartenLeser::getKarteName() const
{
    if( !karteId )
    {
        letzterFehler->setText( "Karte Id ist nicht gesetzt." );
        return 0;
    }
    if( infoClient )
    {
        Text *name = infoClient->getKarteName( karteId );
        if( !name )
            letzterFehler->setText( infoClient->getLetzterFehler() );
        return name;
    }
    else
        letzterFehler->setText( "Informations Klient ist nicht Initialisiert." );
    return 0;
}

Text *KartenLeser::getKartePfad() const
{
    Text *pf = new Text( "data/tmp/Karten/" );
    pf->append( karteId );
    pf->append( "/" );
    return pf;
}

char *KartenLeser::getLetzterFehler() const
{
    return letzterFehler->getText();
}

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

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