#include "Spiele.h"
#include <Rahmen.h>
#include <Punkt.h>
#include <DateiSystem.h>
#include <Text.h>
#include "..\..\Global\Initialisierung.h"
#include "..\..\Global\Variablen.h"
#include <InitDatei.h>

// Inhalt der Spiele Klasse aus Spiele.h
// Konstruktor
Spiele::Spiele(Fenster* zNachLoginFenster, int x)
	: Zeichnung()
{
	bildschirmGröße = uiFactory.initParam.bildschirm->getBackBufferSize();
	pos = Punkt(x, 67);
	gr = Punkt(102, 32);
	LTDBDatei* spielenBilder = new LTDBDatei();
	spielenBilder->setDatei(new Text("data/client/bilder/spielen.ltdb"));
	spielenBilder->leseDaten(0);
	rahmen = new LRahmen();
	rahmen->setFarbe(0xFFFFFFFF);
	rahmen->setSize(102, 32);
	spielAuswahl = new SpielAuswahlFenster();
	karteAuswahl = new KarteAuswahlFenster();
	anmeldung = new AngemeldetFenster();
	gruppe = new GruppeFenster();
	teamAuswahl = new TeamAuswahl();
	statistik = new SpielStatistik();
	oben = initKnopf(380, 450, 40, 15, 0, "");
	oben->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	oben->setHintergrundBildZ(spielenBilder->laden(0, new Text("oben.png")));
	initToolTip(oben, "Nach oben umblättern.");
	links = initKnopf(360, 450, 15, 40, 0, "");
	links->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	links->setHintergrundBildZ(spielenBilder->laden(0, new Text("links.png")));
	initToolTip(links, "Zurück.");
	unten = initKnopf(380, 475, 40, 15, 0, "");
	unten->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	unten->setHintergrundBildZ(spielenBilder->laden(0, new Text("unten.png")));
	initToolTip(unten, "Nach unten umblättern.");
	rechts = initKnopf(425, 450, 15, 40, 0, "");
	rechts->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	rechts->setHintergrundBildZ(spielenBilder->laden(0, new Text("rechts.png")));
	initToolTip(rechts, "Weiter.");
	spielenBilder->release();
	alpha = 0;
	ladenAlpha = 0;
	ladenJetzt = 0;
	animation = 0;
	sichtbar = 0;
	tickVal = 0;
	tickVal2 = 0;
	jetzt = 0;
	prozent1 = 0;
	prozent2 = 0;
	prozent3 = 0;
	prozent4 = 0;
	prozent5 = 0;
	prozent6 = 0;
	spielGefundenB = 0;
	begPos = Punkt(0, 0);
	begGröße = Punkt(0, 0);
	größe1 = Punkt(102, 32);
	pos1 = Punkt(x, 67);
	größe2 = Punkt(800, 500);
	pos2 = bildschirmGröße / 2 - größe2 / 2;
	größe3 = Punkt(950, 550);
	pos3 = bildschirmGröße / 2 - größe3 / 2;
	größe4 = Punkt(700, 600);
	pos4 = bildschirmGröße / 2 - größe4 / 2;
	getThis();
	zNachLoginFenster->addMember(this);
}

// Destruktor
Spiele::~Spiele()
{
	rahmen->release();
	spielAuswahl->warteAufThread(10000);
	spielAuswahl->ende();
	spielAuswahl->release();
	karteAuswahl->warteAufThread(10000);
	karteAuswahl->ende();
	karteAuswahl->release();
	anmeldung->release();
	gruppe->release();
	teamAuswahl->release();
	statistik->release();
	oben->release();
	links->release();
	unten->release();
	rechts->release();
}

// nicht constant
void Spiele::setSichtbar(bool sicht)
{
	begPos = pos;
	begGröße = gr;
	animation |= (sicht ? 0x1 : 0x2);
	updateErlaubt();
	rend = 1;
}

void Spiele::updateErlaubt()
{
	if (sichtbar)
	{
		if (jetzt == 1)
			spielAuswahl->updateListe();
		if (jetzt == 2)
			karteAuswahl->updateListe();
	}
}

