KSG-Client/KSGClient/NachLogin/Spiele/Gruppe/Gruppe.cpp

#include "Gruppe.h"
#include <Punkt.h>
#include <Rahmen.h>
#include "..\..\..\Global\Variablen.h"
#include "..\..\..\Global\Initialisierung.h"
#include "..\..\..\Leser\KartenLeser.h"
#include <DateiSystem.h>
#include <AlphaFeld.h>
#include <ToolTip.h>
#include <Globals.h>

// Inhalt der GruppeEinladungAccount Klasse aus Gruppe.h
// Konstruktor
GruppeEinladungAccount::GruppeEinladungAccount( Schrift *zSchrift )
{
    Bild *nachrichtBild = bilder->get( "data/client/bilder/chat.ltdb/nachricht.png" );
    Bild *neuSendenBild = bilder->get( "data/client/bilder/chat.ltdb/neusenden.png" );
    Bild *entfernenBild = bilder->get( "data/client/bilder/chat.ltdb/entfernen.png" );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    auswahl = new AlphaFeld();
    auswahl->setFarbe( 0x0000FF00 );
    auswahl->setStrength( -2 );
    auswahl->setPosition( 1, 1 );
    name = initTextFeld( 0, 5, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
    nachrichtSenden = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    nachrichtSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    nachrichtSenden->setHintergrundBildZ( nachrichtBild );
    initToolTip( nachrichtSenden, "Nachricht senden.", zSchrift, hauptScreen );
    erneutSenden = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    erneutSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    erneutSenden->setHintergrundBildZ( neuSendenBild );
    initToolTip( erneutSenden, "Einladung erneut senden.", zSchrift, hauptScreen );
    einladungAbbrechen = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    einladungAbbrechen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    einladungAbbrechen->setHintergrundBildZ( entfernenBild );
    initToolTip( einladungAbbrechen, "Einladung abbrechen.", zSchrift, hauptScreen );
    status = 0;
    knopfX = 500;
    tickVal = 0;
    mausIn = 0;
    remove = 0;
    gruppeId = 0;
    accountId = 0;
    admin = 0;
    höhe = 0;
    animation = 0x1;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeEinladungAccount::~GruppeEinladungAccount()
{
    rahmen->release();
    auswahl->release();
    name->release();
    nachrichtSenden->release();
    erneutSenden->release();
    einladungAbbrechen->release();
}

// nicht constant
void GruppeEinladungAccount::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
}

void GruppeEinladungAccount::setAccountId( int id )
{
    this->accountId = id;
    name->setText( infoClient->getSpielerName( id ) );
    rend = 1;
}

void GruppeEinladungAccount::setSize( int br )
{
    if( this->br != br )
        rend = 1;
    this->br = br;
    if( knopfX == 500 )
    {
        knopfX = br;
        rend = 1;
    }
}

void GruppeEinladungAccount::setAbgelehnt()
{
    status = 1;
}

void GruppeEinladungAccount::setAngenommen()
{
    status = 2;
}

void GruppeEinladungAccount::setRemove()
{
    animation &= ~0x1;
}

void GruppeEinladungAccount::setAdmin( int admin )
{
    this->admin = admin;
}

bool GruppeEinladungAccount::tick( double tickVal )
{
    rend |= name->tick( tickVal );
    rend |= nachrichtSenden->tick( tickVal );
    rend |= erneutSenden->tick( tickVal );
    rend |= einladungAbbrechen->tick( tickVal );
    this->tickVal += tickVal * 100;
    int val = (int)this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 4 )
        val = 4;
    this->tickVal -= val;
    if( ( animation | 0x1 ) == animation )
    {
        if( höhe < 30 )
        {
            höhe += val;
            if( höhe > 30 )
                höhe = 30;
            rend = 1;
        }
    }
    else
    {
        if( höhe > 0 )
        {
            höhe -= val;
            if( höhe < 0 )
                höhe = 0;
            rend = 1;
        }
    }
    if( mausIn )
    {
        if( admin == loginClient->getAccountId() && !status )
        {
            if( knopfX > br - 60 )
            {
                knopfX -= val;
                if( knopfX < br - 60 )
                    knopfX = br - 60;
                rend = 1;
            }
        }
        else if( admin == loginClient->getAccountId() && status != 2 )
        {
            if( knopfX > br - 40 )
            {
                knopfX -= val;
                if( knopfX < br - 40 )
                    knopfX = br - 40;
                rend = 1;
            }
        }
        else
        {
            if( knopfX > br - 20 )
            {
                knopfX -= val;
                if( knopfX < br - 20 )
                    knopfX = br - 20;
                rend = 1;
            }
        }
    }
    else
    {
        if( knopfX < br )
        {
            knopfX += val;
            if( knopfX > br )
                knopfX = br;
            rend = 1;
        }
    }
    switch( status )
    {
    case 1:
        if( 1 )
        {
            int r = ( rahmen->getFarbe() >> 16 ) & 0xFF;
            int g = ( rahmen->getFarbe() >> 8 ) & 0xFF;
            int b = rahmen->getFarbe() & 0xFF;
            if( r < 255 )
            {
                r += val;
                if( r > 255 )
                    r = 255;
                rend = 1;
            }
            if( g > 0 )
            {
                g -= val;
                if( g < 0 )
                    g = 0;
                rend = 1;
            }
            if( b > 0 )
            {
                b -= val;
                if( b < 0 )
                    b = 0;
                rend = 1;
            }
            int f = ( ( r << 16 ) & 0xFF0000 ) | ( ( g << 8 ) & 0xFF00 ) | ( b & 0xFF );
            rahmen->setFarbe( ( rahmen->getFarbe() & 0xFF000000 ) | f );
            auswahl->setFarbe( ( auswahl->getFarbe() & 0xFF000000 ) | f );
        }
        break;
    case 2:
        if( 1 )
        {
            int r = ( rahmen->getFarbe() >> 16 ) & 0xFF;
            int g = ( rahmen->getFarbe() >> 8 ) & 0xFF;
            int b = rahmen->getFarbe() & 0xFF;
            if( r > 0 )
            {
                r -= val;
                if( r < 0 )
                    r = 0;
                rend = 1;
            }
            if( g < 255 )
            {
                g += val;
                if( g > 255 )
                    g = 255;
                rend = 1;
            }
            if( b > 0 )
            {
                b -= val;
                if( b < 0 )
                    b = 0;
                rend = 1;
            }
            int f = ( ( r << 16 ) & 0xFF0000 ) | ( ( g << 8 ) & 0xFF00 ) | ( b & 0xFF );
            rahmen->setFarbe( ( rahmen->getFarbe() & 0xFF000000 ) | f );
            auswahl->setFarbe( ( auswahl->getFarbe() & 0xFF000000 ) | f );
        }
        break;
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeEinladungAccount::doPublicMausEreignis( MausEreignis & me )
{
    if( me.mx < 0 || me.my < 0 || me.mx > br || me.my > höhe )
        mausIn = 0;
    else
        mausIn = 1;
    bool ak = !me.verarbeitet;
    nachrichtSenden->doPublicMausEreignis( me );
    int aktion = ( me.verarbeitet && ak ) ? 1 : 0;
    erneutSenden->doPublicMausEreignis( me );
    aktion = ( me.verarbeitet && ak && !aktion ) ? 2 : aktion;
    einladungAbbrechen->doPublicMausEreignis( me );
    aktion = ( me.verarbeitet && ak && !status && !aktion ) ? 3 : aktion;
    if( me.id != ME_RLinks || !mausIn )
        return;
    switch( aktion )
    {
    case 1:
        nachLogin->zChatLeiste()->addChat( accountId, 0 );
        break;
    case 2:
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        else
        {
            if( !anmeldungClient->gruppeSpielerEinladen( accountId, gruppeId ) )
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
        break;
    case 3:
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        else
        {
            if( !anmeldungClient->gruppeEinladungAbbrechen( accountId, gruppeId ) )
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
        break;
    }
}

void GruppeEinladungAccount::render( int y, Bild & zrObj )
{
    if( !zrObj.setDrawOptions( 0, y, br, höhe ) )
        return;
    rahmen->setSize( br, höhe );
    rahmen->render( zrObj );
    int rbr = rahmen->getRBreite();
    if( !zrObj.setDrawOptions( rbr, rbr, br - rbr * 2, höhe - rbr * 2 ) )
    {
        zrObj.releaseDrawOptions();
        return;
    }
    auswahl->setSize( br - rbr * 2, höhe - rbr * 2 );
    auswahl->render( zrObj );
    nachrichtSenden->setPosition( knopfX, 5 );
    nachrichtSenden->render( zrObj );
    erneutSenden->setPosition( knopfX + 20, 5 );
    erneutSenden->render( zrObj );
    einladungAbbrechen->setPosition( knopfX + 40, 5 );
    einladungAbbrechen->render( zrObj );
    name->render( zrObj );
    zrObj.releaseDrawOptions();
    zrObj.releaseDrawOptions();
}

// constant
bool GruppeEinladungAccount::getRemove() const
{
    return remove;
}

int GruppeEinladungAccount::getAccountId() const
{
    return accountId;
}

int GruppeEinladungAccount::getHeight() const
{
    return höhe;
}

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

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

// Inhalt der GruppeEinladungListe Klasse aus Gruppe.h
// Konstruktor
GruppeEinladungListe::GruppeEinladungListe( Schrift * zSchrift )
{
    schrift = zSchrift->getThis();
    Bild *maximierenBild = bilder->get( "data/client/bilder/chat.ltdb/maximieren.png" );
    pos = Punkt( 200, 0 );
    gr = Punkt( 150, 350 );
    rahmen = new LRahmen();
    rahmen->setRamenBreite( 1 );
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setSize( 150, 350 );
    einladenName = initTextFeld( 5, 5, 115, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    initToolTip( einladenName, "Name des Spielers den du einladen möchtest.", zSchrift, hauptScreen );
    einladen = initKnopf( 125, 5, 20, 20, 0, 0, "" );
    einladen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    einladen->setHintergrundBildZ( maximierenBild );
    initToolTip( einladen, "Diesen Spieler einladen.", zSchrift, hauptScreen );
    scroll = new VScrollBar();
    accounts = new RCArray< GruppeEinladungAccount >();
    einladungHöhe = 0;
    tickVal = 0;
    anzahl = 0;
    gruppeId = 0;
    admin = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeEinladungListe::~GruppeEinladungListe()
{
    rahmen->release();
    einladenName->release();
    einladen->release();
    scroll->release();
    accounts->release();
    schrift->release();
}

// nicht constant
void GruppeEinladungListe::reset()
{
    einladenName->setText( "" );
    scroll->update( 0, 0 );
    einladungHöhe = 0;
    tickVal = 0;
    accounts->leeren();
    anzahl = 0;
    gruppeId = 0;
    admin = 0;
    rend = 1;
}

void GruppeEinladungListe::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
    for( int i = 0; i < anzahl; i++ )
        accounts->z( i )->setGruppeId( gruppeId );
}

void GruppeEinladungListe::addAccount( int id )
{
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp->getAccountId() == id )
            tmp->setRemove();
    }
    GruppeEinladungAccount * tmp = new GruppeEinladungAccount( schrift );
    tmp->setGruppeId( gruppeId );
    tmp->setAccountId( id );
    tmp->setAdmin( admin );
    accounts->add( tmp, anzahl );
    anzahl++;
    rend = 1;
}

void GruppeEinladungListe::setAbgelehnt( int id )
{
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp && tmp->getAccountId() == id )
        {
            tmp->setAbgelehnt();
            break;
        }
    }
}

void GruppeEinladungListe::setAngenommen( int id )
{
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp && tmp->getAccountId() == id )
        {
            tmp->setAngenommen();
            break;
        }
    }
}

