KSG-Client/KSGClient/NachLogin/Spiele/Team Auswahl/TeamAuswahl.cpp

#include "TeamAuswahl.h"

#include <AlphaFeld.h>
#include <AuswahlBox.h>
#include <DateiSystem.h>
#include <Rahmen.h>

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

// Inhalt der TeamAuswahlListeSpieler Klasse aus TeamAuswahl.h
// Konstruktor
TeamAuswahlListeSpieler::TeamAuswahlListeSpieler(
    SpielerTeamStruktur* sts, int accountId, int karteId)
    : ReferenceCounter()
{
    this->accountId = accountId;
    Text* n = infoClient->getSpielerName(accountId);
    name = initTextFeld(1,
        1,
        99,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        n->getText());
    n->release();
    if (accountId == loginClient->getAccountId())
    {
        teamAuswahl = uiFactory.createAuswahlBox(uiFactory.initParam);
        teamAuswahl->setStyle(
            AuswahlBox::Style::Sichtbar | AuswahlBox::Style::Erlaubt
            | AuswahlBox::Style::Rahmen | AuswahlBox::Style::MultiStyled
            | AuswahlBox::Style::MaxHeight | AuswahlBox::Style::VScroll
            | AuswahlBox::Style::Hintergrund);
        teamAuswahl->setPosition(100, 1);
        teamAuswahl->setSize(150, 20);
        teamAuswahl->setEventParam(this);
        teamAuswahl->setEventAktion(TeamAuswahlListeSpielerTeamAuswahlE);
    }
    else
        team = initTextFeld(100,
            1,
            150,
            20,
            TextFeld::Style::Text | TextFeld::Style::Center,
            "");
    Array<int>* statistik = new Array<int>();
    infoClient->getSpielStatistik(
        accountId, infoClient->getSpielId(karteId), statistik);
    punkte = initTextFeld(250,
        1,
        80,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Punkte: ");
    punkte->zText()->append(statistik->hat(3) ? statistik->get(3) : 0);
    spiele = initTextFeld(330,
        1,
        80,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Spiele: ");
    spiele->zText()->append(statistik->hat(0) ? statistik->get(0) : 0);
    gewonnen = initTextFeld(410,
        1,
        90,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Gewonnen: ");
    gewonnen->zText()->append(statistik->hat(1) ? statistik->get(1) : 0);
    statistik->release();
    farbe = initTextFeld(500,
        1,
        50,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Farbe:");
    spielerFarbe = 0;
    rahmen = new LRahmen();
    rahmen->setSize(581, 22);
    rahmen->setFarbe(0xFFFFFFFF);
    rahmen->setRamenBreite(1);
    teamName = new Text("");
    this->sts = sts;
    rend = 0;
}

// Destruktor
TeamAuswahlListeSpieler::~TeamAuswahlListeSpieler()
{
    name->release();
    if (accountId == loginClient->getAccountId())
        teamAuswahl->release();
    else
        team->release();
    punkte->release();
    spiele->release();
    gewonnen->release();
    farbe->release();
    rahmen->release();
    teamName->release();
    sts->release();
}

// nicht constant
void TeamAuswahlListeSpieler::disable()
{
    if (accountId == loginClient->getAccountId())
        teamAuswahl->removeStyle(AuswahlBox::Style::Erlaubt);
}

void TeamAuswahlListeSpieler::spielerTeamAuswahlE(
    AuswahlBox* obj, int p1, int p2)
{
    Text* tmpTeamName = obj->zEintragText(p2);
    if (!tmpTeamName->istGleich(teamName->getText()))
    {
        if (tmpTeamName->istGleich("Zufällig"))
        {
            if (!spielClient->spielErstelltTeamWechseln(0))
                obj->setAuswahl(obj->getEintragPos(teamName->getText()));
        }
        else
        {
            int neuTeam = 0;
            for (int i = 0; i < sts->teamAnzahl; i++)
            {
                if (sts->teamName->z(i)->istGleich(tmpTeamName->getText()))
                {
                    neuTeam = i + 1;
                    break;
                }
            }
            if (!spielClient->spielErstelltTeamWechseln(neuTeam))
                obj->setAuswahl(obj->getEintragPos(teamName->getText()));
        }
        obj->einklappen();
    }
}

void TeamAuswahlListeSpieler::setFarbe(int farbe)
{
    this->spielerFarbe = farbe;
    if (farbe)
        rahmen->setFarbe(farbe);
    else
        rahmen->setFarbe(0xFFFFFFFF);
    rend = 1;
}

void TeamAuswahlListeSpieler::setTeam(Text* zName)
{
    teamName->setText(zName->getText());
    rend = 1;
}

void TeamAuswahlListeSpieler::setTeamErlaubt(
    Text* zName, bool erlaubt, int teamFarbe)
{
    if (accountId != loginClient->getAccountId()) return;
    if (erlaubt)
    {
        if (teamAuswahl->getEintragPos(zName->getText()) < 0)
        {
            int p = teamAuswahl->getEintragAnzahl();
            teamAuswahl->addEintrag(zName->getText());
            teamAuswahl->setMsStyle(p,
                AuswahlBox::Style::FeldRahmen | AuswahlBox::Style::MausBuffer
                    | AuswahlBox::Style::AuswahlBuffer
                    | AuswahlBox::Style::FeldBuffer);
            if (teamFarbe) teamAuswahl->zEintrag(p)->setRahmenFarbe(teamFarbe);
            teamAuswahl->setMsAuswAlphaFeldFarbe(
                p, 0x50000000 | (teamFarbe & 0x00FFFFFF));
            teamAuswahl->setMsAuswAlphaFeldStrength(p, -15);
            teamAuswahl->setMsMausAlphaFeldFarbe(
                p, 0x10000000 | (teamFarbe & 0x00FFFFFF));
            teamAuswahl->setMsMausAlphaFeldStrength(p, -15);
        }
    }
    else
    {
        if (zName->istGleich(teamName->getText())) return;
        if (teamAuswahl->getEintragPos(zName->getText()) >= 0)
            teamAuswahl->removeEintrag(
                teamAuswahl->getEintragPos(zName->getText()));
    }
}

bool TeamAuswahlListeSpieler::tick(double tickVal)
{
    if (accountId == loginClient->getAccountId())
        rend |= teamAuswahl->tick(tickVal);
    else if (!team->zText()->istGleich(teamName->getText()))
    {
        team->setText("");
        team->zText()->append(teamName->getText());
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void TeamAuswahlListeSpieler::doPublicMausEreignis(MausEreignis& me)
{
    if (accountId == loginClient->getAccountId())
        teamAuswahl->doPublicMausEreignis(me);
}

void TeamAuswahlListeSpieler::render(int yOff, Bild& zRObj)
{
    if (!zRObj.setDrawOptions(0, yOff, 581, 22)) return;
    rahmen->render(zRObj);
    name->render(zRObj);
    if (loginClient->getAccountId() == accountId)
        teamAuswahl->render(zRObj);
    else
        team->render(zRObj);
    punkte->render(zRObj);
    spiele->render(zRObj);
    gewonnen->render(zRObj);
    farbe->render(zRObj);
    zRObj.alphaRegion(550, 2, 18, 18, spielerFarbe);
    zRObj.releaseDrawOptions();
}

// constant
int TeamAuswahlListeSpieler::getAccountId() const
{
    return accountId;
}

// Inhalt der TeamAuswahlListeTeam Klasse aus TeamAuswahl.h
// Konstruktor
TeamAuswahlListeTeam::TeamAuswahlListeTeam()
    : ReferenceCounter()
{
    maxSpieler = 0;
    jetztSpieler = 0;
    team = 0;
    name = initTextFeld(0,
        0,
        300,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Team: ");
    mjSpieler = initTextFeld(300,
        0,
        150,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Spieler: 0/0");
    farbe = initTextFeld(450,
        0,
        100,
        20,
        TextFeld::Style::Text | TextFeld::Style::Center,
        "Team Farbe:");
    teamFarbe = 0;
    spieler = new RCArray<TeamAuswahlListeSpieler>();
    rahmen = new LRahmen();
    rahmen->setSize(583, 22);
    rahmen->setFarbe(0xFFFFFFFF);
    rahmen->setRamenBreite(1);
    titelAf = new AlphaFeld();
    titelAf->setPosition(1, 1);
    titelAf->setSize(581, 20);
    titelAf->setFarbe(0x1000FF00);
    titelAf->setStrength(-15);
    teamName = new Text("");
    tickVal = 0;
    höhe = 22;
    rend = 0;
}

// Destruktor
TeamAuswahlListeTeam::~TeamAuswahlListeTeam()
{
    name->release();
    mjSpieler->release();
    farbe->release();
    spieler->release();
    rahmen->release();
    titelAf->release();
    teamName->release();
}

// nicht constant
void TeamAuswahlListeTeam::disable()
{
    for (int i = 0; i < jetztSpieler; i++)
        spieler->z(i)->disable();
}

void TeamAuswahlListeTeam::setMaxSpieler(int maxSpieler)
{
    this->maxSpieler = maxSpieler;
    rend = 1;
}

void TeamAuswahlListeTeam::setName(Text* name)
{
    teamName->setText(name->getText());
    name->release();
    rend = 1;
}

void TeamAuswahlListeTeam::setFarbe(int farbe)
{
    teamFarbe = farbe;
    rahmen->setFarbe(teamFarbe);
    rend = 1;
}

void TeamAuswahlListeTeam::setTeam(int team)
{
    this->team = team;
    rend = 1;
}

void TeamAuswahlListeTeam::addSpieler(TeamAuswahlListeSpieler* spieler)
{
    if (!jetztSpieler) höhe++;
    spieler->setTeam(teamName);
    höhe += 22;
    this->spieler->set(spieler, jetztSpieler);
    jetztSpieler++;
    rend = 1;
}

void TeamAuswahlListeTeam::removeSpieler(int accountId)
{
    höhe -= 22;
    for (int i = 0; i < jetztSpieler; i++)
    {
        if (spieler->z(i)->getAccountId() == accountId)
        {
            jetztSpieler--;
            spieler->remove(i);
            rend = 1;
            break;
        }
    }
    if (!jetztSpieler) höhe = 22;
}

void TeamAuswahlListeTeam::setTeamErlaubt(
    Text* zName, bool erlaubt, int teamFarbe)
{
    for (int i = 0; i < jetztSpieler; i++)
        spieler->z(i)->setTeamErlaubt(zName, erlaubt, teamFarbe);
}

bool TeamAuswahlListeTeam::tick(double tickVal)
{
    this->tickVal += tickVal * 50;
    int val = (int)this->tickVal;
    if (val > 2) val = 2;
    this->tickVal -= val;
    if (val)
    {
        if (rahmen->getHeight() > höhe)
        {
            rahmen->setSize(rahmen->getBreite(), rahmen->getHeight() - val);
            if (rahmen->getHeight() < höhe)
                rahmen->setSize(rahmen->getBreite(), höhe);
            rend = 1;
        }
        if (rahmen->getHeight() < höhe)
        {
            rahmen->setSize(rahmen->getBreite(), rahmen->getHeight() + val);
            if (rahmen->getHeight() > höhe)
                rahmen->setSize(rahmen->getBreite(), höhe);
            rend = 1;
        }
    }
    name->setText("Team: ");
    name->zText()->append(teamName->getText());
    mjSpieler->setText("Spieler: ");
    mjSpieler->zText()->append(jetztSpieler);
    mjSpieler->zText()->append("/");
    mjSpieler->zText()->append(maxSpieler);
    for (int i = 0; i < jetztSpieler; i++)
        rend |= spieler->z(i)->tick(tickVal);
    bool ret = rend;
    rend = 0;
    return ret;
}

void TeamAuswahlListeTeam::doPublicMausEreignis(MausEreignis& me)
{
    int tmpX = me.mx;
    int tmpY = me.my;
    me.mx--;
    me.my -= 22;
    for (int i = 0; i < jetztSpieler; i++)
    {
        spieler->z(i)->doPublicMausEreignis(me);
        me.my -= 22;
    }
    me.mx = tmpX;
    me.my = tmpY;
}

void TeamAuswahlListeTeam::render(int yOff, Bild& zRObj)
{
    if (!zRObj.setDrawOptions(50, yOff, 583, rahmen->getHeight() + 1)) return;
    rahmen->render(zRObj);
    titelAf->setPosition(1, 1);
    titelAf->render(zRObj);
    name->render(zRObj);
    mjSpieler->render(zRObj);
    farbe->render(zRObj);
    zRObj.alphaRegion(550, 2, 18, 18, teamFarbe);
    zRObj.drawLinieH(1, 21, 581, rahmen->getFarbe());
    if (!zRObj.setDrawOptions(1, 22, 582, rahmen->getHeight()))
    {
        zRObj.releaseDrawOptions();
        return;
    }
    int y = 22 * (jetztSpieler - 1);
    for (int i = jetztSpieler - 1; i >= 0; i--)
    {
        spieler->z(i)->render(y, zRObj);
        y -= 22;
    }
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}

// constant
int TeamAuswahlListeTeam::getTeamNummer() const
{
    return team;
}

int TeamAuswahlListeTeam::getHeight() const
{
    return rahmen->getHeight() + 1;
}

bool TeamAuswahlListeTeam::istPlatzFrei() const
{
    return jetztSpieler < maxSpieler;
}

int TeamAuswahlListeTeam::getMaxSpieler() const
{
    return maxSpieler;
}

Text* TeamAuswahlListeTeam::zName() const
{
    return teamName;
}

TeamAuswahlListeSpieler* TeamAuswahlListeTeam::getSpielerDaten(
    int accountId) const
{
    for (int i = 0; i < jetztSpieler; i++)
    {
        if (spieler->z(i)->getAccountId() == accountId) return spieler->get(i);
    }
    return 0;
}

TeamAuswahlListeSpieler* TeamAuswahlListeTeam::zSpielerDaten(
    int accountId) const
{
    for (int i = 0; i < jetztSpieler; i++)
    {
        if (spieler->z(i)->getAccountId() == accountId) return spieler->z(i);
    }
    return 0;
}

// Inhalt der TeamAuswahlListe Klasse aus TeamAuswahl.h
// Konstruktor
TeamAuswahlListe::TeamAuswahlListe(SpielerTeamStruktur* sts, int karteId)
    : ReferenceCounter()
{
    rahmen = new LRahmen();
    rahmen->setSize(698, 398);
    rahmen->setFarbe(0xFFFFFFFF);
    rahmen->setRamenBreite(1);
    scroll = new VScrollBar();
    scroll->update(0, 396);
    scroll->setKlickScroll(7);
    teams = new RCArray<TeamAuswahlListeTeam>();
    TeamAuswahlListeTeam* zufall = new TeamAuswahlListeTeam();
    zufall->setTeam(0);
    zufall->setName(new Text("Zufällig"));
    zufall->setMaxSpieler(sts->spielerAnzahl);
    teams->set(zufall, 0);
    for (int i = 0; i < sts->teamAnzahl; i++)
    {
        TeamAuswahlListeTeam* tmp = new TeamAuswahlListeTeam();
        tmp->setTeam(i);
        tmp->setName(sts->teamName->get(i));
        tmp->setFarbe(sts->teamFarbe->hat(i) ? sts->teamFarbe->get(i) : 0);
        tmp->setMaxSpieler(sts->teamSize->hat(i) ? sts->teamSize->get(i) : 0);
        teams->set(tmp, i + 1);
    }
    teamAnzahl = 1 + sts->teamAnzahl;
    this->karteId = karteId;
    this->sts = sts;
    rend = 0;
}

// Destruktor
TeamAuswahlListe::~TeamAuswahlListe()
{
    rahmen->release();
    scroll->release();
    teams->release();
    sts->release();
}

// nicht constant
void TeamAuswahlListe::disable()
{
    for (int i = 0; i < teamAnzahl; i++)
        teams->z(i)->disable();
}

void TeamAuswahlListe::setTeamVonSpieler(int accountId, int spielerNummer)
{
    if (spielerNummer == 0)
    {
        int neuTeam = 0;
        int altTeam = 0;
        for (int j = 0; j < teamAnzahl; j++)
        {
            if (teams->z(j)->zSpielerDaten(accountId))
            {
                altTeam = j;
                break;
            }
        }
        TeamAuswahlListeSpieler* tmp
            = teams->z(altTeam)->getSpielerDaten(accountId);
        teams->z(altTeam)->removeSpieler(accountId);
        tmp->setFarbe(0);
        teams->z(neuTeam)->addSpieler(tmp);
    }
    else
    {
        int team = 0;
        int max = 0;
        int min = 0;
        for (int i = 0; i < sts->teamAnzahl; i++)
        {
            min = max;
            max += sts->teamSize->get(i);
            if (spielerNummer - 1 >= min && spielerNummer - 1 < max)
            {
                int neuTeam = i + 1;
                int altTeam = 0;
                for (int j = 0; j < teamAnzahl; j++)
                {
                    if (teams->z(j)->zSpielerDaten(accountId))
                    {
                        altTeam = j;
                        break;
                    }
                }
                TeamAuswahlListeSpieler* tmp
                    = teams->z(altTeam)->getSpielerDaten(accountId);
                teams->z(altTeam)->removeSpieler(accountId);
                tmp->setFarbe(sts->spielerFarbe->hat(spielerNummer - 1)
                                  ? sts->spielerFarbe->get(spielerNummer - 1)
                                  : 0);
                teams->z(neuTeam)->addSpieler(tmp);
                break;
            }
        }
    }
    for (int i = 0; i < teamAnzahl; i++)
    {
        for (int j = 0; j < teamAnzahl; j++)
        {
            if (i == 0)
                teams->z(j)->setTeamErlaubt(
                    teams->z(i)->zName(), teams->z(i)->istPlatzFrei(), 0);
            else
                teams->z(j)->setTeamErlaubt(teams->z(i)->zName(),
                    teams->z(i)->istPlatzFrei(),
                    sts->teamFarbe->hat(i - 1) ? sts->teamFarbe->get(i - 1)
                                               : 0);
        }
    }
    rend = 1;
}

void TeamAuswahlListe::addSpieler(int accountId)
{
    TeamAuswahlListeSpieler* tmp
        = new TeamAuswahlListeSpieler(sts->getThis(), accountId, karteId);
    for (int i = 0; i < teamAnzahl; i++)
    {
        if (teams->z(i)->istPlatzFrei())
        {
            if (i == 0)
                tmp->setTeamErlaubt(teams->z(i)->zName(), 1, 0);
            else
                tmp->setTeamErlaubt(teams->z(i)->zName(),
                    1,
                    sts->teamFarbe->hat(i - 1) ? sts->teamFarbe->get(i - 1)
                                               : 0);
        }
    }
    teams->z(0)->addSpieler(tmp);
    for (int i = 0; i < teamAnzahl; i++)
        teams->z(i)->setTeamErlaubt(
            teams->z(0)->zName(), teams->z(0)->istPlatzFrei(), 0);
    rend = 1;
}

void TeamAuswahlListe::removeSpieler(int accountId)
{
    for (int i = 0; i < teamAnzahl; i++)
    {
        if (teams->z(i)->zSpielerDaten(accountId))
            teams->z(i)->removeSpieler(accountId);
    }
    for (int i = 0; i < teamAnzahl; i++)
    {
        for (int j = 0; j < teamAnzahl; j++)
        {
            if (i == 0)
                teams->z(j)->setTeamErlaubt(
                    teams->z(i)->zName(), teams->z(i)->istPlatzFrei(), 0);
            else
                teams->z(j)->setTeamErlaubt(teams->z(i)->zName(),
                    teams->z(i)->istPlatzFrei(),
                    sts->teamFarbe->hat(i - 1) ? sts->teamFarbe->get(i - 1)
                                               : 0);
        }
    }
    rend = 1;
}

bool TeamAuswahlListe::tick(double tickVal)
{
    for (int i = 0; i < teamAnzahl; i++)
        rend |= teams->z(i)->tick(tickVal);
    rend |= scroll->getRend();
    bool ret = rend;
    rend = 0;
    return ret;
}

void TeamAuswahlListe::doPublicMausEreignis(MausEreignis& me)
{
    int tmpX = me.mx;
    int tmpY = me.my;
    me.mx -= 50;
    me.my -= 50 - scroll->getScroll();
    for (int i = 0; i < teamAnzahl; i++)
    {
        teams->z(i)->doPublicMausEreignis(me);
        me.my -= 20 + teams->z(i)->getHeight();
    }
    me.mx = tmpX;
    me.my = tmpY;
    if (me.mx > 1 && me.mx < 698 && me.my > 1 && me.my < 397)
    {
        scroll->doMausMessage(683, 1, 15, 396, me);
        me.verarbeitet = 1;
    }
}

void TeamAuswahlListe::render(Bild& zRObj)
{
    if (!zRObj.setDrawOptions(0, 0, 698, 398)) return;
    rahmen->render(zRObj);
    int maxHöhe = 50;
    for (int i = 0; i < teamAnzahl; i++)
        maxHöhe += 20 + teams->z(i)->getHeight();
    maxHöhe += 30;
    scroll->update(maxHöhe, 396);
    scroll->render(683, 1, 15, 396, zRObj);
    if (!zRObj.setDrawOptions(1, 1, 682, 395))
    {
        zRObj.releaseDrawOptions();
        return;
    }
    int y = 50 - scroll->getScroll();
    for (int i = 0; i < teamAnzahl - 1; i++)
        y += 20 + teams->z(i)->getHeight();
    for (int i = teamAnzahl - 1; i >= 0; i--)
    {
        teams->z(i)->render(y, zRObj);
        if (i > 0) y -= 20 + teams->z(i - 1)->getHeight();
    }
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}

// Inhalt der TeamAuswahlTimer Klasse aus TeamAuswahl.h
// Konstruktor
TeamAuswahlTimer::TeamAuswahlTimer()
    : ReferenceCounter()
{
    zeit = initTextFeld(
        0, 0, 200, 200, TextFeld::Style::Text | TextFeld::Style::Center, "");
    bestätigen = initKnopf(65, 170, 70, 20, Knopf::Style::Sichtbar, "Fertig");
    time = 0;
    maxTime = 0;
    grad = 0;
    rend = 0;
}

// Destruktor
TeamAuswahlTimer::~TeamAuswahlTimer()
{
    zeit->release();
    bestätigen->release();
}

// nicht constant
void TeamAuswahlTimer::setVerbleibendeZeit(int sekunden)
{
    if (!maxTime) maxTime = sekunden;
    if (time != sekunden) rend = 1;
    time = sekunden;
}

bool TeamAuswahlTimer::doPublicMausEreignis(MausEreignis& me)
{
    bool vera = me.verarbeitet;
    bestätigen->doPublicMausEreignis(me);
    if (!vera && me.verarbeitet && me.id == ME_RLinks)
    {
        if (spielClient->spielErstelltTeamFertig())
        {
            bestätigen->removeStyle(Knopf::Style::Erlaubt);
            return 1;
        }
    }
    return 0;
}

bool TeamAuswahlTimer::tick(double tickVal)
{
    zeit->setText("");
    zeit->zText()->append(time);
    grad += (tickVal * 2);
    rend = 1;
    if (grad > 360) grad -= 360;
    bool ret = rend;
    rend = 0;
    return ret;
}

void TeamAuswahlTimer::render(Bild& zRObj)
{
    if (!zRObj.setDrawOptions(498, 398, 200, 200)) return;
    zeit->render(zRObj);
    int r = (maxTime && time)
              ? 90 - (int)(75.0 / ((double)maxTime / (maxTime - time)) + 0.5)
              : 15;
    zRObj.drawKreis(100, 100, 15, 0xFFFF0000);
    zRObj.drawKreis(100, 100, r, 0xFF00FF00);
    int x1 = 100 + (int)(sin(grad) * 15);
    int y1 = 100 + (int)(cos(grad) * 15);
    int x2 = 100 + (int)(sin(grad) * r);
    int y2 = 100 + (int)(cos(grad) * r);
    zRObj.drawLinie(Punkt(x1, y1), Punkt(x2, y2), 0xFFFFFF00);
    bestätigen->render(zRObj);
    zRObj.releaseDrawOptions();
}

// constant
int TeamAuswahlTimer::getZeit() const
{
    return time;
}

// Inhalt der TeamAuswahlChat Klasse aus TeamAuswahl.h
// Konstruktor
TeamAuswahlChat::TeamAuswahlChat()
    : ReferenceCounter()
{
    nachricht = initTextFeld(2, 178, 472, 20, TextFeld::Style::TextFeld, "");
    Bild* sendenBild = bilder->get("data/client/bilder/chat.ltdb/senden.png");
    senden = initKnopf(476, 178, 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);
    verlauf = initTextFeld(2,
        2,
        494,
        174,
        TextFeld::Style::TextGebiet & ~TextFeld::Style::Erlaubt,
        "");
    verlauf->updateVScroll();
    verlauf->setVertikalKlickScroll(5);
    rahmen = new LRahmen();
    rahmen->setSize(498, 200);
    rahmen->setFarbe(0xFFFFFFFF);
    rahmen->setRamenBreite(1);
    rend = 0;
}

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

// nicht constant
void TeamAuswahlChat::addNachricht(const char* nachricht)
{
    verlauf->addZeile(nachricht);
    verlauf->updateVScroll();
    rend = 1;
}

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

void TeamAuswahlChat::doPublicMausEreignis(MausEreignis& me)
{
    verlauf->doPublicMausEreignis(me);
    nachricht->doPublicMausEreignis(me);
    bool ver = !me.verarbeitet;
    senden->doPublicMausEreignis(me);
    int aktion = (ver && me.verarbeitet && me.id == ME_RLinks) ? 1 : 0;
    if (aktion == 1)
    { // Nachricht senden
        if (spielClient->spielErstelltChatNachricht(
                nachricht->zText()->getText()))
        {
            nachricht->setText("");
            nachricht->setAuswahl(0, 0);
            rend = 1;
        }
        else
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(spielClient->getLetzterFehler()),
                new Text("Ok"),
                0);
    }
}

void TeamAuswahlChat::doTastaturEreignis(TastaturEreignis& te)
{
    bool ver = !te.verarbeitet;
    nachricht->doTastaturEreignis(te);
    int aktion = (ver && te.verarbeitet && te.id == TE_Release
                     && te.virtualKey == T_Enter)
                   ? 1
                   : 0;
    if (aktion == 1)
    { // Nachricht senden
        if (spielClient->spielErstelltChatNachricht(
                nachricht->zText()->getText()))
        {
            nachricht->setText("");
            nachricht->setAuswahl(0, 0);
            rend = 1;
        }
        else
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(spielClient->getLetzterFehler()),
                new Text("Ok"),
                0);
    }
}

void TeamAuswahlChat::render(Bild& zRObj)
{
    if (!zRObj.setDrawOptions(0, 398, 498, 200)) return;
    rahmen->render(zRObj);
    verlauf->render(zRObj);
    nachricht->render(zRObj);
    senden->render(zRObj);
    zRObj.releaseDrawOptions();
}

// Inhalt der TeamAuswahl Klasse aus TeamAuswahl.h
// Konstruktor
TeamAuswahl::TeamAuswahl()
    : ReferenceCounter()
{
    tickVal = 0;
    animation = 0;
    sichtbar = 0;
    alpha = 0;
    karteId = 0;
    sts = 0;
    chat = 0;
    timer = 0;
    liste = 0;
    rend = 0;
}

// Destruktor
TeamAuswahl::~TeamAuswahl()
{
    if (sichtbar) setSichtbar(0);
    if (chat) chat->release();
    if (timer) timer->release();
    if (liste) liste->release();
    if (sts) sts->release();
}

// nicht constant
void TeamAuswahl::setKarteId(int karteId)
{
    this->karteId = karteId;
}

void TeamAuswahl::setSichtbar(bool sichtbar, bool sofort)
{
    this->sichtbar = sichtbar;
    if (sichtbar)
        animation |= 0x1;
    else
    {
        if (sofort)
            alpha = 0;
        else
            animation &= ~0x1;
    }
    rend = 1;
}

void TeamAuswahl::initSTS(SpielerTeamStruktur* sts)
{
    uiFactory.initParam.bildschirm->lock();
    if (this->sts) this->sts->release();
    this->sts = sts;
    if (chat) chat = (TeamAuswahlChat*)chat->release();
    if (timer) timer = (TeamAuswahlTimer*)timer->release();
    if (liste) liste = (TeamAuswahlListe*)liste->release();
    chat = new TeamAuswahlChat();
    timer = new TeamAuswahlTimer();
    liste = new TeamAuswahlListe(sts->getThis(), karteId);
    uiFactory.initParam.bildschirm->unlock();
    rend = 1;
}

void TeamAuswahl::addSpieler(int accountId)
{
    if (liste) liste->addSpieler(accountId);
}

void TeamAuswahl::setSpielerNummer(int accountId, int sNummer)
{
    if (liste) liste->setTeamVonSpieler(accountId, sNummer);
}

void TeamAuswahl::removeSpieler(int accountId)
{
    if (liste) liste->removeSpieler(accountId);
}

void TeamAuswahl::verbleibendeZeit(int sekunden)
{
    if (timer) timer->setVerbleibendeZeit(sekunden);
}

void TeamAuswahl::addNachricht(const char* nachricht)
{
    if (chat) chat->addNachricht(nachricht);
}

bool TeamAuswahl::tick(double tickVal)
{
    if (!sichtbar && !alpha) return 0;
    if (chat) rend |= chat->tick(tickVal);
    if (timer) rend |= timer->tick(tickVal);
    if (liste) rend |= liste->tick(tickVal);
    this->tickVal += tickVal * 150;
    int val = (int)this->tickVal;
    if (!val)
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if (val > 5) val = 5;
    this->tickVal -= val;
    if ((animation | 0x1) == animation) // sichtbar werden
    {
        if (alpha != 255)
        {
            if (alpha + val < 255)
                alpha += val;
            else
                alpha = 255;
            rend = 1;
        }
    }
    else // unsichtbar werden
    {
        if (alpha != 0)
        {
            if (alpha - val >= 0)
                alpha -= val;
            else
                alpha = 0;
            rend = 1;
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void TeamAuswahl::doPublicMausEreignis(MausEreignis& me)
{
    if (!alpha) return;
    if (liste) liste->doPublicMausEreignis(me);
    if (chat)
    {
        me.my -= 398;
        chat->doPublicMausEreignis(me);
        me.mx -= 498;
        if (timer->doPublicMausEreignis(me)) liste->disable();
        me.my += 398;
        me.mx += 498;
    }
}

void TeamAuswahl::doTastaturEreignis(TastaturEreignis& te)
{
    if (!alpha) return;
    if (chat) chat->doTastaturEreignis(te);
}

void TeamAuswahl::render(Bild& zRObj)
{
    if (!alpha) return;
    if (!zRObj.setDrawOptions(0, 0, 700, 600)) return;
    zRObj.setAlpha(alpha);
    if (timer) timer->render(zRObj);
    if (chat) chat->render(zRObj);
    if (liste) liste->render(zRObj);
    zRObj.releaseAlpha();
    zRObj.releaseDrawOptions();
}

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

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

SpielerTeamStruktur* TeamAuswahl::getSTS() const
{
    return sts->getThis();
}

// Event Aktionen
void TeamAuswahlListeSpielerTeamAuswahlE(
    void* p, AuswahlBox* obj, int p1, int p2)
{
    if (!p) return;
    ((TeamAuswahlListeSpieler*)p)->spielerTeamAuswahlE(obj, p1, p2);
}