void Spiele::anmelden(int karteId)
{
	if (anmeldung->setKarteId(karteId))
	{
		karteAuswahl->setSichtbar(0);
		anmeldung->setSichtbar(1);
		jetzt = 3;
	}
}

void Spiele::anmeldungAbbrechen()
{
	anmeldung->setSichtbar(0);
	spielAuswahl->setSichtbar(1);
	jetzt = 1;
}

void Spiele::gruppeBetreten(int gruppeId)
{
	begPos = pos;
	begGröße = gr;
	größe2 = größe3;
	pos2 = pos3;
	gruppe->setGruppeId(gruppeId);
	gruppe->neuerSpieler(loginClient->getAccountId());
	animation |= 0x4;
	spielGefundenB = 0;
}

void Spiele::gruppeVerlassen()
{
	begPos = pos;
	begGröße = gr;
	größe2.x = 800;
	größe2.y = 500;
	pos2 = bildschirmGröße / 2 - größe2 / 2;
	animation |= 0x8;
}

void Spiele::spielerBetrittGruppe(int gruppeId, int accountId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->neuerSpieler(accountId);
}

void Spiele::spielerVerlässtGruppe(int gruppeId, int accountId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->spielerVerlässt(accountId);
}

void Spiele::gruppeNachricht(int gruppeId, const char* nachricht)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->chatNachricht(nachricht);
}

void Spiele::gruppeAnmelden(int gruppeId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->setAngemeldet(1);
}

void Spiele::gruppeAbmelden(int gruppeId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->setAngemeldet(0);
}

void Spiele::setGruppeSpielStarten(int gruppeId, bool spielStarten)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->setSpielerHinzufügen(!spielStarten);
}

void Spiele::setGruppeAdmin(int gruppeId, int admin)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->setAdmin(admin);
	nachLogin->zFreundesListe()->zeigeEinladeKnopf(admin == loginClient->getAccountId());
}

void Spiele::kickAusGruppe(int gruppeId)
{
	if (gruppe->getGruppeId() == gruppeId)
	{
		gruppe->kick();
		gruppeVerlassen();
	}
}

void Spiele::gruppeEinladungNeu(int gruppeId, int accountId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->neueEinladung(accountId);
}

void Spiele::gruppeEinladungAbgebrochen(int gruppeId, int accountId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->einladungEntfernt(accountId);
}

void Spiele::gruppeEinadungAbgelehnt(int gruppeId, int accountId)
{
	if (gruppe->getGruppeId() == gruppeId)
		gruppe->einladungAbgelehnt(accountId);
}

void Spiele::spielGefunden(int karteId)
{
	MausEreignis me;
	me.id = ME_RLinks;
	uiFactory.initParam.bildschirm->lock();
	nachLogin->zTitelLeiste()->druckSpielen(me);
	uiFactory.initParam.bildschirm->unlock();
	if (jetzt == 3)
		anmeldung->setSpielGefunden();
	else if (jetzt == 4)
		gruppe->spielGefunden();
	else
		spielGefundenB = 1;
}

void Spiele::spielGefundenZeitVerbleibend(int sekunden)
{
	if (jetzt == 3)
		anmeldung->setVerbleibendeZeit(sekunden);
	if (jetzt == 4)
		gruppe->verbleibendeZeit(sekunden);
	if (jetzt == 5)
		teamAuswahl->verbleibendeZeit(sekunden);
}

void Spiele::spielGefundenAbbruch()
{
	if (jetzt == 3)
		anmeldung->spielGefundenAbbruch();
	if (jetzt == 4)
		gruppe->spielGefundenAbbruch();
}

void Spiele::zurückInWarteschlange(int stunden, int minuten, int sekunden)
{
	if (jetzt == 3)
		anmeldung->zurückInWarteschlange(stunden, minuten, sekunden);
	if (jetzt == 4)
		gruppe->zurückInWarteschlange(stunden, minuten, sekunden);
}

void Spiele::teamAuswahlBetreten()
{
	begPos = pos;
	begGröße = gr;
	größe2 = größe4;
	pos2 = pos4;
	animation |= 0x10;
}