void GruppeEinladungListe::remove( int id )
{
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp && tmp->getAccountId() == id )
        {
            tmp->setRemove();
            break;
        }
    }
}

void GruppeEinladungListe::setAdmin( int admin )
{
    this->admin = admin;
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp )
            tmp->setAdmin( admin );
    }
}

bool GruppeEinladungListe::tick( double tickVal )
{
    rend |= einladenName->tick( tickVal );
    rend |= einladen->tick( tickVal );
    rend |= scroll->getRend();
    this->tickVal += tickVal * 100;
    int val = (int)this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 4 )
        val = 4;
    this->tickVal -= val;
    if( admin == loginClient->getAccountId() )
    {
        if( einladungHöhe < 30 )
        {
            einladungHöhe += val;
            if( einladungHöhe > 30 )
                einladungHöhe = 30;
            rend = 1;
        }
    }
    else
    {
        if( einladungHöhe > 0 )
        {
            einladungHöhe -= val;
            if( einladungHöhe < 0 )
                einladungHöhe = 0;
            rend = 1;
        }
    }
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp )
            rend |= tmp->tick( tickVal );
    }
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( !tmp->getHeight() )
        {
            accounts->remove( i );
            anzahl--;
            rend = 1;
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeEinladungListe::doPublicMausEreignis( MausEreignis & me )
{
    int tmpX = me.mx;
    int tmpY = me.my;
    me.mx -= pos.x;
    me.my -= pos.y;
    if( einladungHöhe == 30 )
    {
        einladenName->doPublicMausEreignis( me );
        bool ak = !me.verarbeitet;
        einladen->doPublicMausEreignis( me );
        if( me.verarbeitet && ak )
        {
            if( me.id == ME_RLinks )
            {
                if( einladenName->zText()->getLength() )
                {
                    int accountId = infoClient->getAccountId( einladenName->zText()->getText() );
                    if( accountId )
                    {
                        if( !anmeldungClient )
                            anmeldungClient = mainClient->createAnmeldungServerClient();
                        if( !anmeldungClient )
                        {
                            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                                          new Text( "Ok" ), 0 );
                        }
                        if( !anmeldungClient->verbinde() )
                        {
                            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                          new Text( "Ok" ), 0 );
                        }
                        else
                        {
                            if( !anmeldungClient->gruppeSpielerEinladen( accountId, gruppeId ) )
                            {
                                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                              new Text( "Ok" ), 0 );
                            }
                            else
                            {
                                einladenName->setText( "" );
                                einladenName->setAuswahl( 0, 0 );
                                rend = 1;
                            }
                            anmeldungClient->trenne( 0 );
                        }
                    }
                    else
                    {
                        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Der Account wurde nicht gefunden." ),
                                                                      new Text( "Ok" ), 0 );
                    }
                }
            }
            return;
        }
    }
    scroll->doMausMessage( 134, 1 + einladungHöhe, 15, 348 - einladungHöhe, me );
    me.my -= einladungHöhe + 1;
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp )
        {
            tmp->doPublicMausEreignis( me );
            if( tmp->getRemove() )
            {
                accounts->remove( i );
                anzahl--;
                rend = 1;
            }
            me.my -= tmp->getHeight();
        }
    }
    me.mx = tmpX;
    me.my = tmpY;
}

void GruppeEinladungListe::doTastaturEreignis( TastaturEreignis & te )
{
    bool b = !te.verarbeitet;
    einladenName->doTastaturEreignis( te );
    if( te.verarbeitet && b && te.id == TE_Release && te.taste == T_Enter )
    {
        if( einladenName->zText()->getLength() )
        {
            int accountId = infoClient->getAccountId( einladenName->zText()->getText() );
            if( accountId )
            {
                if( !anmeldungClient )
                    anmeldungClient = mainClient->createAnmeldungServerClient();
                if( !anmeldungClient )
                {
                    nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                                  new Text( "Ok" ), 0 );
                }
                if( !anmeldungClient->verbinde() )
                {
                    nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                  new Text( "Ok" ), 0 );
                }
                else
                {
                    if( !anmeldungClient->gruppeSpielerEinladen( accountId, gruppeId ) )
                    {
                        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                      new Text( "Ok" ), 0 );
                    }
                    else
                    {
                        einladenName->setText( "" );
                        einladenName->setAuswahl( 0, 0 );
                        rend = 1;
                    }
                    anmeldungClient->trenne( 0 );
                }
            }
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Der Account wurde nicht gefunden." ),
                                                              new Text( "Ok" ), 0 );
            }
        }
    }
}

