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

#include "TeamAuswahl.h"
#include "..\..\..\Global\Initialisierung.h"
#include "..\..\..\Global\Variablen.h"
#include <DateiSystem.h>
#include <Rahmen.h>
#include <AlphaFeld.h>
#include <AuswahlBox.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.taste == 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);
}