void Spiele::teamAuswahlInit(SpielerTeamStruktur* sts)
{
	int karteId = 0;
	if (jetzt == 3)
		karteId = anmeldung->getKarteId();
	if (jetzt == 4)
		karteId = gruppe->getKarteId();
	teamAuswahl->setKarteId(karteId);
	teamAuswahl->initSTS(sts);
}

void Spiele::teamAuswahlAddSpieler(int accountId)
{
	teamAuswahl->addSpieler(accountId);
}

void Spiele::teamAuswahlRemoveSpieler(int accountId)
{
	teamAuswahl->removeSpieler(accountId);
}

void Spiele::teamAuswahlSpielerWehseltTeam(int accountId, int spielerNummer)
{
	teamAuswahl->setSpielerNummer(accountId, spielerNummer);
}

void Spiele::teamAuswahlChatNachricht(const char* nachricht)
{
	teamAuswahl->addNachricht(nachricht);
}

void Spiele::teamAuswahlAbbrechen()
{
	begPos = pos;
	begGröße = gr;
	größe2.x = 800;
	größe2.y = 500;
	pos2 = bildschirmGröße / 2 - größe2 / 2;
	animation |= 0x20;
}

void Spiele::statistikNachricht(int län, const char* bytes)
{
	statistik->nachricht(län, bytes);
}

void Spiele::ladeSpielStatistik(int karteId)
{
	pos = pos1;
	gr = größe1;
	größe2 = Punkt(800, 500);
	pos2 = bildschirmGröße / 2 - größe2 / 2;
	teamAuswahl->setSichtbar(0, 1);
	animation = 0;
	sichtbar = 0;
	alpha = 0;
	jetzt = 6;
	statistik->setSpielArt(infoClient->getSpielId(karteId));
	setSichtbar(1);
}