void GruppeEinladungListe::render( Bild & zRObj )
{
    if( !zRObj.setDrawOptions( pos, gr ) )
        return;
    rahmen->render( zRObj );
    int rbr = rahmen->getRBreite();
    if( einladungHöhe )
    {
        if( zRObj.setDrawOptions( rbr, rbr, gr.x - rbr * 2, einladungHöhe - rbr * 2 ) )
        {
            einladenName->render( zRObj );
            einladen->render( zRObj );
            zRObj.releaseDrawOptions();
        }
    }
    if( !zRObj.setDrawOptions( rbr, einladungHöhe + rbr, gr.x - rbr * 2, gr.y - rbr * 2 ) )
    {
        zRObj.releaseDrawOptions();
        return;
    }
    scroll->render( 134, 0, 15, 348 - einladungHöhe, zRObj );
    int höhe = 0;
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeEinladungAccount *tmp = accounts->z( i );
        if( tmp )
        {
            tmp->setSize( gr.x - 15 - rbr * 2 );
            tmp->render( höhe - scroll->getScroll(), zRObj );
            höhe += tmp->getHeight();
        }
    }
    scroll->update( höhe, gr.y - rbr * 2 - einladungHöhe );
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}

// constant

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

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

// Inhalt der GruppeAccountDaten Klasse aus Gruppe.h
// Konstruktor
GruppeAccountDaten::GruppeAccountDaten( Schrift * zSchrift )
{
    Bild *nachrichtBild = bilder->get( "data/client/bilder/chat.ltdb/nachricht.png" );
    Bild *einladungBild = bilder->get( "data/client/bilder/chat.ltdb/neuerfreund.png" );
    Bild *ansehenBild = bilder->get( "data/client/bilder/chat.ltdb/ansehen.png" );
    Bild *entfernenBild = bilder->get( "data/client/bilder/chat.ltdb/entfernen.png" );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    auswahl = new AlphaFeld();
    auswahl->setFarbe( 0x0000FF00 );
    auswahl->setStrength( -2 );
    auswahl->setPosition( 1, 1 );
    name = initTextFeld( 1, 6, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
    punkte = initTextFeld( 101, 6, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "0p" );
    nachrichtSenden = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    nachrichtSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    nachrichtSenden->setHintergrundBildZ( nachrichtBild );
    initToolTip( nachrichtSenden, "Nachricht senden.", zSchrift, hauptScreen );
    freundEinladung = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    freundEinladung->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    freundEinladung->setHintergrundBildZ( einladungBild );
    initToolTip( freundEinladung, "Freundeseinladung senden.", zSchrift, hauptScreen );
    accountAnsehen = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    accountAnsehen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    accountAnsehen->setHintergrundBildZ( ansehenBild );
    initToolTip( accountAnsehen, "Account ansehen.", zSchrift, hauptScreen );
    kick = initKnopf( 0, 30, 20, 20, 0, 0, "" );
    kick->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    kick->setHintergrundBildZ( entfernenBild );
    initToolTip( kick, "Diesen Spieler kicken.", zSchrift, hauptScreen );
    tickVal = 0;
    mausIn = 0;
    remove = 0;
    gruppeId = 0;
    accountId = 0;
    admin = 0;
    höhe = 0;
    animation = 0x1;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeAccountDaten::~GruppeAccountDaten()
{
    rahmen->release();
    auswahl->release();
    name->release();
    punkte->release();
    nachrichtSenden->release();
    freundEinladung->release();
    accountAnsehen->release();
    kick->release();
}

// nicht constant
void GruppeAccountDaten::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
}

void GruppeAccountDaten::setAccountId( int id )
{
    accountId = id;
    name->setText( infoClient->getSpielerName( id ) );
    punkte->setText( "" );
    punkte->zText()->append( infoClient->getSpielerPunkte( id, infoClient->getSpielId( infoClient->getGruppenKarteId( gruppeId ) ) ) );
    punkte->zText()->append( "p" );
    rend = 1;
}

void GruppeAccountDaten::setSize( int x )
{
    if( br != x )
    {
        br = x;
        rend = 1;
    }
}

void GruppeAccountDaten::entfernen()
{
    animation &= ~0x1;
}

void GruppeAccountDaten::setAdmin( int admin )
{
    this->admin = admin;
    rend = 1;
}

bool GruppeAccountDaten::tick( double tickVal )
{
    rend |= name->tick( tickVal );
    rend |= punkte->tick( tickVal );
    rend |= nachrichtSenden->tick( tickVal );
    rend |= accountAnsehen->tick( tickVal );
    rend |= freundEinladung->tick( tickVal );
    rend |= kick->tick( tickVal );
    this->tickVal += tickVal * 100;
    int val = (int)this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 4 )
        val = 4;
    this->tickVal -= val;
    if( admin == accountId )
    {
        int r = ( auswahl->getFarbe() >> 16 ) & 0xFF;
        if( r < 200 )
        {
            r += val;
            if( r > 200 )
                r = 200;
            auswahl->setFarbe( ( auswahl->getFarbe() & 0xFF00FFFF ) | ( ( r << 16 ) & 0xFF0000 ) );
            rend = 1;
        }
    }
    else
    {
        int r = ( auswahl->getFarbe() >> 16 ) & 0xFF;
        if( r > 0 )
        {
            if( r - val < 0 )
                r = 0;
            else
                r -= val;
            auswahl->setFarbe( ( auswahl->getFarbe() & 0xFF00FFFF ) | ( ( r << 16 ) & 0xFF0000 ) );
            rend = 1;
        }
    }
    if( ( animation | 0x1 ) == animation )
    {
        if( höhe < 30 )
        {
            höhe += val;
            if( höhe > 30 )
                höhe = 30;
            rend = 1;
        }
        if( mausIn )
        {
            if( höhe < 50 )
            {
                höhe += val;
                if( höhe > 50 )
                    höhe = 50;
                rend = 1;
            }
            int a = ( auswahl->getFarbe() >> 24 ) & 0xFF;
            if( a < 50 )
            {
                a += val;
                if( a > 50 )
                    a = 50;
                auswahl->setFarbe( ( ( a << 24 ) & 0xFF000000 ) | ( auswahl->getFarbe() & 0xFFFFFF ) );
                rend = 1;
            }
        }
        else
        {
            if( höhe > 30 )
            {
                höhe -= val;
                if( höhe < 30 )
                    höhe = 30;
                rend = 1;
            }
            int a = ( auswahl->getFarbe() >> 24 ) & 0xFF;
            if( a > 0 )
            {
                if( a - val < 0 )
                    a = 0;
                else
                    a -= val;
                auswahl->setFarbe( ( ( a << 24 ) & 0xFF000000 ) | ( auswahl->getFarbe() & 0xFFFFFF ) );
                rend = 1;
            }
        }
        if( accountId != loginClient->getAccountId() )
        {
            if( nachrichtSenden->getBreite() < 20 )
            {
                nachrichtSenden->setSize( nachrichtSenden->getBreite() + val, nachrichtSenden->getHeight() );
                if( nachrichtSenden->getBreite() > 20 )
                    nachrichtSenden->setSize( 20, nachrichtSenden->getHeight() );
                rend = 1;
            }
        }
        else
        {
            if( nachrichtSenden->getBreite() > 0 )
            {
                nachrichtSenden->setSize( nachrichtSenden->getBreite() - val, nachrichtSenden->getHeight() );
                if( nachrichtSenden->getBreite() < 0 )
                    nachrichtSenden->setSize( 0, nachrichtSenden->getHeight() );
                rend = 1;
            }
        }
        if( accountAnsehen->getBreite() < 20 )
        {
            accountAnsehen->setSize( accountAnsehen->getBreite() + val, accountAnsehen->getHeight() );
            if( accountAnsehen->getBreite() > 20 )
                accountAnsehen->setSize( 20, accountAnsehen->getHeight() );
            rend = 1;
        }
        if( accountId == loginClient->getAccountId() || nachLogin->zFreundesListe()->istFreund( accountId ) )
        {
            if( freundEinladung->getBreite() > 0 )
            {
                freundEinladung->setSize( freundEinladung->getBreite() - val, freundEinladung->getHeight() );
                if( freundEinladung->getBreite() < 0 )
                    freundEinladung->setSize( 0, freundEinladung->getHeight() );
                rend = 1;
            }
        }
        else
        {
            if( freundEinladung->getBreite() < 20 )
            {
                freundEinladung->setSize( freundEinladung->getBreite() + val, freundEinladung->getHeight() );
                if( freundEinladung->getBreite() > 20 )
                    freundEinladung->setSize( 20, freundEinladung->getHeight() );
                rend = 1;
            }
        }
        if( accountId == loginClient->getAccountId() || admin != loginClient->getAccountId() )
        {
            if( kick->getBreite() > 0 )
            {
                kick->setSize( kick->getBreite() - val, kick->getHeight() );
                if( kick->getBreite() < 0 )
                    kick->setSize( 0, kick->getHeight() );
                rend = 1;
            }
        }
        else
        {
            if( kick->getBreite() < 20 )
            {
                kick->setSize( kick->getBreite() + val, kick->getHeight() );
                if( kick->getBreite() > 20 )
                    kick->setSize( 20, kick->getHeight() );
                rend = 1;
            }
        }
    }
    else
    {
        if( höhe > 0 )
        {
            höhe -= val;
            if( höhe <= 0 )
            {
                höhe = 0;
                remove = 1;
            }
            rend = 1;
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeAccountDaten::doPublicMausEreignis( MausEreignis & me )
{
    if( me.mx < 0 || me.my < 0 || me.mx > br || me.my > höhe )
        mausIn = 0;
    else
        mausIn = 1;
    bool ak = !me.verarbeitet;
    nachrichtSenden->doPublicMausEreignis( me );
    int aktion = ( me.verarbeitet && ak ) ? 1 : 0;
    accountAnsehen->doPublicMausEreignis( me );
    aktion = ( me.verarbeitet && ak && !aktion ) ? 2 : aktion;
    freundEinladung->doPublicMausEreignis( me );
    aktion = ( me.verarbeitet && ak && !aktion ) ? 3 : aktion;
    kick->doPublicMausEreignis( me );
    aktion = ( me.verarbeitet && ak && !aktion ) ? 4 : aktion;
    if( me.id != ME_RLinks )
        return;
    switch( aktion )
    {
    case 1:
        nachLogin->zChatLeiste()->addChat( accountId, 0 );
        break;
    case 2:
        if( nachLogin->zAccountAnsehenFenster()->setSpielerDetails( accountId, 2 ) )
        {
            MausEreignis me = { ME_RLinks, 0, 0, 0, 1 };
            nachLogin->zTitelLeiste()->druckAccountAnsehen( me );
        }
        break;
    case 3:
        chatClient->freundesAnfrage( accountId );
        break;
    case 4:
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        else
        {
            if( !anmeldungClient->kickSpielerAusGruppe( accountId, gruppeId ) )
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
        break;
    }
}

void GruppeAccountDaten::render( int y, Bild & zrObj )
{
    if( !zrObj.setDrawOptions( 0, y, br, höhe ) )
        return;
    rahmen->setSize( br, höhe );
    rahmen->render( zrObj );
    int rbr = rahmen->getRBreite();
    auswahl->setPosition( rbr, rbr );
    auswahl->setSize( br - rbr * 2, höhe - rbr * 2 );
    auswahl->render( zrObj );
    name->render( zrObj );
    punkte->render( zrObj );
    if( !zrObj.setDrawOptions( rbr, rbr, br - rbr * 2, höhe - rbr * 2 ) )
    {
        zrObj.releaseDrawOptions();
        return;
    }
    int b = kick->getBreite();
    kick->setPosition( br - rbr - b, 30 );
    kick->render( zrObj );
    b += freundEinladung->getBreite();
    freundEinladung->setPosition( br - rbr - b, 30 );
    freundEinladung->render( zrObj );
    b += accountAnsehen->getBreite();
    accountAnsehen->setPosition( br - rbr - b, 30 );
    accountAnsehen->render( zrObj );
    b += nachrichtSenden->getBreite();
    nachrichtSenden->setPosition( br - rbr - b, 30 );
    nachrichtSenden->render( zrObj );
    zrObj.releaseDrawOptions();
    zrObj.releaseDrawOptions();
}

// constant
bool GruppeAccountDaten::getRemove() const
{
    return remove;
}

int GruppeAccountDaten::getAccountId() const
{
    return accountId;
}

int GruppeAccountDaten::getHeight() const
{
    return höhe;
}

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

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

// Inhalt der GruppeAccountListe Klasse aus Gruppe.h
// Konstruktor
GruppeAccountListe::GruppeAccountListe( Schrift * zSchrift )
{
    schrift = zSchrift->getThis();
    pos = Punkt( 0, 0 );
    gr = Punkt( 200, 350 );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 200, 350 );
    scroll = new VScrollBar();
    accounts = new RCArray< GruppeAccountDaten >();
    anzahl = 0;
    gruppeId = 0;
    admin = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeAccountListe::~GruppeAccountListe()
{
    schrift->release();
    rahmen->release();
    scroll->release();
    accounts->release();
}

// nicht constant
void GruppeAccountListe::reset()
{
    accounts->leeren();
    anzahl = 0;
    gruppeId = 0;
    admin = 0;
    rend = 1;
}

void GruppeAccountListe::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
    for( int i = 0; i < anzahl; i++ )
        accounts->z( i )->setGruppeId( gruppeId );
}

void GruppeAccountListe::addAccount( int id )
{
    GruppeAccountDaten *tmp = new GruppeAccountDaten( schrift );
    tmp->setGruppeId( gruppeId );
    tmp->setAccountId( id );
    tmp->setAdmin( admin );
    accounts->add( tmp, anzahl );
    anzahl++;
    rend = 1;
}

void GruppeAccountListe::removeAccount( int id )
{
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeAccountDaten *tmp = accounts->z( i );
        if( tmp && tmp->getAccountId() == id )
        {
            tmp->entfernen();
            break;
        }
    }
}

void GruppeAccountListe::setAdmin( int admin )
{
    this->admin = admin;
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeAccountDaten *tmp = accounts->z( i );
        if( tmp )
            tmp->setAdmin( admin );
    }
}

bool GruppeAccountListe::tick( double tickVal )
{
    rend |= scroll->getRend();
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeAccountDaten *tmp = accounts->z( i );
        if( tmp )
            rend |= tmp->tick( tickVal );
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeAccountListe::doPublicMausEreignis( MausEreignis & me )
{
    int tmpX = me.mx;
    int tmpY = me.my;
    me.mx -= pos.x;
    me.my -= pos.y;
    scroll->doMausMessage( 184, 1, 15, 248, me );
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeAccountDaten *tmp = accounts->z( i );
        if( tmp )
        {
            tmp->doPublicMausEreignis( me );
            me.my -= tmp->getHeight();
            if( tmp->getRemove() )
            {
                accounts->remove( i );
                anzahl--;
                i--;
                rend = 1;
            }
        }
    }
    me.mx = tmpX;
    me.my = tmpY;
}

void GruppeAccountListe::render( Bild & zRObj )
{
    if( !zRObj.setDrawOptions( pos, gr ) )
        return;
    rahmen->render( zRObj );
    int rbr = rahmen->getRBreite();
    scroll->render( gr.x - 15 - rbr, 1, 15, gr.y - rbr * 2, zRObj );
    if( !zRObj.setDrawOptions( rbr, rbr, gr.x - rbr * 2, gr.y - rbr * 2 ) )
    {
        zRObj.releaseDrawOptions();
        return;
    }
    int höhe = 0;
    for( int i = 0; i < anzahl; i++ )
    {
        GruppeAccountDaten *tmp = accounts->z( i );
        if( tmp )
        {
            tmp->setSize( gr.x - 15 - rbr * 2 );
            tmp->render( höhe - scroll->getScroll(), zRObj );
            höhe += tmp->getHeight();
        }
    }
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
    scroll->update( höhe, gr.y - rbr * 2 );
}

// constant

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

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

// Inhalt der GruppeChat Klasse aus Gruppe.h
// Konstruktor
GruppeChat::GruppeChat( Schrift * zSchrift )
{
    Bild *sendenBild = bilder->get( "data/client/bilder/chat.ltdb/senden.png" );
    pos = Punkt( 0, 350 );
    gr = Punkt( 750, 200 );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 750, 200 );
    nachricht = initTextFeld( 2, 176, 724, 20, zSchrift, TextFeld::Style::TextFeld, "" );
    initToolTip( nachricht, "Nachricht an die Gruppe senden.", zSchrift, hauptScreen );
    senden = initKnopf( 726, 176, 20, 20, 0, 0, "" );
    senden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    senden->setHintergrundBildZ( sendenBild );
    initToolTip( senden, "Diese Nachricht an die Gruppe senden.", zSchrift, hauptScreen );
    verlauf = initTextFeld( 2, 2, 746, 174, zSchrift, TextFeld::Style::TextGebiet, "" );
    verlauf->removeStyle( TextFeld::Style::Erlaubt );
    verlauf->updateVScroll();
    verlauf->setVertikalKlickScroll( 5 );
    gruppeId = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeChat::~GruppeChat()
{
    rahmen->release();
    nachricht->release();
    senden->release();
    verlauf->release();
}

// nicht constant
void GruppeChat::reset()
{
    gruppeId = 0;
    verlauf->setText( "" );
    verlauf->updateVScroll();
    nachricht->setText( "" );
    rend = 1;
}

void GruppeChat::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
}

