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

#include "Gruppe.h"

#include <AlphaFeld.h>
#include <DateiSystem.h>
#include <Globals.h>
#include <Punkt.h>
#include <Rahmen.h>
#include <ToolTip.h>

#include "..\..\..\Global\Initialisierung.h"
#include "..\..\..\Global\Variablen.h"
#include "..\..\..\Leser\KartenLeser.h"

// Inhalt der GruppeEinladungAccount Klasse aus Gruppe.h
// Konstruktor
GruppeEinladungAccount::GruppeEinladungAccount()
    : ReferenceCounter()
{
    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, TextFeld::Style::Text | TextFeld::Style::Center, "");
    nachrichtSenden = initKnopf(0, 30, 20, 20, 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.");
    erneutSenden = initKnopf(0, 30, 20, 20, 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.");
    einladungAbbrechen = initKnopf(0, 30, 20, 20, 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.");
    status = 0;
    knopfX = 500;
    tickVal = 0;
    mausIn = 0;
    remove = 0;
    gruppeId = 0;
    accountId = 0;
    admin = 0;
    höhe = 0;
    animation = 0x1;
    rend = 0;
}

// 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;
}

// Inhalt der GruppeEinladungListe Klasse aus Gruppe.h
// Konstruktor
GruppeEinladungListe::GruppeEinladungListe()
    : ReferenceCounter()
{
    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, TextFeld::Style::TextFeld, "");
    initToolTip(einladenName, "Name des Spielers den du einladen möchtest.");
    einladen = initKnopf(125, 5, 20, 20, 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.");
    scroll = new VScrollBar();
    accounts = new RCArray<GruppeEinladungAccount>();
    einladungHöhe = 0;
    tickVal = 0;
    anzahl = 0;
    gruppeId = 0;
    admin = 0;
    rend = 0;
}

// Destruktor
GruppeEinladungListe::~GruppeEinladungListe()
{
    rahmen->release();
    einladenName->release();
    einladen->release();
    scroll->release();
    accounts->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();
    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.virtualKey == 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();
}

// Inhalt der GruppeAccountDaten Klasse aus Gruppe.h
// Konstruktor
GruppeAccountDaten::GruppeAccountDaten()
    : ReferenceCounter()
{
    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, TextFeld::Style::Text | TextFeld::Style::Center, "");
    punkte = initTextFeld(
        101, 6, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, "0p");
    nachrichtSenden = initKnopf(0, 30, 20, 20, 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.");
    freundEinladung = initKnopf(0, 30, 20, 20, 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.");
    accountAnsehen = initKnopf(0, 30, 20, 20, 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.");
    kick = initKnopf(0, 30, 20, 20, 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.");
    tickVal = 0;
    mausIn = 0;
    remove = 0;
    gruppeId = 0;
    accountId = 0;
    admin = 0;
    höhe = 0;
    animation = 0x1;
    rend = 0;
}

// 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;
}

// Inhalt der GruppeAccountListe Klasse aus Gruppe.h
// Konstruktor
GruppeAccountListe::GruppeAccountListe()
    : ReferenceCounter()
{
    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;
}

// Destruktor
GruppeAccountListe::~GruppeAccountListe()
{
    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();
    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);
}

// Inhalt der GruppeChat Klasse aus Gruppe.h
// Konstruktor
GruppeChat::GruppeChat()
    : ReferenceCounter()
{
    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, TextFeld::Style::TextFeld, "");
    initToolTip(nachricht, "Nachricht an die Gruppe senden.");
    senden = initKnopf(726, 176, 20, 20, 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.");
    verlauf = initTextFeld(2, 2, 746, 174, TextFeld::Style::TextGebiet, "");
    verlauf->removeStyle(TextFeld::Style::Erlaubt);
    verlauf->updateVScroll();
    verlauf->setVertikalKlickScroll(5);
    gruppeId = 0;
    rend = 0;
}

// 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.virtualKey == 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();
}

// Inhalt der GruppeAnmeldung Klasse aus Gruppe.h
// Konstruktor
GruppeAnmeldung::GruppeAnmeldung()
    : ReferenceCounter()
{
    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, 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.");
    angemeldet = initKontrollKnopf(
        25, 75, 150, 20, KontrollKnopf::Style::Normal, "in Warteschlange");
    angemeldet->removeStyle(KontrollKnopf::Style::Erlaubt);
    angemeldet->setMausEreignis(_ret1ME);
    initToolTip(angemeldet,
        "Die Gruppe befindet sich momentan nicht in der Warteschlange.");
    zeit = initTextFeld(0,
        105,
        200,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Zeit in Warteschlange: ");
    gruppeVerlassen
        = initKnopf(40, 135, 120, 20, Knopf::Style::Normal, "Gruppe verlassen");
    admin = 0;
    time = 0;
    gruppeId = 0;
    rend = 0;
}

// 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();
}

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()
    : Thread()
{
    tr = new TextRenderer(
        dynamic_cast<Schrift*>(uiFactory.initParam.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(dynamic_cast<Bildschirm*>(
                uiFactory.initParam.bildschirm->getThis()));
            info->setSchriftZ(
                dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
            info->setSize(248, 350);
            info->setCallbackParam(this);
            info->setCallbackFunktion(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->reset();
        info->release();
    }
    if (hintergrund) hintergrund->release();
    if (fehler) fehler->release();
    tr->release();
    if (ksgs) Framework::getDLLRegister()->releaseDLL("KSGScript.dll");
}

// nicht constant
void GruppeKarte::reset()
{
    if (info) info->reset();
    if (hintergrund) hintergrund = (Bild*)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->reset();
    if (hintergrund) hintergrund = (Bild*)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 = (Bild*)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,
            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,
            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;
}

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

// 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;
}

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

// Destruktor
GruppeFenster::~GruppeFenster()
{
    anmeldung->release();
    chat->release();
    accounts->release();
    einladungen->release();
    karte->warteAufThread(10000);
    karte->ende();
    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;
}