bool Spiele::tick(double tickVal)
{
	rend |= spielAuswahl->tick(tickVal);
	rend |= karteAuswahl->tick(tickVal);
	rend |= anmeldung->tick(tickVal);
	rend |= gruppe->tick(tickVal);
	rend |= teamAuswahl->tick(tickVal);
	rend |= statistik->tick(tickVal);
	rend |= oben->tick(tickVal);
	rend |= rechts->tick(tickVal);
	rend |= unten->tick(tickVal);
	rend |= links->tick(tickVal);
	if (jetzt == 6 && !statistik->istSichtbar())
	{
		spielAuswahl->setSichtbar(1);
		jetzt = 1;
		statistik->reset();
	}
	tickVal2 += tickVal;
	if (tickVal2 >= 1 / 60.0)
	{
		tickVal2 -= 1 / 60.0;
		if (ladenAlpha && ladeAnimation->zAnimationData())
		{
			rend = 1;
			ladenJetzt++;
			if (ladenJetzt >= ladeAnimation->zAnimationData()->getBildAnzahl())
				ladenJetzt = 0;
		}
	}
	this->tickVal += tickVal * 150;
	int val = (int)this->tickVal;
	if (val < 1)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	this->tickVal -= val;
	if ((animation | 0x1) == animation) // Einblenden
	{
		if (prozent1 != 100)
		{
			prozent1 += val;
			if (prozent1 >= 100)
			{
				prozent1 = 100;
				if (!jetzt)
				{
					spielAuswahl->setSichtbar(1);
					jetzt = 1;
				}
			}
			pos = begPos + (Punkt)(((Vec2< double >)(pos2 - begPos) / 100.0) * prozent1);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe2 - begGröße) / 100.0) * prozent1);
		}
		else if (alpha != 255)
		{
			alpha += val * 2;
			if (alpha >= 255 || (animation | 0x2) == animation)
			{
				alpha = 255;
				animation &= ~0x1;
				sichtbar = 1;
				prozent1 = 0;
			}
		}
		rend = 1;
	}
	if ((animation | 0x2) == animation) // ausblenden
	{
		if (alpha != 0)
		{
			alpha -= val * 2;
			if (alpha < 0)
				alpha = 0;
		}
		else
		{
			prozent2 += val;
			if (prozent2 > 100)
				prozent2 = 100;
			pos = begPos + (Punkt)(((Vec2< double >)(pos1 - begPos) / 100.0) * prozent2);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe1 - begGröße) / 100.0) * prozent2);
			if (prozent2 == 100)
			{
				prozent2 = 0;
				animation &= ~0x2;
				sichtbar = 0;
			}
		}
		rend = 1;
	}
	if ((animation | 0x4) == animation) // Gruppe betreten
	{
		if (ladenAlpha < 255 && !prozent3)
		{
			alpha -= val * 3;
			if (alpha < 0)
				alpha = 0;
			ladenAlpha += val * 3;
			if (ladenAlpha >= 255)
			{
				ladenAlpha = 255;
				if (jetzt == 1)
					spielAuswahl->setSichtbar(0);
				if (jetzt == 2)
					karteAuswahl->setSichtbar(0);
				if (jetzt == 6)
					statistik->verlassen();
			}
		}
		else if (ladenAlpha == 255 && prozent3 != 100)
		{
			prozent3 += val;
			if (prozent3 >= 100)
			{
				prozent3 = 100;
				gruppe->setSichtbar(1);
				jetzt = 4;
				if (spielGefundenB)
				{
					spielGefundenB = 0;
					gruppe->spielGefunden();
				}
			}
			pos = begPos + (Punkt)(((Vec2< double >)(pos3 - begPos) / 100.0) * prozent3);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe3 - begGröße) / 100.0) * prozent3);
		}
		else if (prozent3 == 100)
		{
			alpha += val * 3;
			if (alpha > 255)
				alpha = 255;
			ladenAlpha -= val * 3;
			if (ladenAlpha <= 0)
			{
				ladenAlpha = 0;
				animation &= ~0x4;
				prozent3 = 0;
			}
		}
		rend = 1;
	}
	if ((animation | 0x8) == animation) // Gruppe Verlassen
	{
		if (ladenAlpha < 255 && prozent4 == 0)
		{
			alpha -= val * 3;
			if (alpha < 0)
				alpha = 0;
			ladenAlpha += val * 3;
			if (ladenAlpha >= 255)
			{
				ladenAlpha = 255;
				gruppe->setSichtbar(0);
			}
		}
		else if (ladenAlpha == 255 && prozent4 != 100)
		{
			prozent4 += val;
			if (prozent4 >= 100)
			{
				prozent4 = 100;
				spielAuswahl->setSichtbar(1);
				jetzt = 1;
			}
			pos = begPos + (Punkt)(((Vec2< double >)(pos2 - begPos) / 100.0) * prozent4);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe2 - begGröße) / 100.0) * prozent4);
		}
		else if (prozent4 == 100)
		{
			alpha += val * 3;
			if (alpha > 255)
				alpha = 255;
			ladenAlpha -= val * 3;
			if (ladenAlpha <= 0)
			{
				ladenAlpha = 0;
				animation &= ~0x8;
				prozent4 = 0;
			}
		}
		rend = 1;
	}
	if ((animation | 0x10) == animation) // Team Auswahl betreten
	{
		if (ladenAlpha < 255 && !prozent5)
		{
			alpha -= val * 3;
			if (alpha < 0)
				alpha = 0;
			ladenAlpha += val * 3;
			if (ladenAlpha >= 255)
			{
				ladenAlpha = 255;
				if (jetzt == 1)
					spielAuswahl->setSichtbar(0);
				if (jetzt == 2)
					karteAuswahl->setSichtbar(0);
			}
		}
		else if (ladenAlpha == 255 && prozent5 != 100)
		{
			prozent5 += val;
			if (prozent5 >= 100)
			{
				prozent5 = 100;
				gruppe->setSichtbar(0);
				anmeldung->setSichtbar(0);
				teamAuswahl->setSichtbar(1);
				jetzt = 5;
			}
			pos = begPos + (Punkt)(((Vec2< double >)(pos4 - begPos) / 100.0) * prozent5);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe4 - begGröße) / 100.0) * prozent5);
		}
		else if (prozent5 == 100)
		{
			alpha += val * 3;
			if (alpha > 255)
				alpha = 255;
			ladenAlpha -= val * 3;
			if (ladenAlpha <= 0)
			{
				ladenAlpha = 0;
				animation &= ~0x10;
				prozent5 = 0;
			}
		}
		rend = 1;
	}
	if ((animation | 0x20) == animation) // Team Auswahl Verlassen
	{
		if (ladenAlpha < 255 && prozent6 == 0)
		{
			alpha -= val * 3;
			if (alpha < 0)
				alpha = 0;
			ladenAlpha += val * 3;
			if (ladenAlpha >= 255)
			{
				ladenAlpha = 255;
				teamAuswahl->setSichtbar(0);
			}
		}
		else if (ladenAlpha == 255 && prozent6 != 100)
		{
			prozent6 += val;
			if (prozent6 >= 100)
			{
				prozent6 = 100;
				spielAuswahl->setSichtbar(1);
				jetzt = 1;
			}
			pos = begPos + (Punkt)(((Vec2< double >)(pos2 - begPos) / 100.0) * prozent6);
			gr = begGröße + (Punkt)(((Vec2< double >)(größe2 - begGröße) / 100.0) * prozent6);
		}
		else if (prozent6 == 100)
		{
			alpha += val * 3;
			if (alpha > 255)
				alpha = 255;
			ladenAlpha -= val * 3;
			if (ladenAlpha <= 0)
			{
				ladenAlpha = 0;
				animation &= ~0x20;
				prozent6 = 0;
			}
		}
		rend = 1;
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void Spiele::doPublicMausEreignis(MausEreignis& me)
{
	if (!sichtbar)
		return;
	if (animation)
		return;
	int mx = me.mx;
	int my = me.my;
	me.mx -= pos.x;
	me.my -= pos.y;
	int ak = 0;
	bool tmp = me.verarbeitet;
	oben->doPublicMausEreignis(me);
	ak = me.verarbeitet ? 1 : 0;
	links->doPublicMausEreignis(me);
	ak = me.verarbeitet && !ak ? 2 : ak;
	unten->doPublicMausEreignis(me);
	ak = me.verarbeitet && !ak ? 3 : ak;
	rechts->doPublicMausEreignis(me);
	ak = me.verarbeitet && !ak ? 4 : ak;
	if (tmp)
		ak = 0;
	switch (jetzt)
	{
	case 1: // Spiel Auswahl
		if (spielAuswahl)
		{
			spielAuswahl->doPublicMausEreignis(me);
			if (spielAuswahl->hatAuswahl() && spielAuswahl->istAuswahlErlubt())
				rechts->addStyle(Knopf::Style::Erlaubt);
			else
				rechts->removeStyle(Knopf::Style::Erlaubt);
			if (!spielAuswahl->getSeite())
				oben->removeStyle(Knopf::Style::Erlaubt);
			else
				oben->addStyle(Knopf::Style::Erlaubt);
			if (spielAuswahl->getSeite() < spielAuswahl->getSeiteAnzahl() - 1)
				unten->addStyle(Knopf::Style::Erlaubt);
			else
				unten->removeStyle(Knopf::Style::Erlaubt);
			links->removeStyle(Knopf::Style::Erlaubt);
			if (me.id != ME_RLinks)
				break;
			switch (ak)
			{
			case 1: // oben Klick
				spielAuswahl->blättern(1);
				break;
			case 3: // unten Klick
				spielAuswahl->blättern(0);
				break;
			case 4: // rehts Klick
				if (rechts->hatStyle(Knopf::Style::Erlaubt))
				{
					karteAuswahl->setSpielId(spielAuswahl->zAuswahl()->getSpielId());
					spielAuswahl->setSichtbar(0);
					karteAuswahl->setSichtbar(1);
					jetzt = 2;
				}
				break;
			}
		}
		break;
	case 2: // Karten Auswahl
		if (karteAuswahl)
		{
			karteAuswahl->doPublicMausEreignis(me);
			rechts->removeStyle(Knopf::Style::Erlaubt);
			if (!karteAuswahl->getSeite())
				oben->removeStyle(Knopf::Style::Erlaubt);
			else
				oben->addStyle(Knopf::Style::Erlaubt);
			if (karteAuswahl->getSeite() < karteAuswahl->getSeiteAnzahl() - 1)
				unten->addStyle(Knopf::Style::Erlaubt);
			else
				unten->removeStyle(Knopf::Style::Erlaubt);
			links->addStyle(Knopf::Style::Erlaubt);
			if (me.id != ME_RLinks)
				break;
			switch (ak)
			{
			case 1: // oben Klick
				karteAuswahl->blättern(1);
				break;
			case 2: // links Klick
				karteAuswahl->setSichtbar(0);
				spielAuswahl->setSichtbar(1);
				jetzt = 1;
				break;
			case 3: // unten Klick
				karteAuswahl->blättern(0);
				break;
			}
		}
		break;
	case 3: // Anmeldung
		anmeldung->doPublicMausEreignis(me);
		break;
	case 4: // Gruppe
		gruppe->doPublicMausEreignis(me);
		break;
	case 5: // TeamAuswahl
		teamAuswahl->doPublicMausEreignis(me);
		break;
	case 6:
		statistik->doPublicMausEreignis(me);
		break;
	}
	me.mx = mx;
	me.my = my;
}

void Spiele::doTastaturEreignis(TastaturEreignis& te)
{
	if (!sichtbar)
		return;
	switch (jetzt)
	{
	case 1:

		break;
	case 2:

		break;
	case 3:

		break;
	case 4:
		gruppe->doTastaturEreignis(te);
		break;
	case 5:
		teamAuswahl->doTastaturEreignis(te);
		break;
	case 6:
		statistik->doTastaturEreignis(te);
	}
}

void Spiele::render(Bild& zRObj)
{
	if (pos == pos1)
		return;
	int x = pos.x;
	int y = pos.y;
	int br = gr.x;
	int hö = gr.y;
	if (!zRObj.setDrawOptions(x, y, br, hö))
		return;
	rahmen->setSize(br, hö);
	rahmen->render(zRObj);
	int rbr = rahmen->getRBreite();
	zRObj.setAlpha((unsigned char)alpha);
	if (jetzt == 1 || jetzt == 2)
	{
		oben->render(zRObj);
		links->render(zRObj);
		unten->render(zRObj);
		rechts->render(zRObj);
	}
	if (!zRObj.setDrawOptions(rbr, rbr, br - rbr * 2, hö - rbr * 2))
	{
		zRObj.releaseDrawOptions();
		zRObj.releaseAlpha();
		return;
	}
	if (jetzt != 4 && jetzt != 5)
	{
		spielAuswahl->render(zRObj);
		karteAuswahl->render(zRObj);
		anmeldung->render(zRObj);
	}
	if (jetzt != 5)
		gruppe->render(zRObj);
	teamAuswahl->render(zRObj);
	statistik->render(zRObj);
	zRObj.releaseDrawOptions();
	zRObj.releaseAlpha();
	if (ladenAlpha && ladeAnimation->zAnimationData())
	{
		zRObj.setAlpha(ladenAlpha);
		zRObj.drawBild(br / 2 - 25, hö / 2 - 25, 50, 50, *ladeAnimation->zAnimationData()->zBild(ladenJetzt));
		zRObj.releaseAlpha();
	}
	zRObj.releaseDrawOptions();
}

// constant
bool Spiele::istAnimiert() const
{
	return animation != 0;
}

bool Spiele::istSichtbar() const
{
	return sichtbar || prozent1 != 0;
}

int Spiele::getKarteId() const
{
	if (jetzt == 3)
		return anmeldung->getKarteId();
	if (jetzt == 4)
		return gruppe->getKarteId();
	if (jetzt == 5)
		return teamAuswahl->getKarteId();
	return 0;
}

int Spiele::getGruppeId() const
{
	return gruppe->getGruppeId();
}

SpielerTeamStruktur* Spiele::getSTS() const
{
	if (jetzt == 5)
		return teamAuswahl->getSTS();
	return 0;
}