void GruppeChat::gruppeNachricht( const char *nachricht )
{
    verlauf->addZeile( nachricht );
    verlauf->updateVScroll();
    rend = 1;
}

bool GruppeChat::tick( double tickVal )
{
    rend |= verlauf->tick( tickVal );
    rend |= nachricht->tick( tickVal );
    rend |= senden->tick( tickVal );
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeChat::doPublicMausEreignis( MausEreignis & me )
{
    me.mx -= pos.x;
    me.my -= pos.y;
    verlauf->doPublicMausEreignis( me );
    nachricht->doPublicMausEreignis( me );
    bool ak = !me.verarbeitet;
    senden->doPublicMausEreignis( me );
    int aktion = ( me.verarbeitet && ak ) ? 1 : 0;
    if( me.id != ME_RLinks )
    {
        me.mx += pos.x;
        me.my += pos.y;
        return;
    }
    if( aktion )
    {
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        else
        {
            if( anmeldungClient->gruppeNachricht( gruppeId, nachricht->zText()->getText() ) )
            {
                nachricht->setText( "" );
                nachricht->setAuswahl( 0, 0 );
                rend = 1;
            }
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
    }
    me.mx += pos.x;
    me.my += pos.y;
}

void GruppeChat::doTastaturEreignis( TastaturEreignis & te )
{
    bool b = te.verarbeitet;
    nachricht->doTastaturEreignis( te );
    if( te.verarbeitet && !b && te.id == TE_Release && te.taste == T_Enter )
    {
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
        }
        else
        {
            if( anmeldungClient->gruppeNachricht( gruppeId, nachricht->zText()->getText() ) )
            {
                nachricht->setText( "" );
                nachricht->setAuswahl( 0, 0 );
                rend = 1;
            }
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
    }
}

void GruppeChat::render( Bild & zRObj )
{
    if( !zRObj.setDrawOptions( pos.x, pos.y, gr.x, gr.y ) )
        return;
    verlauf->render( zRObj );
    nachricht->render( zRObj );
    senden->render( zRObj );
    zRObj.releaseDrawOptions();
}

// constant

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

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

// Inhalt der GruppeAnmeldung Klasse aus Gruppe.h
// Konstruktor
GruppeAnmeldung::GruppeAnmeldung( Schrift * zSchrift )
{
    pos = Punkt( 750, 350 );
    gr = Punkt( 200, 200 );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 200, 200 );
    spielerHinzufügen = initKontrollKnopf( 25, 45, 150, 20, zSchrift, KontrollKnopf::Style::Normal, "Spieler hinzufügen" );
    spielerHinzufügen->removeStyle( KontrollKnopf::Style::Erlaubt );
    spielerHinzufügen->setMausEreignis( _ret1ME );
    initToolTip( spielerHinzufügen, "Es werden nur Spieler aus dieser Gruppe mit ins Spiel kommen.", zSchrift, hauptScreen );
    angemeldet = initKontrollKnopf( 25, 75, 150, 20, zSchrift, KontrollKnopf::Style::Normal, "in Warteschlange" );
    angemeldet->removeStyle( KontrollKnopf::Style::Erlaubt );
    angemeldet->setMausEreignis( _ret1ME );
    initToolTip( angemeldet, "Die Gruppe befindet sich momentan nicht in der Warteschlange.", zSchrift, hauptScreen );
    zeit = initTextFeld( 0, 105, 200, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Zeit in Warteschlange: " );
    gruppeVerlassen = initKnopf( 40, 135, 120, 20, zSchrift, Knopf::Style::Normal, "Gruppe verlassen" );
    admin = 0;
    time = 0;
    gruppeId = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeAnmeldung::~GruppeAnmeldung()
{
    rahmen->release();
    spielerHinzufügen->release();
    angemeldet->release();
    zeit->release();
    gruppeVerlassen->release();
}

// nicht constant
void GruppeAnmeldung::reset()
{
    spielerHinzufügen->removeStyle( KontrollKnopf::Style::Selected );
    angemeldet->removeStyle( KontrollKnopf::Style::Selected );
    admin = 0;
    time = 0;
    gruppeId = 0;
    rend = 1;
}

void GruppeAnmeldung::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
    spielerHinzufügen->setStyle( KontrollKnopf::Style::Selected, infoClient->getGruppeSpielerHinzufügen( gruppeId ) );
    rend = 1;
}

void GruppeAnmeldung::setAdmin( int admin )
{
    this->admin = admin;
    if( admin == loginClient->getAccountId() )
    {
        spielerHinzufügen->addStyle( KontrollKnopf::Style::Erlaubt );
        angemeldet->addStyle( KontrollKnopf::Style::Erlaubt );
    }
    else
    {
        spielerHinzufügen->removeStyle( KontrollKnopf::Style::Erlaubt );
        angemeldet->removeStyle( KontrollKnopf::Style::Erlaubt );
    }
    rend = 1;
}

void GruppeAnmeldung::setSpielerHinzufügen( bool spielerHinzufügen )
{
    this->spielerHinzufügen->setStyle( KontrollKnopf::Style::Selected, spielerHinzufügen );
    // TODO
    /*if( spielerHinzufügen )
        this->spielerHinzufügen->zToolTip()->setText( "Es kommen auch andere Spieler mit ins Spiel,\ndie nicht in dieser Gruppe sind." );
    else
        this->spielerHinzufügen->zToolTip()->setText( "Es werden nur Spieler aus dieser Gruppe mit ins Spiel kommen." );*/
    rend = 1;
}

void GruppeAnmeldung::setAngemeldet( bool angemeldet )
{
    this->angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet );
    // TODO
    /*
    if( angemeldet )
        this->angemeldet->zToolTip()->setText( "Die Gruppe befindet sich in der Warteschlange." );
    else
        this->angemeldet->zToolTip()->setText( "Die Gruppe befindet sich momentan nicht in der Warteschlange." );*/
    time = 0;
    rend = 1;
}

void GruppeAnmeldung::zurückInWarteschlange( int stunden, int minuten, int sekunden )
{
    this->angemeldet->setStyle( KontrollKnopf::Style::Selected, 1 );
    time = sekunden + minuten * 60 + stunden * 60 * 60;
    rend = 1;
}

void GruppeAnmeldung::spielGefunden()
{
    this->angemeldet->setStyle( KontrollKnopf::Style::Selected, 0 );
    time = 0;
    rend = 1;
}

bool GruppeAnmeldung::tick( double tickVal )
{
    if( angemeldet->hatStyle( KontrollKnopf::Style::Selected ) )
    {
        if( (int)( time / 1 ) != (int)( ( time + tickVal ) / 1 ) )
            rend = 1;
        time += tickVal;
    }
    if( rend )
    {
        zeit->setText( "Zeit in Warteschlange: " );
        zeit->zText()->append( (int)( time / 60 / 60 ) );
        zeit->zText()->append( ":" );
        zeit->zText()->append( (int)( time / 60 ) % 60 );
        zeit->zText()->append( ":" );
        zeit->zText()->append( (int)( time ) % 60 );
    }
    rend |= spielerHinzufügen->tick( tickVal );
    rend |= angemeldet->tick( tickVal );
    rend |= gruppeVerlassen->tick( tickVal );
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeAnmeldung::doPublicMausEreignis( MausEreignis & me )
{
    me.mx -= pos.x;
    me.my -= pos.y;
    bool ak = !me.verarbeitet;
    int aktion = 0;
    if( admin == loginClient->getAccountId() )
    {
        spielerHinzufügen->doPublicMausEreignis( me );
        aktion = ( me.verarbeitet && admin == loginClient->getAccountId() && ak ) ? 1 : aktion;
        angemeldet->doPublicMausEreignis( me );
        aktion = ( me.verarbeitet && admin == loginClient->getAccountId() && ak && !aktion ) ? 2 : aktion;
    }
    gruppeVerlassen->doPublicMausEreignis( me );
    aktion = ( me.verarbeitet && ak && !aktion ) ? 3 : aktion;
    if( me.id != ME_RLinks )
    {
        me.mx += pos.x;
        me.my += pos.y;
        return;
    }
    switch( aktion )
    {
    case 1:
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
            spielerHinzufügen->setStyle( KontrollKnopf::Style::Selected, spielerHinzufügen->hatStyleNicht( KontrollKnopf::Style::Selected ) );
            rend = 1;
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
            spielerHinzufügen->setStyle( KontrollKnopf::Style::Selected, spielerHinzufügen->hatStyleNicht( KontrollKnopf::Style::Selected ) );
            rend = 1;
        }
        else
        {
            if( !anmeldungClient->gruppeSpielStarten( gruppeId, spielerHinzufügen->hatStyleNicht( KontrollKnopf::Style::Selected ) ) )
            {
                spielerHinzufügen->setStyle( KontrollKnopf::Style::Selected, spielerHinzufügen->hatStyleNicht( KontrollKnopf::Style::Selected ) );
                rend = 1;
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
        break;
    case 2:
        if( !anmeldungClient )
            anmeldungClient = mainClient->createAnmeldungServerClient();
        if( !anmeldungClient )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( mainClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
            angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet->hatStyleNicht( KontrollKnopf::Style::Selected ) );
            rend = 1;
        }
        if( !anmeldungClient->verbinde() )
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                          new Text( "Ok" ), 0 );
            angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet->hatStyleNicht( KontrollKnopf::Style::Selected ) );
            rend = 1;
        }
        else
        {
            if( angemeldet->hatStyle( KontrollKnopf::Style::Selected ) )
            {
                if( !anmeldungClient->gruppeAnmelden( gruppeId ) )
                {
                    angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet->hatStyleNicht( KontrollKnopf::Style::Selected ) );
                    rend = 1;
                    nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                  new Text( "Ok" ), 0 );
                }
            }
            else
            {
                if( !anmeldungClient->gruppeAbmelden( gruppeId ) )
                {
                    angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet->hatStyleNicht( KontrollKnopf::Style::Selected ) );
                    rend = 1;
                    nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                                  new Text( "Ok" ), 0 );
                }
            }
            anmeldungClient->trenne( 0 );
        }
        break;
    case 3:
        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
        {
            if( anmeldungClient->gruppeVerlassen( gruppeId ) )
                nachLogin->zSpielenFenster()->gruppeVerlassen();
            else
            {
                nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungClient->getLetzterFehler() ),
                                                              new Text( "Ok" ), 0 );
            }
            anmeldungClient->trenne( 0 );
        }
        break;
    }
    me.mx += pos.x;
    me.my += pos.y;
}

