3DTest/3DTest/NachLogin/Spiele/Gruppe/Gruppe.cpp

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

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

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

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

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

void GruppeEinladungAccount::setGröße( 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 == loginKlient->getAccountId() && !status )
		{
			if( knopfX > br - 60 )
			{
				knopfX -= val;
				if( knopfX < br - 60 )
					knopfX = br - 60;
				rend = 1;
			}
		}
		else if( admin == loginKlient->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::doMausEreignis( 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->doMausEreignis( me );
	int aktion = ( me.verarbeitet && ak ) ? 1 : 0;
	erneutSenden->doMausEreignis( me );
	aktion = ( me.verarbeitet && ak && !aktion ) ? 2 : aktion;
	einladungAbbrechen->doMausEreignis( 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( !anmeldungKlient->gruppeSpielerEinladen( accountId, gruppeId ) )
		{
			nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
														  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
		}
		break;
	case 3:
		if( !anmeldungKlient->gruppeEinladungAbbrechen( accountId, gruppeId ) )
		{
			nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
														  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
		}
		break;
	}
}

void GruppeEinladungAccount::render( int y, Bild &zrObj )
{
	if( !zrObj.setDrawOptions( 0, y, br, höhe ) )
		return;
	rahmen->setGröße( 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->setGröße( 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::getHöhe() const
{
	return höhe;
}

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

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

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

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

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

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

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

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

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

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

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

bool GruppeEinladungListe::tick( double tickVal )
{
	rend |= einladenName->tick( tickVal );
	rend |= einladen->tick( tickVal );
	rend |= scroll->getRend();
	this->tickVal += tickVal * 100;
	int val = ( int )this->tickVal;
	if( val < 1 )
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	if( val > 4 )
		val = 4;
	this->tickVal -= val;
	if( admin == loginKlient->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->getHöhe() )
		{
			accounts->lösche( i );
			anzahl--;
			rend = 1;
		}
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void GruppeEinladungListe::doMausEreignis( MausEreignis &me )
{
	int tmpX = me.mx;
	int tmpY = me.my;
	me.mx -= pos.x;
	me.my -= pos.y;
	if( einladungHöhe == 30 )
	{
		einladenName->doMausEreignis( me );
		bool ak = !me.verarbeitet;
		einladen->doMausEreignis( me );
		if( me.verarbeitet && ak )
		{
			if( me.id == ME_RLinks )
			{
				if( einladenName->zText()->getLänge() )
				{
					int accountId = infoKlient->getAccountId( einladenName->zText()->getText() );
					if( accountId )
					{
						if( !anmeldungKlient->gruppeSpielerEinladen( accountId, gruppeId ) )
						{
							nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
																		  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
						}
						else
						{
							einladenName->setText( "" );
							einladenName->setAuswahl( 0, 0 );
							rend = 1;
						}
					}
					else
					{
						nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Der Account wurde nicht gefunden." ),
																	  new Text( "Ok" ), 0, NachrichtType::nachricht, 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->doMausEreignis( me );
			if( tmp->getRemove() )
			{
				accounts->lösche( i );
				anzahl--;
				rend = 1;
			}
			me.my -= tmp->getHöhe();
		}
	}
	me.mx = tmpX;
	me.my = tmpY;
}

void GruppeEinladungListe::doTastaturEreignis( TastaturEreignis &te )
{
	bool b = !te.verarbeitet;
	einladenName->doTastaturEreignis( te );
	if( te.verarbeitet && b && te.id == TE_Release && te.taste == T_Enter )
	{
		if( einladenName->zText()->getLänge() )
		{
			int accountId = infoKlient->getAccountId( einladenName->zText()->getText() );
			if( accountId )
			{
				if( !anmeldungKlient->gruppeSpielerEinladen( accountId, gruppeId ) )
				{
					nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
																  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
				}
				else
				{
					einladenName->setText( "" );
					einladenName->setAuswahl( 0, 0 );
					rend = 1;
				}
			}
			else
			{
				nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Der Account wurde nicht gefunden." ),
															  new Text( "Ok" ), 0, NachrichtType::nachricht, 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->setGröße( gr.x - 15 - rbr * 2 );
			tmp->render( höhe - scroll->getScrollData()->anzeigeBeginn, zRObj );
			höhe += tmp->getHöhe();
		}
	}
	scroll->update( höhe, gr.y - rbr * 2 - einladungHöhe );
	zRObj.releaseDrawOptions();
	zRObj.releaseDrawOptions();
}

// constant

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

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

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

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

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

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

void GruppeAccountDaten::setGröße( 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 != loginKlient->getAccountId() )
		{
			if( nachrichtSenden->getBreite() < 20 )
			{
				nachrichtSenden->setGröße( nachrichtSenden->getBreite() + val, nachrichtSenden->getHöhe() );
				if( nachrichtSenden->getBreite() > 20 )
					nachrichtSenden->setGröße( 20, nachrichtSenden->getHöhe() );
				rend = 1;
			}
		}
		else
		{
			if( nachrichtSenden->getBreite() > 0 )
			{
				nachrichtSenden->setGröße( nachrichtSenden->getBreite() - val, nachrichtSenden->getHöhe() );
				if( nachrichtSenden->getBreite() < 0 )
					nachrichtSenden->setGröße( 0, nachrichtSenden->getHöhe() );
				rend = 1;
			}
		}
		if( accountAnsehen->getBreite() < 20 )
		{
			accountAnsehen->setGröße( accountAnsehen->getBreite() + val, accountAnsehen->getHöhe() );
			if( accountAnsehen->getBreite() > 20 )
				accountAnsehen->setGröße( 20, accountAnsehen->getHöhe() );
			rend = 1;
		}
		if( accountId == loginKlient->getAccountId() || nachLogin->zFreundesListe()->istFreund( accountId ) )
		{
			if( freundEinladung->getBreite() > 0 )
			{
				freundEinladung->setGröße( freundEinladung->getBreite() - val, freundEinladung->getHöhe() );
				if( freundEinladung->getBreite() < 0 )
					freundEinladung->setGröße( 0, freundEinladung->getHöhe() );
				rend = 1;
			}
		}
		else
		{
			if( freundEinladung->getBreite() < 20 )
			{
				freundEinladung->setGröße( freundEinladung->getBreite() + val, freundEinladung->getHöhe() );
				if( freundEinladung->getBreite() > 20 )
					freundEinladung->setGröße( 20, freundEinladung->getHöhe() );
				rend = 1;
			}
		}
		if( accountId == loginKlient->getAccountId() || admin != loginKlient->getAccountId() )
		{
			if( kick->getBreite() > 0 )
			{
				kick->setGröße( kick->getBreite() - val, kick->getHöhe() );
				if( kick->getBreite() < 0 )
					kick->setGröße( 0, kick->getHöhe() );
				rend = 1;
			}
		}
		else
		{
			if( kick->getBreite() < 20 )
			{
				kick->setGröße( kick->getBreite() + val, kick->getHöhe() );
				if( kick->getBreite() > 20 )
					kick->setGröße( 20, kick->getHöhe() );
				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::doMausEreignis( 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->doMausEreignis( me );
	int aktion = ( me.verarbeitet && ak ) ? 1 : 0;
	accountAnsehen->doMausEreignis( me );
	aktion = ( me.verarbeitet && ak && !aktion ) ? 2 : aktion;
	freundEinladung->doMausEreignis( me );
	aktion = ( me.verarbeitet && ak && !aktion ) ? 3 : aktion;
	kick->doMausEreignis( 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, 0, 0 };
			nachLogin->zTitelLeiste()->druckAccountAnsehen( me );
		}
		break;
	case 3:
		chatKlient->freundesAnfrage( accountId );
		break;
	case 4:
		if( !anmeldungKlient->kickSpielerAusGruppe( accountId, gruppeId ) )
		{
			nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
														  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
		}
		break;
	}
}

void GruppeAccountDaten::render( int y, Bild &zrObj )
{
	if( !zrObj.setDrawOptions( 0, y, br, höhe ) )
		return;
	rahmen->setGröße( br, höhe );
	rahmen->render( zrObj );
	int rbr = rahmen->getRBreite();
	auswahl->setPosition( rbr, rbr );
	auswahl->setGröße( 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::getHöhe() const
{
	return höhe;
}

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

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

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

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

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

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

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

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

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

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

void GruppeAccountListe::doMausEreignis( 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->doMausEreignis( me );
			if( tmp->getRemove() )
			{
				accounts->lösche( i );
				anzahl--;
				rend = 1;
			}
			me.my -= tmp->getHöhe();
		}
	}
	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->setGröße( gr.x - 15 - rbr * 2 );
			tmp->render( höhe - scroll->getScrollData()->anzeigeBeginn, zRObj );
			höhe += tmp->getHöhe();
		}
	}
	zRObj.releaseDrawOptions();
	zRObj.releaseDrawOptions();
	scroll->update( höhe, gr.y - rbr * 2 );
}

// constant

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

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

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

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

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

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

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

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

void GruppeChat::doMausEreignis( MausEreignis &me )
{
	me.mx -= pos.x;
	me.my -= pos.y;
	verlauf->doMausEreignis( me );
	nachricht->doMausEreignis( me );
	bool ak = !me.verarbeitet;
	senden->doMausEreignis( 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( anmeldungKlient->gruppeNachricht( gruppeId, nachricht->zText()->getText() ) )
		{
			nachricht->setText( "" );
			nachricht->setAuswahl( 0, 0 );
			rend = 1;
		}
		else
		{
			nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
														  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
		}
	}
	me.mx += pos.x;
	me.my += pos.y;
}

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

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

// constant

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

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

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

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

// nicht constant
void GruppeAnmeldung::reset()
{
	spielerHinzufügen->löscheStyle( KontrollKnopf::Style::Selected );
	angemeldet->löscheStyle( 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, infoKlient->getGruppeSpielerHinzufügen( gruppeId ) );
	rend = 1;
}

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

void GruppeAnmeldung::setSpielerHinzufügen( bool spielerHinzufügen )
{
	this->spielerHinzufügen->setStyle( KontrollKnopf::Style::Selected, spielerHinzufügen );
	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 );
	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()->anhängen( (int)( time / 60 / 60 ) );
		zeit->zText()->anhängen( ":" );
		zeit->zText()->anhängen( (int)( time / 60 ) % 60 );
		zeit->zText()->anhängen( ":" );
		zeit->zText()->anhängen( (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::doMausEreignis( MausEreignis &me )
{
	me.mx -= pos.x;
	me.my -= pos.y;
	bool ak = !me.verarbeitet;
	int aktion = 0;
	if( admin == loginKlient->getAccountId() )
	{
		spielerHinzufügen->doMausEreignis( me );
		aktion = ( me.verarbeitet && admin == loginKlient->getAccountId() && ak ) ? 1 : aktion;
		angemeldet->doMausEreignis( me );
		aktion = ( me.verarbeitet && admin == loginKlient->getAccountId() && ak && !aktion ) ? 2 : aktion;
	}
	gruppeVerlassen->doMausEreignis( 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( !anmeldungKlient->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( anmeldungKlient->getLetzterFehler() ),
														  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
		}
		break;
	case 2:
		if( angemeldet->hatStyle( KontrollKnopf::Style::Selected ) )
		{
			if( !anmeldungKlient->gruppeAnmelden( gruppeId ) )
			{
				angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet->hatStyleNicht( KontrollKnopf::Style::Selected ) );
				rend = 1;
				nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
															  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
			}
		}
		else
		{
			if( !anmeldungKlient->gruppeAbmelden( gruppeId ) )
			{
				angemeldet->setStyle( KontrollKnopf::Style::Selected, angemeldet->hatStyleNicht( KontrollKnopf::Style::Selected ) );
				rend = 1;
				nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
															  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
			}
		}
		break;
	case 3:
		if( anmeldungKlient->gruppeVerlassen( gruppeId ) )
			nachLogin->zSpielenFenster()->gruppeVerlassen();
		else
		{
			nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( anmeldungKlient->getLetzterFehler() ),
														  new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
		}
		break;
	}
	me.mx += pos.x;
	me.my += pos.y;
}

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

// constant

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

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

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

// Inhalt der GruppeKarte Klasse aus Gruppe.h
// Konstruktor
GruppeKarte::GruppeKarte( Schrift *zSchrift )
{
	schrift = zSchrift;
	pos = Punkt( 350, 0 );
	gr = Punkt( 600, 350 );
	rahmen = new LRahmen();
	rahmen->setFarbe( 0xFFFFFFFF );
	rahmen->setRamenBreite( 1 );
	rahmen->setGröße( 350, 350 );
	rahmen->setPosition( 248, 0 );
    info = 0;
    ksgs = dllDateien->ladeDLL( "KSGScript.dll", "data/bin/KSGScript.dll" );
    if( ksgs )
    {
        KSGSGetZeichnung getKSGScript = (KSGSGetZeichnung)GetProcAddress( ksgs, KSGS_START_FUNKTION );
        if( getKSGScript )
        {
            info = getKSGScript();
            info->setBildschirmZ( hauptScreen->getThis() );
            info->setSchriftZ( schrift->getThis() );
            info->setGröße( 248, 350 );
            info->setRückrufParam( this );
            info->setRückrufFunktion( GruppeKarteKSGSAktion );
        }
        else
        {
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ),
                                                          new Text( "Der Einstiegspunkt '" KSGS_START_FUNKTION "' in der DLL-Datei "
                                                          "'data/bin/KSGScript.dll' konnte nicht gefunden werden." ),
                                                          new Text( "Ok" ), 0, NachrichtType::nachricht, 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, NachrichtType::nachricht, 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;
	ref = 1;
}

// Destruktor
GruppeKarte::~GruppeKarte()
{
	exit = 1;
	warteAufThread( 5000 );
	if( run )
		ende();
	rahmen->release();
    if( info )
    {
        info->zurücksetzen();
        info->release();
    }
	if( hintergrund )
		hintergrund->release();
	if( fehler )
		fehler->release();
	if( schrift )
		schrift->release();
    if( ksgs )
        dllDateien->releaseDLL( "KSGScript.dll" );
}

// nicht constant
void GruppeKarte::reset()
{
    if( info )
        info->zurücksetzen();
	if( hintergrund )
		hintergrund = hintergrund->release();
	if( fehler )
		fehler = 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::doMausEreignis( MausEreignis &me )
{
	me.mx -= pos.x;
	me.my -= pos.y;
    if( info )
        info->doMausEreignis( 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->getHöhe() / 2, tmp->getBreite(), tmp->getHöhe(), *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->getHöhe() - rahmen->getRBreite() * 2, *hintergrund );
		}
		else if( fehler )
			fehler->render( zrObj );
		zrObj.releaseAlpha();
	}
	zrObj.releaseDrawOptions();
}

void GruppeKarte::thread()
{
    if( info )
        info->zurücksetzen();
	if( hintergrund )
		hintergrund = hintergrund->release();
	if( fehler )
		fehler = fehler->release();
	karteId = infoKlient->getGruppenKarteId( gruppeId );
	if( !karteId )
	{
		run = 0;
		return;
	}
	KartenLeser *karte = new KartenLeser();
	karte->setKarteId( karteId );
	hintergrund = karte->getKartenVorschauBild();
	if( exit )
	{
		if( hintergrund )
			hintergrund = hintergrund->release();
		karte->release();
		run = 0;
		return;
	}
	if( !hintergrund )
	{
		Text *f = new Text( karte->getLetzterFehler() );
		schrift->lock();
		schrift->setSchriftGröße( 12 );
		int br = schrift->getTextBreite( f );
		int hö = schrift->getTextHöhe( f );
		schrift->unlock();
		fehler = initTextFeld( gr.x / 2 - ( br + 10 ) / 2, gr.y / 2 - ( hö + 4 ) / 2, br + 10, hö + 4,
							   schrift, TextFeld::Style::Text | TextFeld::Style::Center, f->getText() );
		f->release();
		karte->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() );
		schrift->lock();
		schrift->setSchriftGröße( 12 );
		int br = schrift->getTextBreite( f );
		int hö = schrift->getTextHöhe( f );
		schrift->unlock();
		fehler = initTextFeld( gr.x / 2 - ( br + 10 ) / 2, gr.y / 2 - ( hö + 4 ) / 2, br + 10, hö + 4,
							   schrift, TextFeld::Style::Text | TextFeld::Style::Center, f->getText() );
		f->release();
		karte->release();
		run = 0;
		return;
	}
	karte->release();
	geladen = 1;
	run = 0;
	rend = 1;
}

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

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

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

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

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

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

void GruppeSpielGefunden::setSichtbar( bool sichtbar )
{
	warte->löscheStyle( 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()->anhängen( (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::doMausEreignis( MausEreignis &me )
{
	me.mx -= pos.x;
	me.my -= pos.y;
	bool ver = me.verarbeitet;
	annehmen->doMausEreignis( me );
	if( me.verarbeitet && !ver && me.id == ME_RLinks )
	{
		if( spielKlient->spielErstelltAnnehmen() )
		{
			annehmen->löscheStyle( Knopf::Style::Sichtbar );
			warte->addStyle( TextFeld::Style::Sichtbar );
			rend = 1;
		}
		else if( nachLogin && nachLogin->zSpielenFenster() )
			nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( spielKlient->getLetzterFehler() ), new Text( "Ok" ), 0, NachrichtType::nachricht, 0 );
	}
	me.mx += pos.x;
	me.my += pos.y;
}

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

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

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

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

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

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

// nicht constant
void GruppeFenster::setGruppeId( int id )
{
	gruppeId = id;
	anmeldung->setGruppeId( id );
	chat->setGruppeId( id );
	accounts->setGruppeId( id );
	einladungen->setGruppeId( id );
	karte->setGruppeId( id );
	spiel->setSichtbar( 0 );
	if( id )
	{
		int adminId = infoKlient->getGruppeAdminId( id );
		nachLogin->zFreundesListe()->zeigeEinladeKnopf( adminId == loginKlient->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::doMausEreignis( MausEreignis &me )
{
	if( !spiel->istSichtbar() )
	{
		anmeldung->doMausEreignis( me );
		chat->doMausEreignis( me );
		accounts->doMausEreignis( me );
		einladungen->doMausEreignis( me );
		karte->doMausEreignis( me );
	}
	spiel->doMausEreignis( me );
}

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

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

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

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

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

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