void GruppeAnmeldung::render( Bild & zRObj )
{
    if( !zRObj.setDrawOptions( pos.x, pos.y, gr.x, gr.y ) )
        return;
    rahmen->render( zRObj );
    spielerHinzufügen->render( zRObj );
    angemeldet->render( zRObj );
    zeit->render( zRObj );
    gruppeVerlassen->render( zRObj );
    zRObj.releaseDrawOptions();
}

// constant

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

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

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

// Inhalt der GruppeKarte Klasse aus Gruppe.h
// Konstruktor
GruppeKarte::GruppeKarte( Schrift * zSchrift )
    : Thread()
{
    schrift = zSchrift->getThis();
    tr = new TextRenderer( schrift->getThis() );
    pos = Punkt( 350, 0 );
    gr = Punkt( 600, 350 );
    rahmen = new LRahmen();
    rahmen->setFarbe( 0xFFFFFFFF );
    rahmen->setRamenBreite( 1 );
    rahmen->setSize( 350, 350 );
    rahmen->setPosition( 248, 0 );
    info = 0;
    ksgs = Framework::getDLLRegister()->ladeDLL( "KSGScript.dll", "data/bin/KSGScript.dll" );
    if( ksgs )
    {
        KSGSGetZeichnung getKSGScript = (KSGSGetZeichnung)GetProcAddress( ksgs, KSGS_START_FUNKTION );
        if( getKSGScript )
        {
            info = getKSGScript();
            info->setBildschirmZ( hauptScreen->getThis() );
            info->setSchriftZ( schrift->getThis() );
            info->setSize( 248, 350 );
            info->setRückrufParam( this );
            info->setRückrufFunktion( GruppeKarteKSGSAktion );
        }
        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 );
    }
    hintergrund = 0;
    fehler = 0;
    alpha1 = 0;
    alpha2 = 0;
    ladenZeit = 0;
    tickVal = 0;
    ladeBild = 0;
    karteId = 0;
    gruppeId = 0;
    exit = 0;
    geladen = 0;
    rend = 0;
}

// Destruktor
GruppeKarte::~GruppeKarte()
{
    rahmen->release();
    if( info )
    {
        info->zurücksetzen();
        info->release();
    }
    if( hintergrund )
        hintergrund->release();
    if( fehler )
        fehler->release();
    if( schrift )
        schrift->release();
    tr->release();
    if( ksgs )
        Framework::getDLLRegister()->releaseDLL( "KSGScript.dll" );
}

// nicht constant
void GruppeKarte::reset()
{
    if( info )
        info->zurücksetzen();
    if( hintergrund )
        hintergrund = hintergrund->release();
    if( fehler )
        fehler = (TextFeld *)fehler->release();
    if( run )
    {
        exit = 1;
        warteAufThread( 5000 );
        if( run )
            ende();
    }
    geladen = 0;
    alpha1 = 0;
    alpha2 = 0;
    ladenZeit = 0;
    tickVal = 0;
    ladeBild = 0;
    karteId = 0;
    gruppeId = 0;
    exit = 0;
    rend = 1;
}

void GruppeKarte::ksgsAktion( RCArray< KSGSVariable > * parameter, KSGSVariable * *retVal )
{

}

void GruppeKarte::setGruppeId( int gruppeId )
{
    this->gruppeId = gruppeId;
    if( run )
    {
        exit = 1;
        warteAufThread( 5000 );
        if( run )
            ende();
        exit = 0;
    }
    geladen = 0;
    rend = 1;
    start();
}

bool GruppeKarte::tick( double tickVal )
{
    if( !gruppeId )
        return 0;
    if( info )
        rend |= info->tick( tickVal );
    ladenZeit += tickVal;
    if( ladenZeit >= 1 / 30.0 )
    {
        ladenZeit -= 1 / 30.0;
        if( ladeAnimation &&ladeAnimation->zAnimationData() )
        {
            if( alpha1 )
                rend = 1;
            ladeBild++;
            if( ladeBild >= ladeAnimation->zAnimationData()->getBildAnzahl() )
                ladeBild = 0;
        }
    }
    this->tickVal += tickVal * 300;
    int val = (int)this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 10 )
        val = 10;
    this->tickVal -= val;
    if( !geladen && !fehler )
    {
        if( alpha1 != 255 || alpha2 != 0 )
            rend = 1;
        if( alpha1 + val > 255 )
            alpha1 = 255;
        else
            alpha1 += val;
        if( alpha2 - val < 0 )
            alpha2 = 0;
        else
            alpha2 -= val;
    }
    else
    {
        if( alpha1 != 0 || alpha2 != 255 )
            rend = 1;
        if( alpha1 - val < 0 )
            alpha1 = 0;
        else
            alpha1 -= val;
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeKarte::doPublicMausEreignis( MausEreignis & me )
{
    me.mx -= pos.x;
    me.my -= pos.y;
    if( info )
        info->doPublicMausEreignis( me );
    me.mx += pos.x;
    me.my += pos.y;
}

void GruppeKarte::render( Bild & zrObj )
{
    int x = pos.x;
    int y = pos.y;
    if( !zrObj.setDrawOptions( x, y, gr.x, gr.y ) )
        return;
    if( alpha1 != 0 && ladeAnimation && ladeAnimation->zAnimationData() )
    {
        Bild *tmp = ladeAnimation->zAnimationData()->zBild( ladeBild );
        if( tmp )
        {
            zrObj.setAlpha( alpha1 );
            zrObj.drawBild( gr.x / 2 - tmp->getBreite() / 2, gr.y / 2 - tmp->getHeight() / 2, tmp->getBreite(), tmp->getHeight(), *tmp );
            zrObj.releaseAlpha();
        }
    }
    if( alpha2 != 0 )
    {
        zrObj.setAlpha( alpha2 );
        if( geladen )
        {
            if( info )
                info->render( zrObj );
            rahmen->render( zrObj );
            zrObj.drawBild( 248 + rahmen->getRBreite(), rahmen->getRBreite(),
                            rahmen->getBreite() - rahmen->getRBreite() * 2, rahmen->getHeight() - rahmen->getRBreite() * 2, *hintergrund );
        }
        else if( fehler )
            fehler->render( zrObj );
        zrObj.releaseAlpha();
    }
    zrObj.releaseDrawOptions();
}

void GruppeKarte::thread()
{
    if( info )
        info->zurücksetzen();
    if( hintergrund )
        hintergrund = hintergrund->release();
    if( fehler )
        fehler = (TextFeld *)fehler->release();
    karteId = infoClient->getGruppenKarteId( gruppeId );
    if( !karteId )
    {
        run = 0;
        return;
    }
    KartenLeser *karte = KartenLeser::getInstance();
    karte->lock();
    karte->setKarteId( karteId );
    hintergrund = karte->getKartenVorschauBild();
    if( exit )
    {
        if( hintergrund )
            hintergrund = hintergrund->release();
        karte->unlock();
        karte->release();
        run = 0;
        return;
    }
    if( !hintergrund )
    {
        Text *f = new Text( karte->getLetzterFehler() );
        tr->setSchriftSize( 12 );
        int br = tr->getTextBreite( f->getText() );
        int hö = tr->getTextHeight( f->getText() );
        fehler = initTextFeld( gr.x / 2 - ( br + 10 ) / 2, gr.y / 2 - ( hö + 4 ) / 2, br + 10, hö + 4,
                               schrift, TextFeld::Style::Text | TextFeld::Style::Center, f->getText() );
        f->release();
        karte->unlock();
        karte->release();
        run = 0;
        return;
    }
    bool ok = 0;
    if( info )
    {
        if( !karte->getKartenBeschreibung() )
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Beschreibung nicht gefunden." ), new Text( "Ok" ) );
        else
        {
            Text *pf = karte->getKartePfad();
            *pf += "beschreibung.ksgs";
            info->setScriptDatei( pf );
            ok = info->neuLaden();
            KSGSVariable *var = info->startFunktion( info->getFunktionId( "_in_gruppe" ), new RCArray< KSGSVariable >() );
            if( var )
                var->release();
        }
    }
    if( !ok )
    {
        Text *f = new Text( karte->getLetzterFehler() );
        tr->setSchriftSize( 12 );
        int br = tr->getTextBreite( f->getText() );
        int hö = tr->getTextHeight( f->getText() );
        fehler = initTextFeld( gr.x / 2 - ( br + 10 ) / 2, gr.y / 2 - ( hö + 4 ) / 2, br + 10, hö + 4,
                               schrift, TextFeld::Style::Text | TextFeld::Style::Center, f->getText() );
        f->release();
        karte->unlock();
        karte->release();
        run = 0;
        return;
    }
    karte->unlock();
    karte->release();
    geladen = 1;
    run = 0;
    rend = 1;
}

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

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

// Inhalt der GruppeSpielGefunden Klasse aus Gruppe.h
// Konstruktor
GruppeSpielGefunden::GruppeSpielGefunden( Schrift * zSchrift )
{
    pos = Punkt( 375, 235 );
    gr = Punkt( 200, 90 );
    spielGefunden = initFenster( 0, 0, 200, 90, zSchrift, Fenster::Style::Sichtbar | Fenster::Style::Rahmen | Fenster::Style::Titel, "Spiel gefunden" );
    zeit = initTextFeld( 0, 30, 200, 20, zSchrift, TextFeld::Style::Text, "Verbleibende Zeit: 10" );
    warte = initTextFeld( 0, 60, 200, 20, zSchrift, TextFeld::Style::Text & ~TextFeld::Style::Sichtbar, "Warte auf andere Spieler. . ." );
    annehmen = initKnopf( 50, 60, 100, 20, zSchrift, Knopf::Style::Normal, "beitreten" );
    alpha = 0;
    time = 0;
    sichtbar = 0;
    tickVal = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeSpielGefunden::~GruppeSpielGefunden()
{
    spielGefunden->release();
    zeit->release();
    warte->release();
    annehmen->release();
}

// nicht constant
void GruppeSpielGefunden::reset()
{
    zeit->setText( "Verbleibende Zeit: 10" );
    alpha = 0;
    time = 0;
    sichtbar = 0;
    warte->removeStyle( TextFeld::Style::Sichtbar );
    annehmen->addStyle( Knopf::Style::Sichtbar );
    rend = 1;
}

void GruppeSpielGefunden::setSichtbar( bool sichtbar )
{
    warte->removeStyle( TextFeld::Style::Sichtbar );
    annehmen->addStyle( Knopf::Style::Sichtbar );
    this->sichtbar = sichtbar;
    rend = 1;
}

void GruppeSpielGefunden::setVerbleibendeZeit( int sekunden )
{
    if( time != sekunden )
        rend = 1;
    time = sekunden;
}

bool GruppeSpielGefunden::tick( double tickVal )
{
    if( rend )
    {
        zeit->setText( "Verbleibende Zeit: " );
        zeit->zText()->append( (int)time );
    }
    rend |= annehmen->tick( tickVal );
    this->tickVal += tickVal * 300;
    int val = (int)this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 10 )
        val = 10;
    this->tickVal -= val;
    if( sichtbar )
    {
        if( alpha < 255 )
        {
            if( alpha + val > 255 )
                alpha = 255;
            else
                alpha += val;
            rend = 1;
        }
    }
    else
    {
        if( alpha )
        {
            if( alpha - val < 0 )
                alpha = 0;
            else
                alpha -= val;
            rend = 1;
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeSpielGefunden::doPublicMausEreignis( MausEreignis & me )
{
    me.mx -= pos.x;
    me.my -= pos.y;
    bool ver = me.verarbeitet;
    annehmen->doPublicMausEreignis( me );
    if( me.verarbeitet && !ver && me.id == ME_RLinks )
    {
        if( spielClient->spielErstelltAnnehmen() )
        {
            annehmen->removeStyle( Knopf::Style::Sichtbar );
            warte->addStyle( TextFeld::Style::Sichtbar );
            rend = 1;
        }
        else if( nachLogin &&nachLogin->zSpielenFenster() )
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( spielClient->getLetzterFehler() ), new Text( "Ok" ), 0 );
    }
    me.mx += pos.x;
    me.my += pos.y;
}

void GruppeSpielGefunden::render( Bild & zRObj )
{
    if( !zRObj.setDrawOptions( pos.x, pos.y, gr.x, gr.y ) )
        return;
    zRObj.setAlpha( alpha );
    spielGefunden->render( zRObj );
    zeit->render( zRObj );
    warte->render( zRObj );
    annehmen->render( zRObj );
    zRObj.releaseAlpha();
    zRObj.releaseDrawOptions();
}

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

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

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

// Inhalt der GruppeFenster Klasse aus Gruppe.h
// Konstruktor
GruppeFenster::GruppeFenster( Schrift * zSchrift )
{
    pos = Punkt( 0, 0 );
    gr = Punkt( 950, 550 );
    anmeldung = new GruppeAnmeldung( zSchrift );
    chat = new GruppeChat( zSchrift );
    accounts = new GruppeAccountListe( zSchrift );
    einladungen = new GruppeEinladungListe( zSchrift );
    karte = new GruppeKarte( zSchrift );
    spiel = new GruppeSpielGefunden( zSchrift );
    alpha = 0;
    sichtbar = 0;
    tickVal = 0;
    rend = 0;
    ref = 1;
}

// Destruktor
GruppeFenster::~GruppeFenster()
{
    anmeldung->release();
    chat->release();
    accounts->release();
    einladungen->release();
    karte->release();
    spiel->release();
}

// nicht constant
void GruppeFenster::setGruppeId( int id )
{
    gruppeId = id;
    anmeldung->setGruppeId( id );
    chat->setGruppeId( id );
    accounts->setGruppeId( id );
    einladungen->setGruppeId( id );
    karte->setGruppeId( id );
    spiel->setSichtbar( 0 );
    if( id )
    {
        int adminId = infoClient->getGruppeAdminId( id );
        nachLogin->zFreundesListe()->zeigeEinladeKnopf( adminId == loginClient->getAccountId() );
        setAdmin( adminId );
    }
    rend = 1;
}

void GruppeFenster::setSichtbar( bool sichtbar )
{
    this->sichtbar = sichtbar;
    rend = 1;
}

void GruppeFenster::chatNachricht( const char *nachricht )
{
    chat->gruppeNachricht( nachricht );
}

void GruppeFenster::neuerSpieler( int accountId )
{
    einladungen->setAngenommen( accountId );
    accounts->addAccount( accountId );
}

void GruppeFenster::spielerVerlässt( int accountId )
{
    accounts->removeAccount( accountId );
    anmeldung->setAngemeldet( 0 );
}

void GruppeFenster::neueEinladung( int accountId )
{
    einladungen->addAccount( accountId );
}

void GruppeFenster::einladungEntfernt( int accountId )
{
    einladungen->remove( accountId );
}

void GruppeFenster::einladungAbgelehnt( int accountId )
{
    einladungen->setAbgelehnt( accountId );
}

void GruppeFenster::setSpielerHinzufügen( bool sh )
{
    anmeldung->setSpielerHinzufügen( sh );
}

void GruppeFenster::setAngemeldet( bool angemeldet )
{
    anmeldung->setAngemeldet( angemeldet );
}

void GruppeFenster::spielGefunden()
{
    anmeldung->spielGefunden();
    spiel->setSichtbar( 1 );
    rend = 1;
}

void GruppeFenster::verbleibendeZeit( int sekunden )
{
    spiel->setVerbleibendeZeit( sekunden );
}

void GruppeFenster::spielGefundenAbbruch()
{
    spiel->setSichtbar( 0 );
}

void GruppeFenster::zurückInWarteschlange( int stunden, int minuten, int sekunden )
{
    anmeldung->zurückInWarteschlange( stunden, minuten, sekunden );
}

void GruppeFenster::setAdmin( int accountId )
{
    anmeldung->setAdmin( accountId );
    accounts->setAdmin( accountId );
    einladungen->setAdmin( accountId );
}

void GruppeFenster::kick()
{

}

void GruppeFenster::reset()
{
    accounts->reset();
    einladungen->reset();
    karte->reset();
    chat->reset();
    anmeldung->reset();
    spiel->reset();
}

bool GruppeFenster::tick( double tickVal )
{
    if( !spiel->istSichtbar() )
    {
        rend |= anmeldung->tick( tickVal );
        rend |= chat->tick( tickVal );
        rend |= accounts->tick( tickVal );
        rend |= einladungen->tick( tickVal );
        rend |= karte->tick( tickVal );
    }
    rend |= spiel->tick( tickVal );
    this->tickVal += tickVal * 300;
    int val = (int)this->tickVal;
    if( val < 1 )
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if( val > 10 )
        val = 10;
    this->tickVal -= val;
    if( sichtbar )
    {
        if( spiel->istSichtbar() )
        {
            if( alpha > 0x70 )
            {
                if( alpha - val < 0x70 )
                    alpha = 0x70;
                else
                    alpha -= val;
                rend = 1;
            }
            else if( alpha < 0x70 )
            {
                if( alpha + val > 0x70 )
                    alpha = 0x70;
                else
                    alpha += val;
                rend = 1;
            }
        }
        else
        {
            if( alpha < 255 )
            {
                if( alpha + val > 255 )
                    alpha = 255;
                else
                    alpha += val;
                rend = 1;
            }
        }
    }
    else
    {
        if( alpha > 0 )
        {
            if( alpha - val < 0 )
                alpha = 0;
            else
                alpha -= val;
            rend = 1;
            if( !alpha )
                reset();
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void GruppeFenster::doPublicMausEreignis( MausEreignis & me )
{
    if( !spiel->istSichtbar() )
    {
        anmeldung->doPublicMausEreignis( me );
        chat->doPublicMausEreignis( me );
        accounts->doPublicMausEreignis( me );
        einladungen->doPublicMausEreignis( me );
        karte->doPublicMausEreignis( me );
    }
    spiel->doPublicMausEreignis( me );
}

void GruppeFenster::doTastaturEreignis( TastaturEreignis & te )
{
    if( !spiel->istSichtbar() )
    {
        chat->doTastaturEreignis( te );
        einladungen->doTastaturEreignis( te );
    }
}

void GruppeFenster::render( Bild & zRObj )
{
    if( alpha )
    {
        int x = pos.x;
        int y = pos.y;
        if( !zRObj.setDrawOptions( x, y, gr.x, gr.y ) )
            return;
        unsigned char tmpAlpha = zRObj.getAlpha();
        zRObj.setAlpha( alpha );
        anmeldung->render( zRObj );
        chat->render( zRObj );
        accounts->render( zRObj );
        einladungen->render( zRObj );
        karte->render( zRObj );
        zRObj.releaseAlpha();
        spiel->render( zRObj );
        zRObj.releaseDrawOptions();
    }
}

// constant
int GruppeFenster::getGruppeId() const
{
    return gruppeId;
}

int GruppeFenster::getKarteId() const
{
    return karte ? karte->getKarteId() : 0;
}

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

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