use framework reference counter

SpielServer/Datenbank.cpp

@@ -7,18 +7,18 @@
 // Inhalt der SSDatenbank Klasse aus Datenbank.h
 // Konstruktor
 SSDatenbank::SSDatenbank( InitDatei *zIni )
+    : ReferenceCounter()
 {
-	datenbank = new Datenbank( zIni->zWert( "DBBenutzer" )->getText(), zIni->zWert( "DBPasswort" )->getText(),
-							   zIni->zWert( "DBName" )->getText(), zIni->zWert( "DBIP" )->getText(),
-							   (unsigned short)TextZuInt( zIni->zWert( "DBPort" )->getText(), 10 ) );
+    datenbank = new Datenbank( zIni->zWert( "DBBenutzer" )->getText(), zIni->zWert( "DBPasswort" )->getText(),
+                               zIni->zWert( "DBName" )->getText(), zIni->zWert( "DBIP" )->getText(),
+                               (unsigned short)TextZuInt( zIni->zWert( "DBPort" )->getText(), 10 ) );
     if( !datenbank->istOk() )
     {
         std::cout << "SS: Die Verbindung zur Datenbank konnte nicht hergestellt werden.\nDas Programm wird beendet.";
         exit( 1 );
     }
-	InitializeCriticalSection( &cs );
-    ini = zIni->getThis();
-	ref = 1;
+    InitializeCriticalSection( &cs );
+    ini = dynamic_cast<InitDatei *>( zIni->getThis() );
     Text befehl = "SELECT port, admin_port, ip FROM server WHERE id = ";
     befehl += zIni->zWert( "ServerId" )->getText();
     lock();
@@ -37,1003 +37,1003 @@ SSDatenbank::SSDatenbank( InitDatei *zIni )
 // Destruktor
 SSDatenbank::~SSDatenbank()
 {
-	datenbank->release();
-	DeleteCriticalSection( &cs );
+    datenbank->release();
+    DeleteCriticalSection( &cs );
     ini->release();
 }
 
 // nicht constant
 void SSDatenbank::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void SSDatenbank::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 Text *SSDatenbank::getKlientKey( int cId )
 {
-	lock();
-	if( !datenbank->befehl( Text( "SELECT schluessel FROM client WHERE id = " ) += cId ) )
-	{
-		unlock();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	Text *ret = new Text( res.values[ 0 ].getText() );
-	res.destroy();
-	return ret;
+    lock();
+    if( !datenbank->befehl( Text( "SELECT schluessel FROM client WHERE id = " ) += cId ) )
+    {
+        unlock();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    Text *ret = new Text( res.values[ 0 ].getText() );
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::istAdministrator( const char *name, const char *passwort )
 {
-	Text *befehl = new Text( "SELECT id FROM benutzer WHERE name = '" );
-	Text n( name );
-	n.ersetzen( "'", "''" );
-	befehl->append( (char*)n );
-	befehl->append( "' AND passwort = md5( '" );
-	Text p( passwort );
-	p.ersetzen( "'", "''" );
-	befehl->append( (char*)p );
-	befehl->append( "' )" );
-	lock();
-	datenbank->befehl( befehl->getText() );
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	int ret = 0;
-	if( res.zeilenAnzahl > 0 )
-		ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    Text *befehl = new Text( "SELECT id FROM benutzer WHERE name = '" );
+    Text n( name );
+    n.ersetzen( "'", "''" );
+    befehl->append( (char *)n );
+    befehl->append( "' AND passwort = md5( '" );
+    Text p( passwort );
+    p.ersetzen( "'", "''" );
+    befehl->append( (char *)p );
+    befehl->append( "' )" );
+    lock();
+    datenbank->befehl( befehl->getText() );
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    int ret = 0;
+    if( res.zeilenAnzahl > 0 )
+        ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 bool SSDatenbank::adminHatRecht( int id, int recht )
 {
-	Text *befehl = new Text( "SELECT * FROM benutzer_rechte WHERE benutzer_id = " );
-	befehl->append( id );
-	befehl->append( " AND rechte_id = " );
-	befehl->append( recht );
-	lock();
-	datenbank->befehl( befehl->getText() );
-	int ret = datenbank->getZeilenAnzahl();
-	unlock();
-	befehl->release();
-	return ret != 0;
+    Text *befehl = new Text( "SELECT * FROM benutzer_rechte WHERE benutzer_id = " );
+    befehl->append( id );
+    befehl->append( " AND rechte_id = " );
+    befehl->append( recht );
+    lock();
+    datenbank->befehl( befehl->getText() );
+    int ret = datenbank->getZeilenAnzahl();
+    unlock();
+    befehl->release();
+    return ret != 0;
 }
 
 bool SSDatenbank::setServerStatus( int id, int status )
 {
-	Text *befehl = new Text( "UPDATE server SET server_status_id = " );
-	*befehl += status;
-	*befehl += "WHERE id = ";
-	*befehl += id;
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	bool ret = datenbank->getZeilenAnzahl() != 0;
-	unlock();
-	befehl->release();
-	return ret;
+    Text *befehl = new Text( "UPDATE server SET server_status_id = " );
+    *befehl += status;
+    *befehl += "WHERE id = ";
+    *befehl += id;
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    bool ret = datenbank->getZeilenAnzahl() != 0;
+    unlock();
+    befehl->release();
+    return ret;
 }
 
 bool SSDatenbank::setMaxSpiele( int id, int maxS )
 {
-	Text *befehl = new Text( "UPDATE server SET max_tasks = " );
-	befehl->append( maxS );
-	befehl->append( " WHERE id = " );
-	befehl->append( id );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	bool ret = datenbank->getZeilenAnzahl() > 0;
-	unlock();
-	befehl->release();
-	return ret;
+    Text *befehl = new Text( "UPDATE server SET max_tasks = " );
+    befehl->append( maxS );
+    befehl->append( " WHERE id = " );
+    befehl->append( id );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    bool ret = datenbank->getZeilenAnzahl() > 0;
+    unlock();
+    befehl->release();
+    return ret;
 }
 
 bool SSDatenbank::serverIstNichtPausiert( int id )
 {
-	Text *befehl = new Text( "SELECT server_status_id FROM server WHERE id = " );
-	befehl->append( id );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	bool ret = (int)res.values[ 0 ] == 3;
-	res.destroy();
-	return ret;
+    Text *befehl = new Text( "SELECT server_status_id FROM server WHERE id = " );
+    befehl->append( id );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    bool ret = (int)res.values[ 0 ] == 3;
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::getAccountId( int clientId )
 {
-	if( !clientId )
-		return 0;
-	Text *befehl = new Text( "SELECT account_id FROM account_client WHERE client_id = " );
-	befehl->append( clientId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    if( !clientId )
+        return 0;
+    Text *befehl = new Text( "SELECT account_id FROM account_client WHERE client_id = " );
+    befehl->append( clientId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 Text *SSDatenbank::getSpielArtName( int spielId )
 {
-	if( !spielId )
-		return new Text( "" );
-	Text *befehl = new Text( "SELECT name FROM spiel_art WHERE id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return new Text( "" );
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return new Text( "" );
-	}
-	Text *ret = new Text( res.values[ 0 ].getText() );
-	res.destroy();
-	return ret;
+    if( !spielId )
+        return new Text( "" );
+    Text *befehl = new Text( "SELECT name FROM spiel_art WHERE id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return new Text( "" );
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return new Text( "" );
+    }
+    Text *ret = new Text( res.values[ 0 ].getText() );
+    res.destroy();
+    return ret;
 }
 
 Text *SSDatenbank::getKarteName( int karteId )
 {
-	if( !karteId )
-		return new Text( "Inoffiziell" );
-	Text *befehl = new Text( "SELECT name FROM karte WHERE id = " );
-	befehl->append( karteId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return new Text( "Inoffiziell" );
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return new Text( "Inoffiziell" );
-	}
-	Text *ret = new Text( res.values[ 0 ].getText() );
-	res.destroy();
-	return ret;
+    if( !karteId )
+        return new Text( "Inoffiziell" );
+    Text *befehl = new Text( "SELECT name FROM karte WHERE id = " );
+    befehl->append( karteId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return new Text( "Inoffiziell" );
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return new Text( "Inoffiziell" );
+    }
+    Text *ret = new Text( res.values[ 0 ].getText() );
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::getSpielArtId( int karteId )
 {
-	if( !karteId )
-		return 0;
-	Text *befehl = new Text( "SELECT spiel_art_id FROM karte WHERE id = " );
-	befehl->append( karteId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    if( !karteId )
+        return 0;
+    Text *befehl = new Text( "SELECT spiel_art_id FROM karte WHERE id = " );
+    befehl->append( karteId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::erstelleSpiel( int serverId )
 {
-	if( !serverId )
-		return 0;
-	Text *befehl = new Text( "SELECT such_spieler_fuer_spiel( " );
-	befehl->append( serverId );
-	befehl->append( ")" );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    if( !serverId )
+        return 0;
+    Text *befehl = new Text( "SELECT such_spieler_fuer_spiel( " );
+    befehl->append( serverId );
+    befehl->append( ")" );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 bool SSDatenbank::deleteSpielErstelltNext( int serverId )
 {
-	if( !serverId )
-		return 0;
-	Text *befehl = new Text( "DELETE FROM server_spiel_next WHERE server_spiel_id = " );
-	befehl->append( serverId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->release();
-	return 1;
+    if( !serverId )
+        return 0;
+    Text *befehl = new Text( "DELETE FROM server_spiel_next WHERE server_spiel_id = " );
+    befehl->append( serverId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->release();
+    return 1;
 }
 
 int SSDatenbank::getSpielErstelltId( int serverId )
 {
-	if( !serverId )
-		return 0;
-	Text *befehl = new Text( "SELECT spiel_erstellt_id FROM server_spiel_next WHERE server_spiel_id = " );
-	befehl->append( serverId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    if( !serverId )
+        return 0;
+    Text *befehl = new Text( "SELECT spiel_erstellt_id FROM server_spiel_next WHERE server_spiel_id = " );
+    befehl->append( serverId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::getSpielErstelltSpieler( int spielErstelltId, Array< int > *accountIds )
 {
-	if( !spielErstelltId )
-		return 0;
-	Text *befehl = new Text( "SELECT a.account_id FROM spiel_erstellt_spieler a WHERE a.spiel_erstellt_id = " );
-	befehl->append( spielErstelltId );
-	befehl->append( " UNION SELECT a.account_id FROM gruppe_spieler a, spiel_erstellt_gruppe b WHERE a.gruppe_id = b.gruppe_id AND b.spiel_erstellt_id = " );
-	befehl->append( spielErstelltId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	int ret = res.zeilenAnzahl;
-	for( int i = 0; i < ret; i++ )
-		accountIds->set( TextZuInt( res.values[ i ].getText(), 10 ), i );
-	res.destroy();
-	return ret;
+    if( !spielErstelltId )
+        return 0;
+    Text *befehl = new Text( "SELECT a.account_id FROM spiel_erstellt_spieler a WHERE a.spiel_erstellt_id = " );
+    befehl->append( spielErstelltId );
+    befehl->append( " UNION SELECT a.account_id FROM gruppe_spieler a, spiel_erstellt_gruppe b WHERE a.gruppe_id = b.gruppe_id AND b.spiel_erstellt_id = " );
+    befehl->append( spielErstelltId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    int ret = res.zeilenAnzahl;
+    for( int i = 0; i < ret; i++ )
+        accountIds->set( TextZuInt( res.values[ i ].getText(), 10 ), i );
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::getKarteVonErstelltemSpiel( int spielErstelltId )
 {
-	if( !spielErstelltId )
-		return 0;
-	Text *befehl = new Text( "SELECT karte_id FROM spiel_erstellt WHERE id = " );
-	befehl->append( spielErstelltId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    if( !spielErstelltId )
+        return 0;
+    Text *befehl = new Text( "SELECT karte_id FROM spiel_erstellt WHERE id = " );
+    befehl->append( spielErstelltId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 bool SSDatenbank::getChatServerPortIp( int accountId, int *port, Text *zIp )
 {
-	if( !accountId )
-		return 0;
-	Text *befehl = new Text( "SELECT a.port, a.ip FROM server a, account_client b, server_client c WHERE a.server_typ_name = 'chat' AND a.id = c.server_id AND c.client_id = b.client_id AND b.account_id = " );
-	befehl->append( accountId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	*port = TextZuInt( res.values[ 0 ].getText(), 10 );
-	zIp->setText( res.values[ 1 ].getText() );
-	res.destroy();
-	return 1;
+    if( !accountId )
+        return 0;
+    Text *befehl = new Text( "SELECT a.port, a.ip FROM server a, account_client b, server_client c WHERE a.server_typ_name = 'chat' AND a.id = c.server_id AND c.client_id = b.client_id AND b.account_id = " );
+    befehl->append( accountId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    *port = TextZuInt( res.values[ 0 ].getText(), 10 );
+    zIp->setText( res.values[ 1 ].getText() );
+    res.destroy();
+    return 1;
 }
 
 bool SSDatenbank::spielErstelltAbbruch( int spielErstelltId, int anzahl, Array< int > *accounts, Array< int > *status, Array< bool > *inWarteschlange, RCArray< Zeit > *zeit )
 {
-	if( !spielErstelltId || !anzahl )
-		return 0;
-	Text *befehl = new Text( "BEGIN" );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	befehl->setText( "UPDATE server_spiel_regel SET jetzt_spiele = jetzt_spiele - 1 FROM spiel_erstellt "
-					 "WHERE server_spiel_regel.server_spiel_id = spiel_erstellt.server_spiel_id "
-					 "AND server_spiel_regel.karte_id = spiel_erstellt.karte_id AND spiel_erstellt.id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	befehl->setText( "UPDATE server SET tasks = tasks - 1 FROM spiel_erstellt "
-					 "WHERE server.id = spiel_erstellt.server_spiel_id AND spiel_erstellt.id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	befehl->setText( "SELECT karte_id FROM spiel_erstellt WHERE id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	if( !res.zeilenAnzahl )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		befehl->release();
-		res.destroy();
-		return 0;
-	}
-	int karteId = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	befehl->setText( "SELECT account_id, anmeldung_zeit FROM spiel_erstellt_spieler WHERE spiel_erstellt_id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result acc = datenbank->getResult();
-	befehl->setText( "SELECT gruppe_id, anmeldung_zeit FROM spiel_erstellt_gruppe WHERE spiel_erstellt_id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		acc.destroy();
-		befehl->release();
-		return 0;
-	}
-	Result gru = datenbank->getResult();
-	befehl->setText( "DELETE FROM spiel_erstellt_spieler WHERE spiel_erstellt_id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		acc.destroy();
-		gru.destroy();
-		befehl->release();
-		return 0;
-	}
-	befehl->setText( "DELETE FROM spiel_erstellt_gruppe WHERE spiel_erstellt_id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		acc.destroy();
-		gru.destroy();
-		befehl->release();
-		return 0;
-	}
-	befehl->setText( "DELETE FROM spiel_erstellt WHERE id = " );
-	befehl->append( spielErstelltId );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		befehl->setText( "ROLLBACK" );
-		datenbank->befehl( befehl->getText() );
-		unlock();
-		acc.destroy();
-		gru.destroy();
-		befehl->release();
-		return 0;
-	}
-	for( int i = 0; i < acc.zeilenAnzahl; i++ )
-	{
-		int accId = TextZuInt( acc.values[ i * 2 ].getText(), 10 );
-		for( int j = 0; j < anzahl; j++ )
-		{
-			if( accounts->hat( j ) && accId == accounts->get( j ) )
-			{
-				if( status->hat( j ) && status->get( j ) == 2 )
-				{ // zurück in Warteschlange
-					befehl->setText( "INSERT INTO account_anmeldung_fuer_spiel( account_id, karte_id, anmeldung_zeit ) VALUES( " );
-					befehl->append( accId );
-					befehl->append( ", " );
-					befehl->append( karteId );
-					befehl->append( ", '" );
-					befehl->append( acc.values[ i * 2 + 1 ].getText() );
-					befehl->append( "' )" );
-					if( datenbank->befehl( befehl->getText() ) )
-					{
-						inWarteschlange->set( 1, j );
-						Zeit *jetzt = getZeit();
-						Zeit *anmeldung = new Zeit();
-						anmeldung->setZeit( "y-m-d h:i:s", acc.values[ i * 2 + 1 ].getText() );
-						jetzt->minusZeit( anmeldung );
-						zeit->set( jetzt, j );
-					}
-				}
-				break;
-			}
-		}
-	}
-	acc.destroy();
-	for( int i = 0; i < gru.zeilenAnzahl; i++ )
-	{
-		bool backInWarteschlange = 1;
-		Array< int > *mitglieder = new Array< int >();
-		int mAnzahl = getSpielerAusGruppe( TextZuInt( gru.values[ i * 2 ].getText(), 10 ), mitglieder );
-		for( int j = 0; j < mAnzahl; j++ )
-		{
-			if( mitglieder->hat( j ) )
-			{
-				int akkId = mitglieder->get( j );
-				for( int k = 0; k < anzahl; k++ )
-				{
-					if( accounts->hat( k ) && akkId == accounts->get( k ) )
-						backInWarteschlange &= status->hat( k ) && status->get( k ) == 2;
-				}
-				if( !backInWarteschlange )
-					break;
-			}
-		}
-		if( backInWarteschlange )
-		{
-			befehl->setText( "INSERT INTO grupe_aneldung_fuer_spiel( gruppe_id, anmeldung_zeit ) VALUES( " );
-			befehl->append( TextZuInt( gru.values[ i * 2 ].getText(), 10 ) );
-			befehl->append( ", '" );
-			befehl->append( gru.values[ i * 2 + 1 ].getText() );
-			befehl->append( "' )" );
-			if( datenbank->befehl( befehl->getText() ) )
-			{
-				Zeit *jetzt = getZeit();
-				Zeit *anmeldung = new Zeit();
-				anmeldung->setZeit( "y-m-d h:i:s", gru.values[ i * 2 + 1 ].getText() );
-				jetzt->minusZeit( anmeldung );
-				for( int j = 0; j < mAnzahl; j++ )
-				{
-					int akkId = mitglieder->get( j );
-					for( int k = 0; k < anzahl; k++ )
-					{
-						if( accounts->hat( k ) && akkId == accounts->get( k ) )
-						{
-							inWarteschlange->set( 1, k );
-							zeit->set( jetzt->getThis(), k );
-						}
-					}
-				}
-				jetzt->release();
-			}
-		}
-		mitglieder->release();
-	}
-	gru.destroy();
-	befehl->setText( "COMMIT" );
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->release();
-	return 1;
+    if( !spielErstelltId || !anzahl )
+        return 0;
+    Text *befehl = new Text( "BEGIN" );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    befehl->setText( "UPDATE server_spiel_regel SET jetzt_spiele = jetzt_spiele - 1 FROM spiel_erstellt "
+                     "WHERE server_spiel_regel.server_spiel_id = spiel_erstellt.server_spiel_id "
+                     "AND server_spiel_regel.karte_id = spiel_erstellt.karte_id AND spiel_erstellt.id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    befehl->setText( "UPDATE server SET tasks = tasks - 1 FROM spiel_erstellt "
+                     "WHERE server.id = spiel_erstellt.server_spiel_id AND spiel_erstellt.id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    befehl->setText( "SELECT karte_id FROM spiel_erstellt WHERE id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    if( !res.zeilenAnzahl )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        befehl->release();
+        res.destroy();
+        return 0;
+    }
+    int karteId = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    befehl->setText( "SELECT account_id, anmeldung_zeit FROM spiel_erstellt_spieler WHERE spiel_erstellt_id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result acc = datenbank->getResult();
+    befehl->setText( "SELECT gruppe_id, anmeldung_zeit FROM spiel_erstellt_gruppe WHERE spiel_erstellt_id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        acc.destroy();
+        befehl->release();
+        return 0;
+    }
+    Result gru = datenbank->getResult();
+    befehl->setText( "DELETE FROM spiel_erstellt_spieler WHERE spiel_erstellt_id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        acc.destroy();
+        gru.destroy();
+        befehl->release();
+        return 0;
+    }
+    befehl->setText( "DELETE FROM spiel_erstellt_gruppe WHERE spiel_erstellt_id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        acc.destroy();
+        gru.destroy();
+        befehl->release();
+        return 0;
+    }
+    befehl->setText( "DELETE FROM spiel_erstellt WHERE id = " );
+    befehl->append( spielErstelltId );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        befehl->setText( "ROLLBACK" );
+        datenbank->befehl( befehl->getText() );
+        unlock();
+        acc.destroy();
+        gru.destroy();
+        befehl->release();
+        return 0;
+    }
+    for( int i = 0; i < acc.zeilenAnzahl; i++ )
+    {
+        int accId = TextZuInt( acc.values[ i * 2 ].getText(), 10 );
+        for( int j = 0; j < anzahl; j++ )
+        {
+            if( accounts->hat( j ) && accId == accounts->get( j ) )
+            {
+                if( status->hat( j ) && status->get( j ) == 2 )
+                { // zurück in Warteschlange
+                    befehl->setText( "INSERT INTO account_anmeldung_fuer_spiel( account_id, karte_id, anmeldung_zeit ) VALUES( " );
+                    befehl->append( accId );
+                    befehl->append( ", " );
+                    befehl->append( karteId );
+                    befehl->append( ", '" );
+                    befehl->append( acc.values[ i * 2 + 1 ].getText() );
+                    befehl->append( "' )" );
+                    if( datenbank->befehl( befehl->getText() ) )
+                    {
+                        inWarteschlange->set( 1, j );
+                        Zeit *jetzt = getZeit();
+                        Zeit *anmeldung = new Zeit();
+                        anmeldung->setZeit( "y-m-d h:i:s", acc.values[ i * 2 + 1 ].getText() );
+                        jetzt->minusZeit( anmeldung );
+                        zeit->set( jetzt, j );
+                    }
+                }
+                break;
+            }
+        }
+    }
+    acc.destroy();
+    for( int i = 0; i < gru.zeilenAnzahl; i++ )
+    {
+        bool backInWarteschlange = 1;
+        Array< int > *mitglieder = new Array< int >();
+        int mAnzahl = getSpielerAusGruppe( TextZuInt( gru.values[ i * 2 ].getText(), 10 ), mitglieder );
+        for( int j = 0; j < mAnzahl; j++ )
+        {
+            if( mitglieder->hat( j ) )
+            {
+                int akkId = mitglieder->get( j );
+                for( int k = 0; k < anzahl; k++ )
+                {
+                    if( accounts->hat( k ) && akkId == accounts->get( k ) )
+                        backInWarteschlange &= status->hat( k ) && status->get( k ) == 2;
+                }
+                if( !backInWarteschlange )
+                    break;
+            }
+        }
+        if( backInWarteschlange )
+        {
+            befehl->setText( "INSERT INTO grupe_aneldung_fuer_spiel( gruppe_id, anmeldung_zeit ) VALUES( " );
+            befehl->append( TextZuInt( gru.values[ i * 2 ].getText(), 10 ) );
+            befehl->append( ", '" );
+            befehl->append( gru.values[ i * 2 + 1 ].getText() );
+            befehl->append( "' )" );
+            if( datenbank->befehl( befehl->getText() ) )
+            {
+                Zeit *jetzt = getZeit();
+                Zeit *anmeldung = new Zeit();
+                anmeldung->setZeit( "y-m-d h:i:s", gru.values[ i * 2 + 1 ].getText() );
+                jetzt->minusZeit( anmeldung );
+                for( int j = 0; j < mAnzahl; j++ )
+                {
+                    int akkId = mitglieder->get( j );
+                    for( int k = 0; k < anzahl; k++ )
+                    {
+                        if( accounts->hat( k ) && akkId == accounts->get( k ) )
+                        {
+                            inWarteschlange->set( 1, k );
+                            zeit->set( dynamic_cast<Zeit *>( jetzt->getThis() ), k );
+                        }
+                    }
+                }
+                jetzt->release();
+            }
+        }
+        mitglieder->release();
+    }
+    gru.destroy();
+    befehl->setText( "COMMIT" );
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->release();
+    return 1;
 }
 
 int SSDatenbank::spielErstelltFortsetzen( int spielErstelltId )
 {
-	if( !spielErstelltId )
-		return 0;
-	Text *befehl = new Text( "SELECT spiel_erstellt_fortsetzen( " );
-	befehl->append( spielErstelltId );
-	befehl->append( " )" );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	return ret;
+    if( !spielErstelltId )
+        return 0;
+    Text *befehl = new Text( "SELECT spiel_erstellt_fortsetzen( " );
+    befehl->append( spielErstelltId );
+    befehl->append( " )" );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    int ret = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    return ret;
 }
 
 void SSDatenbank::spielSetTeams( int spielId, int sAnzahl, Array< int > *accounts, Array< int > *team )
 {
-	Text *befehl = new Text( "" );
-	for( int i = 0; i < sAnzahl; i++ )
-	{
-		if( team->hat( i ) && accounts->hat( i ) )
-		{
-			befehl->setText( "UPDATE spiel_spieler SET team_id = " );
-			befehl->append( team->get( i ) );
-			befehl->append( " WHERE account_id = " );
-			befehl->append( accounts->get( i ) );
-			befehl->append( " AND spiel_id = " );
-			befehl->append( spielId );
-			lock();
-			datenbank->befehl( befehl->getText() );
-			unlock();
-		}
-	}
-	befehl->release();
+    Text *befehl = new Text( "" );
+    for( int i = 0; i < sAnzahl; i++ )
+    {
+        if( team->hat( i ) && accounts->hat( i ) )
+        {
+            befehl->setText( "UPDATE spiel_spieler SET team_id = " );
+            befehl->append( team->get( i ) );
+            befehl->append( " WHERE account_id = " );
+            befehl->append( accounts->get( i ) );
+            befehl->append( " AND spiel_id = " );
+            befehl->append( spielId );
+            lock();
+            datenbank->befehl( befehl->getText() );
+            unlock();
+        }
+    }
+    befehl->release();
 }
 
 void SSDatenbank::spielSetSpielerNummern( int spielId, int sAnzahl, Array< int > *accounts, Array< int > *spielerNummern )
 {
-	Text *befehl = new Text( "" );
-	for( int i = 0; i < sAnzahl; i++ )
-	{
-		if( spielerNummern->hat( i ) && accounts->hat( i ) )
-		{
-			befehl->setText( "UPDATE spiel_spieler SET spieler_nummer = " );
-			befehl->append( spielerNummern->get( i ) );
-			befehl->append( " WHERE account_id = " );
-			befehl->append( accounts->get( i ) );
-			befehl->append( " AND spiel_id = " );
-			befehl->append( spielId );
-			lock();
-			datenbank->befehl( befehl->getText() );
-			unlock();
-		}
-	}
-	befehl->release();
+    Text *befehl = new Text( "" );
+    for( int i = 0; i < sAnzahl; i++ )
+    {
+        if( spielerNummern->hat( i ) && accounts->hat( i ) )
+        {
+            befehl->setText( "UPDATE spiel_spieler SET spieler_nummer = " );
+            befehl->append( spielerNummern->get( i ) );
+            befehl->append( " WHERE account_id = " );
+            befehl->append( accounts->get( i ) );
+            befehl->append( " AND spiel_id = " );
+            befehl->append( spielId );
+            lock();
+            datenbank->befehl( befehl->getText() );
+            unlock();
+        }
+    }
+    befehl->release();
 }
 
 int SSDatenbank::getSpielerAusGruppe( int gruppeId, Array< int > *accounts )
 {
-	Text *befehl = new Text( "SELECT account_id FROM gruppe_spieler WHERE gruppe_id = " );
-	befehl->append( gruppeId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	int ret = res.zeilenAnzahl;
-	for( int i = 0; i < ret; i++ )
-		accounts->set( TextZuInt( res.values[ i ].getText(), 10 ), i );
-	res.destroy();
-	return ret;
+    Text *befehl = new Text( "SELECT account_id FROM gruppe_spieler WHERE gruppe_id = " );
+    befehl->append( gruppeId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    int ret = res.zeilenAnzahl;
+    for( int i = 0; i < ret; i++ )
+        accounts->set( TextZuInt( res.values[ i ].getText(), 10 ), i );
+    res.destroy();
+    return ret;
 }
 
 int SSDatenbank::getAktionForKlient( int serverId, int accountId, int *id )
 {
-	if( !serverId || !accountId )
-		return 0;
-	Text *befehl = new Text( "SELECT a.id FROM spiel_erstellt a, spiel_erstellt_spieler b "
-							 "WHERE b.spiel_erstellt_id = a.id AND b.account_id = " );
-	befehl->append( accountId );
-	befehl->append( " AND a.server_spiel_id = " );
-	befehl->append( serverId );
-	befehl->append( " UNION SELECT a.id FROM spiel_erstellt a, spiel_erstellt_gruppe b, gruppe_spieler d "
-					  "WHERE b.spiel_erstellt_id = a.id AND d.gruppe_id = b.gruppe_id AND d.account_id = " );
-	befehl->append( accountId );
-	befehl->append( " AND a.server_spiel_id = " );
-	befehl->append( serverId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	if( res.zeilenAnzahl )
-	{
-		befehl->release();
-		*id = TextZuInt( res.values[ 0 ].getText(), 10 );
-		res.destroy();
-		return 1;
-	}
-	res.destroy();
-	befehl->setText( "SELECT a.id FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id AND a.spiel_status_id < 3 AND a.spiel_server_id = " );
-	befehl->append( serverId );
-	befehl->append( " AND b.account_id = " );
-	befehl->append( accountId ); lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( res.zeilenAnzahl )
-	{
-		*id = TextZuInt( res.values[ 0 ].getText(), 10 );
-		res.destroy();
-		return 2;
-	}
-	res.destroy();
-	return 0;
+    if( !serverId || !accountId )
+        return 0;
+    Text *befehl = new Text( "SELECT a.id FROM spiel_erstellt a, spiel_erstellt_spieler b "
+                             "WHERE b.spiel_erstellt_id = a.id AND b.account_id = " );
+    befehl->append( accountId );
+    befehl->append( " AND a.server_spiel_id = " );
+    befehl->append( serverId );
+    befehl->append( " UNION SELECT a.id FROM spiel_erstellt a, spiel_erstellt_gruppe b, gruppe_spieler d "
+                    "WHERE b.spiel_erstellt_id = a.id AND d.gruppe_id = b.gruppe_id AND d.account_id = " );
+    befehl->append( accountId );
+    befehl->append( " AND a.server_spiel_id = " );
+    befehl->append( serverId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    if( res.zeilenAnzahl )
+    {
+        befehl->release();
+        *id = TextZuInt( res.values[ 0 ].getText(), 10 );
+        res.destroy();
+        return 1;
+    }
+    res.destroy();
+    befehl->setText( "SELECT a.id FROM spiel a, spiel_spieler b WHERE a.id = b.spiel_id AND a.spiel_status_id < 3 AND a.spiel_server_id = " );
+    befehl->append( serverId );
+    befehl->append( " AND b.account_id = " );
+    befehl->append( accountId ); lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( res.zeilenAnzahl )
+    {
+        *id = TextZuInt( res.values[ 0 ].getText(), 10 );
+        res.destroy();
+        return 2;
+    }
+    res.destroy();
+    return 0;
 }
 
 bool SSDatenbank::setSpielStatusIsRunning( int spielId )
 {
-	if( !spielId )
-		return 0;
-	Text *befehl = new Text( "UPDATE spiel SET spiel_status_id = 2 WHERE id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->release();
-	return 1;
+    if( !spielId )
+        return 0;
+    Text *befehl = new Text( "UPDATE spiel SET spiel_status_id = 2 WHERE id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->release();
+    return 1;
 }
 
 bool SSDatenbank::setSpielStatusBeendet( int spielId, int status )
 {
-	if( !spielId )
-		return 0;
-	Text *befehl = new Text( "UPDATE spiel SET spiel_status_id = " );
-	befehl->append( status );
-	befehl->append( " WHERE id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->setText( "UPDATE spiel SET end_datum = now() WHERE id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->setText( "UPDATE server SET tasks = tasks - 1 FROM spiel WHERE server.id = spiel.spiel_server_id AND spiel.id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->setText( "UPDATE server_spiel_regel SET jetzt_spiele = jetzt_spiele - 1 FROM spiel WHERE server_spiel_regel.server_spiel_id = spiel.spiel_server_id AND server_spiel_regel.karte_id = spiel.karte_id AND spiel.id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->release();
-	return 1;
+    if( !spielId )
+        return 0;
+    Text *befehl = new Text( "UPDATE spiel SET spiel_status_id = " );
+    befehl->append( status );
+    befehl->append( " WHERE id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->setText( "UPDATE spiel SET end_datum = now() WHERE id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->setText( "UPDATE server SET tasks = tasks - 1 FROM spiel WHERE server.id = spiel.spiel_server_id AND spiel.id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->setText( "UPDATE server_spiel_regel SET jetzt_spiele = jetzt_spiele - 1 FROM spiel WHERE server_spiel_regel.server_spiel_id = spiel.spiel_server_id AND server_spiel_regel.karte_id = spiel.karte_id AND spiel.id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->release();
+    return 1;
 }
 
 bool SSDatenbank::setSpielSpielerStatus( int spielId, int accountId, int punkte, int status )
 {
-	if( !spielId || !accountId )
-		return 0;
-	Text *befehl = new Text( "UPDATE spiel_spieler SET spiel_spieler_status_id = " );
-	befehl->append( status );
-	befehl->append( " WHERE spiel_id = " );
-	befehl->append( spielId );
-	befehl->append( " AND account_id = " );
-	befehl->append( accountId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->setText( "UPDATE spiel_spieler SET punkte = " );
-	befehl->append( punkte );
-	befehl->append( " WHERE spiel_id = " );
-	befehl->append( spielId );
-	befehl->append( " AND account_id = " );
-	befehl->append( accountId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	if( ( punkte / 10 + status - 1 ) > 0 && ( status == 1 || status == 2 ) )
-	{
-		int kupfer = punkte / 10;
-		kupfer += status - 1;
-		befehl->setText( "UPDATE account SET kupfer = kupfer + " );
-		befehl->append( kupfer );
-		befehl->append( " WHERE id = " );
-		befehl->append( accountId );
-		lock();
-		if( !datenbank->befehl( befehl->getText() ) )
-		{
-			unlock();
-			befehl->release();
-			return 0;
-		}
-		unlock();
-	}
-	befehl->release();
-	return 1;
+    if( !spielId || !accountId )
+        return 0;
+    Text *befehl = new Text( "UPDATE spiel_spieler SET spiel_spieler_status_id = " );
+    befehl->append( status );
+    befehl->append( " WHERE spiel_id = " );
+    befehl->append( spielId );
+    befehl->append( " AND account_id = " );
+    befehl->append( accountId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->setText( "UPDATE spiel_spieler SET punkte = " );
+    befehl->append( punkte );
+    befehl->append( " WHERE spiel_id = " );
+    befehl->append( spielId );
+    befehl->append( " AND account_id = " );
+    befehl->append( accountId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    if( ( punkte / 10 + status - 1 ) > 0 && ( status == 1 || status == 2 ) )
+    {
+        int kupfer = punkte / 10;
+        kupfer += status - 1;
+        befehl->setText( "UPDATE account SET kupfer = kupfer + " );
+        befehl->append( kupfer );
+        befehl->append( " WHERE id = " );
+        befehl->append( accountId );
+        lock();
+        if( !datenbank->befehl( befehl->getText() ) )
+        {
+            unlock();
+            befehl->release();
+            return 0;
+        }
+        unlock();
+    }
+    befehl->release();
+    return 1;
 }
 
 bool SSDatenbank::addSpielerStatistik( int accountId, int spielId )
 {
-	if( !spielId || !accountId )
-		return 0;
-	Text *befehl = new Text( "SELECT spiel_statistik.* FROM spiel_statistik, spiel, karte "
-							 "WHERE spiel_statistik.spiel_art_id = karte.spiel_art_id AND karte.id = spiel.karte_id "
-							 "AND spiel_statistik.account_id = " );
-	befehl->append( accountId );
-	befehl->append( " AND spiel.id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	int anz = datenbank->getZeilenAnzahl();
-	unlock();
-	if( !anz )
-	{
-		befehl->setText( "INSERT INTO spiel_statistik( account_id, spiel_art_id ) SELECT " );
-		befehl->append( accountId );
-		befehl->append( " AS account_id, spiel_art.id FROM spiel_art, karte, spiel "
-						  "WHERE spiel_art.id = karte.spiel_art_id AND karte.id = spiel.karte_id AND spiel.id = " );
-		befehl->append( spielId );
-		lock();
-		if( !datenbank->befehl( befehl->getText() ) )
-		{
-			unlock();
-			befehl->release();
-			return 0;
-		}
-		unlock();
-	}
-	befehl->setText( "SELECT spiel_spieler_status_id FROM spiel_spieler WHERE account_id = " );
-	befehl->append( accountId );
-	befehl->append( " AND spiel_id = " );
-	befehl->append( spielId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		befehl->release();
-		return 0;
-	}
-	int status = TextZuInt( res.values[ 0 ].getText(), 10 );
-	res.destroy();
-	befehl->setText( "UPDATE spiel_statistik SET gespielt = gespielt + 1, " );
-	if( status == 1 )
-		befehl->append( " verloren = spiel_statistik.verloren + 1, " );
-	if( status == 2 )
-		befehl->append( " gewonnen = spiel_statistik.gewonnen + 1, " );
-	befehl->append( " punkte = spiel_statistik.punkte + spiel_spieler.punkte FROM spiel_spieler, karte, spiel "
-					  "WHERE spiel_statistik.account_id = spiel_spieler.account_id "
-					  "AND spiel_statistik.spiel_art_id = karte.spiel_art_id "
-					  "AND karte.id = spiel.karte_id AND spiel_spieler.spiel_id = spiel.id AND spiel.id = " );
-	befehl->append( spielId );
-	befehl->append( " AND spiel_statistik.account_id = " );
-	befehl->append( accountId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	unlock();
-	befehl->release();
-	return 1;
+    if( !spielId || !accountId )
+        return 0;
+    Text *befehl = new Text( "SELECT spiel_statistik.* FROM spiel_statistik, spiel, karte "
+                             "WHERE spiel_statistik.spiel_art_id = karte.spiel_art_id AND karte.id = spiel.karte_id "
+                             "AND spiel_statistik.account_id = " );
+    befehl->append( accountId );
+    befehl->append( " AND spiel.id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    int anz = datenbank->getZeilenAnzahl();
+    unlock();
+    if( !anz )
+    {
+        befehl->setText( "INSERT INTO spiel_statistik( account_id, spiel_art_id ) SELECT " );
+        befehl->append( accountId );
+        befehl->append( " AS account_id, spiel_art.id FROM spiel_art, karte, spiel "
+                        "WHERE spiel_art.id = karte.spiel_art_id AND karte.id = spiel.karte_id AND spiel.id = " );
+        befehl->append( spielId );
+        lock();
+        if( !datenbank->befehl( befehl->getText() ) )
+        {
+            unlock();
+            befehl->release();
+            return 0;
+        }
+        unlock();
+    }
+    befehl->setText( "SELECT spiel_spieler_status_id FROM spiel_spieler WHERE account_id = " );
+    befehl->append( accountId );
+    befehl->append( " AND spiel_id = " );
+    befehl->append( spielId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        befehl->release();
+        return 0;
+    }
+    int status = TextZuInt( res.values[ 0 ].getText(), 10 );
+    res.destroy();
+    befehl->setText( "UPDATE spiel_statistik SET gespielt = gespielt + 1, " );
+    if( status == 1 )
+        befehl->append( " verloren = spiel_statistik.verloren + 1, " );
+    if( status == 2 )
+        befehl->append( " gewonnen = spiel_statistik.gewonnen + 1, " );
+    befehl->append( " punkte = spiel_statistik.punkte + spiel_spieler.punkte FROM spiel_spieler, karte, spiel "
+                    "WHERE spiel_statistik.account_id = spiel_spieler.account_id "
+                    "AND spiel_statistik.spiel_art_id = karte.spiel_art_id "
+                    "AND karte.id = spiel.karte_id AND spiel_spieler.spiel_id = spiel.id AND spiel.id = " );
+    befehl->append( spielId );
+    befehl->append( " AND spiel_statistik.account_id = " );
+    befehl->append( accountId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    unlock();
+    befehl->release();
+    return 1;
 }
 
 Text *SSDatenbank::getAccountRufName( int accountId )
 {
-	if( !accountId )
-		return 0;
-	Text *befehl = new Text( "SELECT ruf_name FROM account WHERE id = " );
-	befehl->append( accountId );
-	lock();
-	if( !datenbank->befehl( befehl->getText() ) )
-	{
-		unlock();
-		befehl->release();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	befehl->release();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	Text *ret = new Text( res.values[ 0 ].getText() );
-	res.destroy();
-	return ret;
+    if( !accountId )
+        return 0;
+    Text *befehl = new Text( "SELECT ruf_name FROM account WHERE id = " );
+    befehl->append( accountId );
+    lock();
+    if( !datenbank->befehl( befehl->getText() ) )
+    {
+        unlock();
+        befehl->release();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    befehl->release();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    Text *ret = new Text( res.values[ 0 ].getText() );
+    res.destroy();
+    return ret;
 }
 
 bool SSDatenbank::suchHistorieServer( short *port, Text *ip )
 {
-	lock();
-	if( !datenbank->befehl( "SELECT such_historie_server()" ) )
-	{
-		unlock();
-		return 0;
-	}
-	Result res = datenbank->getResult();
-	unlock();
-	if( !res.zeilenAnzahl || (int)res.values[ 0 ] == 0 )
-	{
-		res.destroy();
-		return 0;
-	}
-	lock();
-	if( !datenbank->befehl( Text( "SELECT port, ip FROM server WHERE id = " ) += res.values[ 0 ].getText() ) )
-	{
-		unlock();
-		res.destroy();
-		return 0;
-	}
-	res.destroy();
-	res = datenbank->getResult();
-	unlock();
-	if( !res.zeilenAnzahl )
-	{
-		res.destroy();
-		return 0;
-	}
-	*port = (short)(int)res.values[ 0 ];
-	*ip = res.values[ 1 ].getText();
-	res.destroy();
-	return 1;
+    lock();
+    if( !datenbank->befehl( "SELECT such_historie_server()" ) )
+    {
+        unlock();
+        return 0;
+    }
+    Result res = datenbank->getResult();
+    unlock();
+    if( !res.zeilenAnzahl || (int)res.values[ 0 ] == 0 )
+    {
+        res.destroy();
+        return 0;
+    }
+    lock();
+    if( !datenbank->befehl( Text( "SELECT port, ip FROM server WHERE id = " ) += res.values[ 0 ].getText() ) )
+    {
+        unlock();
+        res.destroy();
+        return 0;
+    }
+    res.destroy();
+    res = datenbank->getResult();
+    unlock();
+    if( !res.zeilenAnzahl )
+    {
+        res.destroy();
+        return 0;
+    }
+    *port = (short)(int)res.values[ 0 ];
+    *ip = res.values[ 1 ].getText();
+    res.destroy();
+    return 1;
 }
 
 bool SSDatenbank::getKartenServer( int karteId, int *port, Text *ip )
@@ -1083,20 +1083,5 @@ Text *SSDatenbank::getSpielPfad( int karteId )
 // constant
 Text *SSDatenbank::getLetzterFehler() const
 {
-	return datenbank->getLetzterFehler();
-}
-
-// Reference Counting
-SSDatenbankV *SSDatenbank::getThis()
-{
-	ref++;
-	return this;
-}
-
-SSDatenbankV *SSDatenbank::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return datenbank->getLetzterFehler();
 }

SpielServer/Datenbank.h

@@ -13,63 +13,59 @@ using namespace sql;
 
 namespace Admin_Recht
 {
-	const int SSStarten = 32;
-	const int SSBeenden = 34;
-	const int SSPausieren = 35;
-	const int SSMSChange = 36;
+    const int SSStarten = 32;
+    const int SSBeenden = 34;
+    const int SSPausieren = 35;
+    const int SSMSChange = 36;
 }
 
-class SSDatenbank : private SSDatenbankV
+class SSDatenbank : public SSDatenbankV
 {
 private:
-	Datenbank *datenbank;
-	CRITICAL_SECTION cs;
+    Datenbank *datenbank;
+    CRITICAL_SECTION cs;
     InitDatei *ini;
-	int ref;
 
 public:
-	// Konstruktor
-	SSDatenbank( InitDatei *zIni );
-	// Destruktor
-	virtual ~SSDatenbank();
-	// nicht constant
-	void lock();
-	void unlock();
-	Text *getKlientKey( int cId );
-	int istAdministrator( const char *name, const char *passwort );
-	bool adminHatRecht( int id, int recht );
-	bool setServerStatus( int id, int status );
-	bool setMaxSpiele( int id, int maxS );
-	bool serverIstNichtPausiert( int id );
-	virtual int getAccountId( int clientId );
-	virtual Text *getSpielArtName( int spielId );
-	virtual Text *getKarteName( int karteId );
-	virtual int getSpielArtId( int karteId );
-	int erstelleSpiel( int serverId );
-	bool deleteSpielErstelltNext( int serverId );
-	int getSpielErstelltId( int serverId );
-	int getSpielErstelltSpieler( int spielErstelltId, Array< int > *accountIds );
-	int getKarteVonErstelltemSpiel( int spielErstelltId );
-	bool getChatServerPortIp( int accountId, int *port, Text *zIp );
-	bool spielErstelltAbbruch( int spielErstelltId, int anzahl, Array< int > *accounts, Array< int > *status, Array< bool > *inWarteschlange, RCArray< Zeit > *zeit );
-	int spielErstelltFortsetzen( int spielErstelltId );
-	void spielSetTeams( int spielId, int sAnzahl, Array< int > *accounts, Array< int > *team );
-	void spielSetSpielerNummern( int spielId, int sAnzahl, Array< int > *accounts, Array< int > *spielerNummern );
-	int getSpielerAusGruppe( int gruppeId, Array< int > *accounts );
-	int getAktionForKlient( int serverId, int accountId, int *id );
-	bool setSpielStatusIsRunning( int spielId );
-	virtual bool setSpielStatusBeendet( int spielId, int status );
-	virtual bool setSpielSpielerStatus( int spielId, int accountId, int punkte, int status );
-	virtual bool addSpielerStatistik( int accountId, int spielId );
-	virtual Text *getAccountRufName( int accountId );
+    // Konstruktor
+    SSDatenbank( InitDatei *zIni );
+    // Destruktor
+    virtual ~SSDatenbank();
+    // nicht constant
+    void lock();
+    void unlock();
+    Text *getKlientKey( int cId );
+    int istAdministrator( const char *name, const char *passwort );
+    bool adminHatRecht( int id, int recht );
+    bool setServerStatus( int id, int status );
+    bool setMaxSpiele( int id, int maxS );
+    bool serverIstNichtPausiert( int id );
+    virtual int getAccountId( int clientId );
+    virtual Text *getSpielArtName( int spielId );
+    virtual Text *getKarteName( int karteId );
+    virtual int getSpielArtId( int karteId );
+    int erstelleSpiel( int serverId );
+    bool deleteSpielErstelltNext( int serverId );
+    int getSpielErstelltId( int serverId );
+    int getSpielErstelltSpieler( int spielErstelltId, Array< int > *accountIds );
+    int getKarteVonErstelltemSpiel( int spielErstelltId );
+    bool getChatServerPortIp( int accountId, int *port, Text *zIp );
+    bool spielErstelltAbbruch( int spielErstelltId, int anzahl, Array< int > *accounts, Array< int > *status, Array< bool > *inWarteschlange, RCArray< Zeit > *zeit );
+    int spielErstelltFortsetzen( int spielErstelltId );
+    void spielSetTeams( int spielId, int sAnzahl, Array< int > *accounts, Array< int > *team );
+    void spielSetSpielerNummern( int spielId, int sAnzahl, Array< int > *accounts, Array< int > *spielerNummern );
+    int getSpielerAusGruppe( int gruppeId, Array< int > *accounts );
+    int getAktionForKlient( int serverId, int accountId, int *id );
+    bool setSpielStatusIsRunning( int spielId );
+    virtual bool setSpielStatusBeendet( int spielId, int status );
+    virtual bool setSpielSpielerStatus( int spielId, int accountId, int punkte, int status );
+    virtual bool addSpielerStatistik( int accountId, int spielId );
+    virtual Text *getAccountRufName( int accountId );
     bool suchHistorieServer( short *port, Text *ip );
     bool getKartenServer( int karteId, int *port, Text *ip );
     Text *getSpielPfad( int karteId );
-	// constant
-	Text *getLetzterFehler() const;
-	// Reference Counting
-	virtual SSDatenbankV *getThis();
-	virtual SSDatenbankV *release();
+    // constant
+    Text *getLetzterFehler() const;
 };
 
 #endif

SpielServer/KartenLeser.cpp

@@ -11,10 +11,10 @@
 // Inhalt der KartenLeser Klasse aus KartenLeser.h
 // Konstruktor 
 KartenLeser::KartenLeser( int sNum, int karteId, SpielServer *ss )
+    : ReferenceCounter()
 {
     this->ss = ss;
     pfad = new Text( "" );
-    ref = 1;
     this->sNum = sNum;
     setKarteId( karteId );
 }
@@ -40,11 +40,11 @@ bool KartenLeser::setKarteId( int id )
         ss->zDB()->getKartenServer( id, &port, &ip );
         Klient *klient = new Klient();
         unsigned char key[ 20 ] = { 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 };
-        klient->setSendeKey( (char*)key, 20 );
-        klient->setEmpfangKey( (char*)key, 20 );
+        klient->setSendeKey( (char *)key, 20 );
+        klient->setEmpfangKey( (char *)key, 20 );
         if( !klient->verbinde( (unsigned short)port, ip ) )
         {
-            klient = klient->release();
+            klient = (Klient *)klient->release();
             return 0;
         }
         klient->sendeEncrypted( "\x7", 1 );
@@ -52,7 +52,7 @@ bool KartenLeser::setKarteId( int id )
         klient->getNachrichtEncrypted( &ret, 1 );
         if( ret == 1 )
         {
-            klient->sendeEncrypted( (char*)&id, 4 );
+            klient->sendeEncrypted( (char *)&id, 4 );
             klient->getNachrichtEncrypted( &ret, 1 );
             if( ret == 2 )
             { // update
@@ -61,18 +61,18 @@ bool KartenLeser::setKarteId( int id )
             else if( ret == 1 )
             {
                 int anz = 0;
-                klient->getNachrichtEncrypted( (char*)&anz, 4 );
+                klient->getNachrichtEncrypted( (char *)&anz, 4 );
                 for( int i = 0; i < anz; i++ )
                 {
                     unsigned char len = 0;
-                    klient->getNachrichtEncrypted( (char*)&len, 1 );
+                    klient->getNachrichtEncrypted( (char *)&len, 1 );
                     if( !len )
                         continue;
                     char *pfa = new char[ len + 1 ];
                     pfa[ (int)len ] = 0;
                     klient->getNachrichtEncrypted( pfa, len );
                     __int64 size = 0;
-                    klient->getNachrichtEncrypted( (char*)&size, 8 );
+                    klient->getNachrichtEncrypted( (char *)&size, 8 );
                     char *buffer = new char[ 2048 ];
                     Text pfad = pf.getText();
                     pfad += "/";
@@ -98,7 +98,7 @@ bool KartenLeser::setKarteId( int id )
         {
             retVal = 0;
             unsigned char byte = 0;
-            klient->getNachrichtEncrypted( (char*)&byte, 1 );
+            klient->getNachrichtEncrypted( (char *)&byte, 1 );
             char *f = new char[ byte + 1 ];
             f[ (int)byte ] = 0;
             klient->getNachrichtEncrypted( f, byte );
@@ -110,7 +110,7 @@ bool KartenLeser::setKarteId( int id )
         klient->release();
     }
     karteId = id;
-    pfad->setText( (char*)pf );
+    pfad->setText( (char *)pf );
     return retVal;
 }
 
@@ -128,15 +128,15 @@ bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *sts )
         return 0;
     }
     datei->open( Datei::Style::lesen );
-    datei->lese( (char*)&sts->spielerAnzahl, 4 );
-    datei->lese( (char*)&sts->teamAnzahl, 4 );
+    datei->lese( (char *)&sts->spielerAnzahl, 4 );
+    datei->lese( (char *)&sts->teamAnzahl, 4 );
     if( sts->spielerFarbe )
         sts->spielerFarbe->release();
     sts->spielerFarbe = new Array< int >();
     for( int i = 0; i < sts->spielerAnzahl; i++ )
     {
         int farbe = 0;
-        datei->lese( (char*)&farbe, 4 );
+        datei->lese( (char *)&farbe, 4 );
         sts->spielerFarbe->set( farbe, i );
     }
     if( sts->teamFarbe )
@@ -145,7 +145,7 @@ bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *sts )
     for( int i = 0; i < sts->teamAnzahl; i++ )
     {
         int farbe = 0;
-        datei->lese( (char*)&farbe, 4 );
+        datei->lese( (char *)&farbe, 4 );
         sts->teamFarbe->set( farbe, i );
     }
     if( sts->teamName )
@@ -154,7 +154,7 @@ bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *sts )
     for( int i = 0; i < sts->teamAnzahl; i++ )
     {
         unsigned char len = 0;
-        datei->lese( (char*)&len, 1 );
+        datei->lese( (char *)&len, 1 );
         char *txt = new char[ len + 1 ];
         txt[ (int)len ] = 0;
         datei->lese( txt, len );
@@ -168,7 +168,7 @@ bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *sts )
     for( int i = 0; i < sts->teamAnzahl; i++ )
     {
         int size = 0;
-        datei->lese( (char*)&size, 4 );
+        datei->lese( (char *)&size, 4 );
         sts->teamSize->set( size, i );
     }
     datei->close();
@@ -184,25 +184,10 @@ int KartenLeser::getKarteId() const
 
 Text *KartenLeser::getPfad() const
 {
-    return pfad ? pfad->getThis() : 0;
+    return pfad ? dynamic_cast<Text *>( pfad->getThis() ) : 0;
 }
 
 Text *KartenLeser::zPfad() const
 {
     return pfad;
-}
-
-// Reference Counting
-KartenLeser *KartenLeser::getThis()
-{
-    ref++;
-    return this;
-}
-
-KartenLeser *KartenLeser::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

SpielServer/KartenLeser.h

@@ -9,30 +9,26 @@ using namespace Framework;
 struct SpielerTeamStruktur;
 class SpielServer;
 
-class KartenLeser
+class KartenLeser : public virtual ReferenceCounter
 {
 private:
-	SpielServer *ss;
-	int karteId;
-	Text *pfad;
+    SpielServer *ss;
+    int karteId;
+    Text *pfad;
     int sNum;
-	int ref;
 
 public:
-	// Konstruktor 
-	KartenLeser( int sNum, int karteId, SpielServer *ss );
-	// Destruktor
-	~KartenLeser();
-	// nicht constant
-	bool setKarteId( int id );
-	bool ladeSpielerTeamStruktur( SpielerTeamStruktur *sts );
-	// constant
-	int getKarteId() const;
-	Text *getPfad() const;
-	Text *zPfad() const;
-	// Reference Counting
-	KartenLeser *getThis();
-	KartenLeser *release();
+    // Konstruktor 
+    KartenLeser( int sNum, int karteId, SpielServer *ss );
+    // Destruktor
+    ~KartenLeser();
+    // nicht constant
+    bool setKarteId( int id );
+    bool ladeSpielerTeamStruktur( SpielerTeamStruktur *sts );
+    // constant
+    int getKarteId() const;
+    Text *getPfad() const;
+    Text *zPfad() const;
 };
 
 #endif

SpielServer/SSDatenbankV.h

@@ -5,28 +5,23 @@
 
 using namespace Framework;
 
-class SSDatenbankV
+class SSDatenbankV : public virtual ReferenceCounter
 {
 private:
 
 public:
     virtual ~SSDatenbankV()
     {}
-	// nicht constant
-	virtual int getAccountId( int clientId ) = 0;
-	virtual Text *getSpielArtName( int spielId ) = 0;
-	virtual Text *getKarteName( int karteId ) = 0;
-	virtual int getSpielArtId( int karteId ) = 0;
-	virtual Text *getAccountRufName( int accountId ) = 0;
-	virtual bool setSpielStatusBeendet( int spielId, int status ) = 0;
-	virtual bool setSpielSpielerStatus( int spielId, int accountId, int punkte, int status ) = 0;
-	virtual bool addSpielerStatistik( int accountId, int spielId ) = 0;
+    // nicht constant
+    virtual int getAccountId( int clientId ) = 0;
+    virtual Text *getSpielArtName( int spielId ) = 0;
+    virtual Text *getKarteName( int karteId ) = 0;
+    virtual int getSpielArtId( int karteId ) = 0;
+    virtual Text *getAccountRufName( int accountId ) = 0;
+    virtual bool setSpielStatusBeendet( int spielId, int status ) = 0;
+    virtual bool setSpielSpielerStatus( int spielId, int accountId, int punkte, int status ) = 0;
+    virtual bool addSpielerStatistik( int accountId, int spielId ) = 0;
     virtual Text *getSpielPfad( int karteId ) = 0;
-	// constant
-
-	// Reference Counting
-	virtual SSDatenbankV *getThis() = 0;
-	virtual SSDatenbankV *release() = 0;
 };
 
 #endif

SpielServer/Spiel.cpp

@@ -139,14 +139,14 @@ void Spiel::teamAusgleich()
 }
 
 // nicht constant
-void Spiel::setAccounts( int anzahl, Array< int > * zAccounts )
+void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
 {
     for( int i = 0; i < anzahl; i++ )
         accounts->set( zAccounts->hat( i ) ? zAccounts->get( i ) : 0, i );
     spielerAnzahl = anzahl;
 }
 
-void Spiel::setKlients( int anzahl, RCArray< SSKlient > * zKlients )
+void Spiel::setKlients( int anzahl, RCArray< SSKlient > *zKlients )
 {
     for( int i = 0; i < anzahl; i++ )
         klients->set( zKlients->get( i ), i );
@@ -155,13 +155,13 @@ void Spiel::setKlients( int anzahl, RCArray< SSKlient > * zKlients )
 void Spiel::setKarteId( int karteId )
 {
     karte = karteId;
-    KartenLeser *reader = new KartenLeser( id, karte, (SpielServer *)ss->getThis() );
+    KartenLeser *reader = new KartenLeser( id, karte, dynamic_cast<SpielServer *>( getThis() ) );
     reader->ladeSpielerTeamStruktur( sts );
     reader->release();
     start();
 }
 
-bool Spiel::klientVerbunden( SSKlient * klient )
+bool Spiel::klientVerbunden( SSKlient *klient )
 {
     int accId = klient->getAccountId();
     bool ret = 0;
@@ -208,7 +208,7 @@ bool Spiel::klientWechseltTeam( int accountId, int team )
         {
             if( accounts->hat( i ) && accounts->get( i ) == accountId )
                 spielerNummern->set( 0, i );
-            SSKlient * tmp = klients->z( i );
+            SSKlient *tmp = klients->z( i );
             if( tmp )
                 tmp->erstellungSpielerTeam( accountId, 0 );
         }
@@ -238,7 +238,7 @@ bool Spiel::klientWechseltTeam( int accountId, int team )
             {
                 if( accounts->hat( j ) && accounts->get( j ) == accountId )
                     spielerNummern->set( i, j );
-                SSKlient * tmp = klients->z( j );
+                SSKlient *tmp = klients->z( j );
                 if( tmp )
                     tmp->erstellungSpielerTeam( accountId, i );
             }
@@ -261,7 +261,7 @@ bool Spiel::chatNachricht( char *nachricht )
     return 1;
 }
 
-bool Spiel::klientGetrennt( SSKlient * zKlient )
+bool Spiel::klientGetrennt( SSKlient *zKlient )
 {
     int accId = zKlient->getAccountId();
     bool ret = 0;
@@ -588,7 +588,7 @@ void Spiel::thread()
         return;
     }
     spiel = getSpielKlasse();
-    spiel->setPSQLK( ss->zDB()->getThis() );
+    spiel->setPSQLK( dynamic_cast<SSDatenbankV *>( ss->zDB()->getThis() ) );
     spiel->setSpielId( id );
     spiel->setKarteId( karte );
     Text tmp = ss->zInit()->zWert( "TempMapPfad" )->getText();
@@ -618,11 +618,11 @@ void Spiel::thread()
     // Spiel ist zuende
     state = 6;
     statistik = spiel->getStatistik();
-    spiel = spiel->release();
+    spiel = (SpielKlasse *)spiel->release();
     statistik->run();
     // Statistik ist zuende
     state = 7;
-    statistik = statistik->release();
+    statistik = (StatistikV *)statistik->release();
     FreeLibrary( spielDll );
     spielDll = 0;
     DateiRemove( tmp );

SpielServer/SpielErstellt.cpp

@@ -79,15 +79,15 @@ void SpielErstellt::sendeVerbindungsBefehl()
             klient->getNachrichtEncrypted( &ret, 1 );
             if( ret != 3 )
             {
-                klient->sendeEncrypted( (char *)& accId, 4 );
-                klient->sendeEncrypted( (char *)& sPort, 2 );
+                klient->sendeEncrypted( (char *)&accId, 4 );
+                klient->sendeEncrypted( (char *)&sPort, 2 );
                 klient->sendeEncrypted( (char *)sIp4, 4 );
                 klient->getNachrichtEncrypted( &ret, 1 );
             }
             if( ret == 3 )
             {
                 unsigned char len = 0;
-                klient->getNachrichtEncrypted( (char *)& len, 1 );
+                klient->getNachrichtEncrypted( (char *)&len, 1 );
                 char *err = new char[ len ];
                 klient->getNachrichtEncrypted( err, len );
                 delete[] err;
@@ -167,7 +167,7 @@ bool SpielErstellt::klientLehntAb( int accountId )
     return ret;
 }
 
-bool SpielErstellt::klientGetrennt( SSKlient * zKlient )
+bool SpielErstellt::klientGetrennt( SSKlient *zKlient )
 {
     if( !verbunden )
         return 0;
@@ -311,7 +311,7 @@ void SpielErstellt::thread()
     }
     // alle Spieler sind bereit Vorgang fortsetzen
     spielId = ss->zDB()->spielErstelltFortsetzen( id );
-    Spiel *weiter = new Spiel( spielId, (SpielServer *)ss->getThis() );
+    Spiel *weiter = new Spiel( spielId, dynamic_cast<SpielServer *>( getThis() ) );
     ss->addSpiel( weiter );
     weiter->setAccounts( spielerAnzahl, accounts );
     weiter->setKlients( spielerAnzahl, klients );
@@ -328,7 +328,7 @@ int SpielErstellt::getId() const
 
 // Inhalt der SpielFinden Klasse aus SpielErstellt.h
 // Konstruktor
-SpielFinden::SpielFinden( SpielServer * ss )
+SpielFinden::SpielFinden( SpielServer *ss )
     : Thread()
 {
     this->ss = ss;
@@ -367,7 +367,7 @@ void SpielFinden::thread()
         if( !ret )
         { // erfolg
             int id = ss->zDB()->getSpielErstelltId( spielServerId );
-            SpielErstellt *erstellt = new SpielErstellt( id, (SpielServer *)ss->getThis() );
+            SpielErstellt *erstellt = new SpielErstellt( id, dynamic_cast<SpielServer *>( getThis() ) );
             ss->addSpielErstellt( erstellt );
             erstellt->sendeVerbindungsBefehl();
             ss->zDB()->deleteSpielErstelltNext( spielServerId );

SpielServer/SpielKlasse.h

@@ -10,31 +10,27 @@ class SSDatenbankV;
 class SSKlientV;
 class StatistikV;
 
-class SpielKlasse
+class SpielKlasse : public virtual ReferenceCounter
 {
 private:
 
 public:
-	virtual ~SpielKlasse()
-	{
-	}
-	// nicht constant
-	virtual void setPSQLK( SSDatenbankV *psqldb ) = 0;
-	virtual void setSpielId( int id ) = 0;
+    virtual ~SpielKlasse()
+    {	}
+    // nicht constant
+    virtual void setPSQLK( SSDatenbankV *psqldb ) = 0;
+    virtual void setSpielId( int id ) = 0;
     virtual void setKarteId( int karteId ) = 0;
     virtual void setTempPfad( char *pfad ) = 0;
-	virtual void setAccounts( int anzahl, Array< int > *zAccounts ) = 0;
-	virtual void setKlients( int anzahl, RCArray< SSKlientV > *zKlients ) = 0;
-	virtual void setSpielerNummern( int anzahl, Array< int > *spielerNummern ) = 0;
-	virtual void klientOffline( int accountId ) = 0;
-	virtual void klientOnline( int accountId, SSKlientV *zKlient ) = 0;
-	virtual void nachricht( int accountId, int len, char *bytes ) = 0;
-	virtual void run() = 0;
-	// constant
-	virtual StatistikV *getStatistik() const = 0;
-	// Reference Counting 
-	virtual SpielKlasse *getThis() = 0;
-	virtual SpielKlasse *release() = 0;
+    virtual void setAccounts( int anzahl, Array< int > *zAccounts ) = 0;
+    virtual void setKlients( int anzahl, RCArray< SSKlientV > *zKlients ) = 0;
+    virtual void setSpielerNummern( int anzahl, Array< int > *spielerNummern ) = 0;
+    virtual void klientOffline( int accountId ) = 0;
+    virtual void klientOnline( int accountId, SSKlientV *zKlient ) = 0;
+    virtual void nachricht( int accountId, int len, char *bytes ) = 0;
+    virtual void run() = 0;
+    // constant
+    virtual StatistikV *getStatistik() const = 0;
 };
 
 #endif

SpielServer/SpielServer.cpp

@@ -12,609 +12,609 @@
 // Inhalt der SpielServer Klasse aus SpielServer.h
 // Konstruktor 
 SpielServer::SpielServer( InitDatei *zIni )
-: Thread()
-{
-	Network::Start( 100 );
-	std::cout << "SS: Verbindung mit Datenbank wird hergestellt...\n";
-	db = new SSDatenbank( zIni );
-	empfangen = 0;
-	gesendet = 0;
-	fehler = new Text();
-	ini = zIni->getThis();
-	id = *zIni->zWert( "ServerId" );
-	server = new Server();
-	aServer = new SSLServer();
+    : Thread()
+{
+    Network::Start( 100 );
+    std::cout << "SS: Verbindung mit Datenbank wird hergestellt...\n";
+    db = new SSDatenbank( zIni );
+    empfangen = 0;
+    gesendet = 0;
+    fehler = new Text();
+    ini = dynamic_cast<InitDatei *>( zIni->getThis() );
+    id = *zIni->zWert( "ServerId" );
+    server = new Server();
+    aServer = new SSLServer();
     aServer->setPrivateKeyPassword( zIni->zWert( "SSLPasswort" )->getText() );
     aServer->setCertificateFile( zIni->zWert( "SSLCert" )->getText() );
     aServer->setPrivateKeyFile( zIni->zWert( "SSLKey" )->getText() );
-	std::cout << "SS: Starten des Admin Servers...\n";
-	if( !aServer->verbinde( (unsigned short)TextZuInt( ini->zWert( "AdminServerPort" )->getText(), 10 ), 10 ) )
-	{
-		std::cout << "SS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
-		exit( 1 );
-	}
-	db->setServerStatus( id, 2 );
-	end = 0;
-	nichtPausiert = 0;
-	InitializeCriticalSection( &cs );
+    std::cout << "SS: Starten des Admin Servers...\n";
+    if( !aServer->verbinde( (unsigned short)TextZuInt( ini->zWert( "AdminServerPort" )->getText(), 10 ), 10 ) )
+    {
+        std::cout << "SS: Der Admin Server konnte nicht gestartet werden. Das Programm wird beendet.\n";
+        exit( 1 );
+    }
+    db->setServerStatus( id, 2 );
+    end = 0;
+    nichtPausiert = 0;
+    InitializeCriticalSection( &cs );
     startSpielThread = new SpielFinden( this );
-	if( zIni->zWert( "Aktiv" )->istGleich( "TRUE" ) )
-	{
-		serverStarten();
-		serverFortsetzen();
-	}
-	erstellt = new RCArray< SpielErstellt >();
-	spiele = new RCArray< Spiel >();
-	klients = new RCArray< SSKlient >();
-	spielHistorieId = new Array< int >();
-	spielErstelltAnzahl = 0;
-	spielAnzahl = 0;
-	klientAnzahl = 0;
-	klientAnzahl2 = 0;
-	historieS = new HistorieSender( this );
-	historieS->start();
+    if( zIni->zWert( "Aktiv" )->istGleich( "TRUE" ) )
+    {
+        serverStarten();
+        serverFortsetzen();
+    }
+    erstellt = new RCArray< SpielErstellt >();
+    spiele = new RCArray< Spiel >();
+    klients = new RCArray< SSKlient >();
+    spielHistorieId = new Array< int >();
+    spielErstelltAnzahl = 0;
+    spielAnzahl = 0;
+    klientAnzahl = 0;
+    klientAnzahl2 = 0;
+    historieS = new HistorieSender( this );
+    historieS->start();
 }
 
 // Destruktor 
 SpielServer::~SpielServer()
 {
-	historieS->setEnde();
-	historieS->warteAufThread( 20000 );
-	historieS->ende();
-	historieS->release();
-	fehler->release();
-	server->trenne();
-	server->release();
-	aServer->trenne();
-	aServer->release();
-	ini->release();
-	db->release();
-	DeleteCriticalSection( &cs );
-	startSpielThread->release();
-	erstellt->release();
-	spiele->release();
-	if( klients )
-		klients->release();
-	spielHistorieId->release();
+    historieS->setEnde();
+    historieS->warteAufThread( 20000 );
+    historieS->ende();
+    historieS->release();
+    fehler->release();
+    server->trenne();
+    server->release();
+    aServer->trenne();
+    aServer->release();
+    ini->release();
+    db->release();
+    DeleteCriticalSection( &cs );
+    startSpielThread->release();
+    erstellt->release();
+    spiele->release();
+    if( klients )
+        klients->release();
+    spielHistorieId->release();
 }
 
 // nicht constant
 void SpielServer::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void SpielServer::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 void SpielServer::runn()
 {
-	while( !end && aServer->isConnected() )
-	{
-		SSLSKlient *klient;
-		klient = aServer->getKlient();
-		if( end && klient )
-		{
-			klient->trenne();
-			klient = klient->release();
-			Sleep( 1000 );
-			return;
-		}
-		if( !klient )
-			continue;
-		SSAKlient *slHandle = new SSAKlient( klient, (SpielServer *)getThis() );
-		slHandle->start();
-	}
+    while( !end && aServer->isConnected() )
+    {
+        SSLSKlient *klient;
+        klient = aServer->getKlient();
+        if( end && klient )
+        {
+            klient->trenne();
+            klient = (SSLSKlient *)klient->release();
+            Sleep( 1000 );
+            return;
+        }
+        if( !klient )
+            continue;
+        SSAKlient *slHandle = new SSAKlient( klient, dynamic_cast<SpielServer *>( getThis() ) );
+        slHandle->start();
+    }
 }
 
 void SpielServer::thread()
 {
-	while( server->isConnected() )
-	{
-		SKlient *klient;
-		klient = server->getKlient();
-		if( !klient )
-			continue;
-		Framework::getThreadRegister()->cleanUpClosedThreads();
-		SSKlient *slHandle = new SSKlient( klient, (SpielServer *)getThis() );
-		klientAnzahl2++;
-		slHandle->start();
-	}
+    while( server->isConnected() )
+    {
+        SKlient *klient;
+        klient = server->getKlient();
+        if( !klient )
+            continue;
+        Framework::getThreadRegister()->cleanUpClosedThreads();
+        SSKlient *slHandle = new SSKlient( klient, dynamic_cast<SpielServer *>( getThis() ) );
+        klientAnzahl2++;
+        slHandle->start();
+    }
 }
 
 void SpielServer::close()
 {
-	db->setServerStatus( id, 1 );
-	server->trenne();
+    db->setServerStatus( id, 1 );
+    server->trenne();
 #ifdef WIN32
-	warteAufThread( 1000 );
+    warteAufThread( 1000 );
 #endif
-	lock();
-	for( int i = 0; i < klientAnzahl; i++ )
-		klients->z( i )->absturz();
-	if( klients )
-		 klients = klients->release();
-	klientAnzahl = 0;
-	unlock();
-	ende();
-	run = 0;
-	end = 1;
-	Klient *klient = new Klient();
-	klient->verbinde( aServer->getPort(), "127.0.0.1" );
-	Sleep( 500 );
-	aServer->trenne();
-	klient->release();
+    lock();
+    for( int i = 0; i < klientAnzahl; i++ )
+        klients->z( i )->absturz();
+    if( klients )
+        klients = ( RCArray<SSKlient>* ) klients->release();
+    klientAnzahl = 0;
+    unlock();
+    ende();
+    run = 0;
+    end = 1;
+    Klient *klient = new Klient();
+    klient->verbinde( aServer->getPort(), "127.0.0.1" );
+    Sleep( 500 );
+    aServer->trenne();
+    klient->release();
 }
 
 bool SpielServer::serverStarten()
 {
-	if( nichtPausiert )
-	{
-		fehler->setText( "Der Server konnte nicht gestartet werden: Der Server läuft bereits." );
-		return 0;
-	}
-	if( server )
-		server->release();
-	server = new Server();
-	if( server->verbinde( (unsigned short)TextZuInt( ini->zWert( "ServerPort" )->getText(), 10 ), 10 ) )
-	{
-		nichtPausiert = 1;
-		start();
-		startSpielThread->setSpielServerId( id );
-		startSpielThread->start();
-		return 1;
-	}
-	else
-	{
-		serverBeenden();
-		fehler->setText( "Der Server konnte nicht gestartet werden: Eventuell ist der Port in benutzung." );
-		return 0;
-	}
+    if( nichtPausiert )
+    {
+        fehler->setText( "Der Server konnte nicht gestartet werden: Der Server läuft bereits." );
+        return 0;
+    }
+    if( server )
+        server->release();
+    server = new Server();
+    if( server->verbinde( (unsigned short)TextZuInt( ini->zWert( "ServerPort" )->getText(), 10 ), 10 ) )
+    {
+        nichtPausiert = 1;
+        start();
+        startSpielThread->setSpielServerId( id );
+        startSpielThread->start();
+        return 1;
+    }
+    else
+    {
+        serverBeenden();
+        fehler->setText( "Der Server konnte nicht gestartet werden: Eventuell ist der Port in benutzung." );
+        return 0;
+    }
 }
 
 bool SpielServer::serverPause()
 {
-	if( !nichtPausiert )
-	{
-		fehler->setText( "Der Server konnte nicht pausiert werden: Der Server läuft nicht." );
-		return 0;
-	}
-	if( !db->setServerStatus( id, 2 ) )
-	{
-		fehler->setText( "Der Server konnte nicht pausiert werden: " );
-		fehler->append( db->getLetzterFehler() );
-		return 0;
-	}
-	return 1;
+    if( !nichtPausiert )
+    {
+        fehler->setText( "Der Server konnte nicht pausiert werden: Der Server läuft nicht." );
+        return 0;
+    }
+    if( !db->setServerStatus( id, 2 ) )
+    {
+        fehler->setText( "Der Server konnte nicht pausiert werden: " );
+        fehler->append( db->getLetzterFehler() );
+        return 0;
+    }
+    return 1;
 }
 
 bool SpielServer::serverFortsetzen()
 {
-	if( !nichtPausiert )
-	{
-		fehler->setText( "Der Server konnte nicht fortgesetzt werden: Der Server läuft nicht." );
-		return 0;
-	}
-	if( !db->setServerStatus( id, 3 ) )
-	{
-		fehler->setText( "Der Server konnte nicht fortgesetzt werden: " );
-		fehler->append( db->getLetzterFehler() );
-		return 0;
-	}
-	return 1;
+    if( !nichtPausiert )
+    {
+        fehler->setText( "Der Server konnte nicht fortgesetzt werden: Der Server läuft nicht." );
+        return 0;
+    }
+    if( !db->setServerStatus( id, 3 ) )
+    {
+        fehler->setText( "Der Server konnte nicht fortgesetzt werden: " );
+        fehler->append( db->getLetzterFehler() );
+        return 0;
+    }
+    return 1;
 }
 
 bool SpielServer::serverBeenden()
 {
-	if( !nichtPausiert )
-	{
-		fehler->setText( "Der Server konnte nicht beendet werden: Der Server läuft nicht." );
-		return 0;
-	}
-	if( db->serverIstNichtPausiert( id ) )
-	{
-		fehler->setText( "Der Server konnte nicht beendet werden: Der Server muss erst pausiert werden." );
-		return 0;
-	}
-	startSpielThread->setEnde();
-	startSpielThread->warteAufThread( 2000 );
-	startSpielThread->ende();
-	nichtPausiert = 0;
-	ende();
-	if( server )
-		server->trenne();
-	return 1;
+    if( !nichtPausiert )
+    {
+        fehler->setText( "Der Server konnte nicht beendet werden: Der Server läuft nicht." );
+        return 0;
+    }
+    if( db->serverIstNichtPausiert( id ) )
+    {
+        fehler->setText( "Der Server konnte nicht beendet werden: Der Server muss erst pausiert werden." );
+        return 0;
+    }
+    startSpielThread->setEnde();
+    startSpielThread->warteAufThread( 2000 );
+    startSpielThread->ende();
+    nichtPausiert = 0;
+    ende();
+    if( server )
+        server->trenne();
+    return 1;
 }
 
 bool SpielServer::setMaxSpiele( int ms )
 {
-	if( !db->setMaxSpiele( id, ms ) )
-	{
-		fehler->setText( "Die maximale Anzahl der Spiele konnte nicht gesetzt werden:\n" );
-		fehler->append( db->getLetzterFehler() );
-		return 0;
-	}
-	ini->setWert( "MaxSpiele", Text() += ms );
-	return 1;
+    if( !db->setMaxSpiele( id, ms ) )
+    {
+        fehler->setText( "Die maximale Anzahl der Spiele konnte nicht gesetzt werden:\n" );
+        fehler->append( db->getLetzterFehler() );
+        return 0;
+    }
+    ini->setWert( "MaxSpiele", Text() += ms );
+    return 1;
 }
 
 void SpielServer::addSpielErstellt( SpielErstellt *erstellt )
 {
-	lock();
-	this->erstellt->set( erstellt, spielErstelltAnzahl );
-	spielErstelltAnzahl++;
-	unlock();
+    lock();
+    this->erstellt->set( erstellt, spielErstelltAnzahl );
+    spielErstelltAnzahl++;
+    unlock();
 }
 
 void SpielServer::SpielErstelltAbbruch( int spielErstelltId )
 {
-	lock();
-	for( int i = 0; i < spielErstelltAnzahl; i++ )
-	{
-		if( erstellt->z( i )->getId() == spielErstelltId )
-		{
-			erstellt->z( i )->abbruch();
-			break;
-		}
-	}
-	unlock();
+    lock();
+    for( int i = 0; i < spielErstelltAnzahl; i++ )
+    {
+        if( erstellt->z( i )->getId() == spielErstelltId )
+        {
+            erstellt->z( i )->abbruch();
+            break;
+        }
+    }
+    unlock();
 }
 
 void SpielServer::removeSpielErstellt( int id )
 {
-	lock();
-	bool gefunden = 0;
-	for( int i = 0; i < spielErstelltAnzahl; i++ )
-	{
-		if( erstellt->z( i )->getId() == id )
-		{
-			spielErstelltAnzahl--;
-			SpielErstellt *zse = erstellt->get( i );
-			erstellt->remove( i );
-			unlock();
-			zse->release();
-			gefunden = 1;
-			break;
-		}
-	}
-	if( !gefunden )
-		unlock();
+    lock();
+    bool gefunden = 0;
+    for( int i = 0; i < spielErstelltAnzahl; i++ )
+    {
+        if( erstellt->z( i )->getId() == id )
+        {
+            spielErstelltAnzahl--;
+            SpielErstellt *zse = erstellt->get( i );
+            erstellt->remove( i );
+            unlock();
+            zse->release();
+            gefunden = 1;
+            break;
+        }
+    }
+    if( !gefunden )
+        unlock();
 }
 
 bool SpielServer::registerKlient( SSKlient *klient )
 {
-	lock();
-	bool gefunden = 0;
-	for( int i = 0; i < klientAnzahl; i++ )
-	{
-		SSKlient *tmp = klients->z( i );
-		if( tmp )
-		{
-			if( tmp->getAccountId() == klient->getAccountId() )
-			{
-				klient->getThis();
-				tmp->setSenden( klient );
-				klient->release();
-				gefunden = 1;
-				unlock();
-				return 1;
-			}
-		}
-	}
-	if( !gefunden )
-	{
-		klients->set( klient, klientAnzahl );
-		klientAnzahl++;
-	}
-	unlock();
-	return 0;
+    lock();
+    bool gefunden = 0;
+    for( int i = 0; i < klientAnzahl; i++ )
+    {
+        SSKlient *tmp = klients->z( i );
+        if( tmp )
+        {
+            if( tmp->getAccountId() == klient->getAccountId() )
+            {
+                klient->getThis();
+                tmp->setSenden( klient );
+                klient->release();
+                gefunden = 1;
+                unlock();
+                return 1;
+            }
+        }
+    }
+    if( !gefunden )
+    {
+        klients->set( klient, klientAnzahl );
+        klientAnzahl++;
+    }
+    unlock();
+    return 0;
 }
 
 bool SpielServer::absturzKlient( int klientId )
 {
-	lock();
-	SSKlient *zKlient = 0;
-	for( int i = 0; i < klientAnzahl; i++ )
-	{
-		if( klients->z( i )->getKlientNummer() == klientId )
-		{
-			zKlient = klients->z( i );
-			break;
-		}
-	}
-	if( !zKlient )
-	{
-		unlock();
-		return 0;
-	}
-	int id = 0;
-	int ak = db->getAktionForKlient( this->id, zKlient->getAccountId(), &id );
-	switch( ak )
-	{
-	case 0: // Information Über Verwendung des Klient ist verlorengegangen (überall abmelden)
-		for( int i = 0; i < spielErstelltAnzahl; i++ )
-		{
-			SpielErstellt *tmp = erstellt->z( i );
-			if( tmp )
-				tmp->klientGetrennt( zKlient );
-		}
-		for( int i = 0; i < spielAnzahl; i++ )
-		{
-			Spiel *tmp = spiele->z( i );
-			if( tmp )
-				tmp->klientGetrennt( zKlient );
-		}
-		break;
-	case 1: // Spiel Erstellt
-		for( int i = 0; i < spielErstelltAnzahl; i++ )
-		{
-			SpielErstellt *tmp = erstellt->z( i );
-			if( tmp )
-			{
-				if( tmp->getId() == id )
-				{
-					tmp->klientGetrennt( zKlient );
-					break;
-				}
-			}
-		}
-		break;
-	case 2: // Spielt
-		for( int i = 0; i < spielAnzahl; i++ )
-		{
-			Spiel *tmp = spiele->z( i );
-			if( tmp && tmp->getId() == id )
-			{
-				tmp->klientGetrennt( zKlient );
-				break;
-			}
-		}
-		break;
-	}
-	bool gefunden = 0;
-	for( int i = 0; i < klientAnzahl; i++ )
-	{
-		if( klients->z( i ) == zKlient )
-		{
-			zKlient->absturz();
-			klientAnzahl--;
-			zKlient->getThis();
-			klients->remove( i );
-			unlock();
-			zKlient->release();
-			gefunden = 1;
-			break;
-		}
-	}
-	if( !gefunden )
-		unlock();
-	return 1;
+    lock();
+    SSKlient *zKlient = 0;
+    for( int i = 0; i < klientAnzahl; i++ )
+    {
+        if( klients->z( i )->getKlientNummer() == klientId )
+        {
+            zKlient = klients->z( i );
+            break;
+        }
+    }
+    if( !zKlient )
+    {
+        unlock();
+        return 0;
+    }
+    int id = 0;
+    int ak = db->getAktionForKlient( this->id, zKlient->getAccountId(), &id );
+    switch( ak )
+    {
+    case 0: // Information Über Verwendung des Klient ist verlorengegangen (überall abmelden)
+        for( int i = 0; i < spielErstelltAnzahl; i++ )
+        {
+            SpielErstellt *tmp = erstellt->z( i );
+            if( tmp )
+                tmp->klientGetrennt( zKlient );
+        }
+        for( int i = 0; i < spielAnzahl; i++ )
+        {
+            Spiel *tmp = spiele->z( i );
+            if( tmp )
+                tmp->klientGetrennt( zKlient );
+        }
+        break;
+    case 1: // Spiel Erstellt
+        for( int i = 0; i < spielErstelltAnzahl; i++ )
+        {
+            SpielErstellt *tmp = erstellt->z( i );
+            if( tmp )
+            {
+                if( tmp->getId() == id )
+                {
+                    tmp->klientGetrennt( zKlient );
+                    break;
+                }
+            }
+        }
+        break;
+    case 2: // Spielt
+        for( int i = 0; i < spielAnzahl; i++ )
+        {
+            Spiel *tmp = spiele->z( i );
+            if( tmp && tmp->getId() == id )
+            {
+                tmp->klientGetrennt( zKlient );
+                break;
+            }
+        }
+        break;
+    }
+    bool gefunden = 0;
+    for( int i = 0; i < klientAnzahl; i++ )
+    {
+        if( klients->z( i ) == zKlient )
+        {
+            zKlient->absturz();
+            klientAnzahl--;
+            zKlient->getThis();
+            klients->remove( i );
+            unlock();
+            zKlient->release();
+            gefunden = 1;
+            break;
+        }
+    }
+    if( !gefunden )
+        unlock();
+    return 1;
 }
 
 bool SpielServer::verteileKlient( SSKlient *klient )
 {
-	lock();
-	int id = 0;
-	int ak = db->getAktionForKlient( this->id, klient->getAccountId(), &id );
-	switch( ak )
-	{
-	case 0: // Keine Verwendung für den Klient
-		unlock();
-		return 0;
-		break;
-	case 1: // Spiel Erstellt
-		for( int i = 0; i < spielErstelltAnzahl; i++ )
-		{
-			SpielErstellt *tmp = erstellt->z( i );
-			if( tmp )
-			{
-				if( tmp->getId() == id )
-				{
-					tmp->klientVerbunden( (SSKlient*)klient->getThis() );
-					unlock();
-					return 1;
-				}
-			}
-		}
-		break;
-	case 2: // Spielt
-		for( int i = 0; i < spielAnzahl; i++ )
-		{
-			Spiel *tmp = spiele->z( i );
-			if( tmp )
-			{
-				if( tmp->getId() == id )
-				{
-					tmp->klientVerbunden( (SSKlient*)klient->getThis() );
-					unlock();
-					return 1;
-				}
-			}
-		}
-		break;
-	}
-	unlock();
-	return 0;
+    lock();
+    int id = 0;
+    int ak = db->getAktionForKlient( this->id, klient->getAccountId(), &id );
+    switch( ak )
+    {
+    case 0: // Keine Verwendung für den Klient
+        unlock();
+        return 0;
+        break;
+    case 1: // Spiel Erstellt
+        for( int i = 0; i < spielErstelltAnzahl; i++ )
+        {
+            SpielErstellt *tmp = erstellt->z( i );
+            if( tmp )
+            {
+                if( tmp->getId() == id )
+                {
+                    tmp->klientVerbunden( dynamic_cast<SSKlient *>( klient->getThis() ) );
+                    unlock();
+                    return 1;
+                }
+            }
+        }
+        break;
+    case 2: // Spielt
+        for( int i = 0; i < spielAnzahl; i++ )
+        {
+            Spiel *tmp = spiele->z( i );
+            if( tmp )
+            {
+                if( tmp->getId() == id )
+                {
+                    tmp->klientVerbunden( dynamic_cast<SSKlient *>( klient->getThis() ) );
+                    unlock();
+                    return 1;
+                }
+            }
+        }
+        break;
+    }
+    unlock();
+    return 0;
 }
 
 void SpielServer::unregisterKlient( SSKlient *zKlient )
 {
-	lock();
-	int id = 0;
-	int ak = db->getAktionForKlient( this->id, zKlient->getAccountId(), &id );
-	switch( ak )
-	{
-	case 0: // Information Über Verwendung des Klient ist verlorengegangen (überall abmelden)
-		for( int i = 0; i < spielErstelltAnzahl; i++ )
-		{
-			SpielErstellt *tmp = erstellt->z( i );
-			if( tmp )
-				tmp->klientGetrennt( zKlient );
-		}
-		for( int i = 0; i < spielAnzahl; i++ )
-		{
-			Spiel *tmp = spiele->z( i );
-			if( tmp )
-				tmp->klientGetrennt( zKlient );
-		}
-		break;
-	case 1: // Spiel Erstellt
-		for( int i = 0; i < spielErstelltAnzahl; i++ )
-		{
-			SpielErstellt *tmp = erstellt->z( i );
-			if( tmp )
-			{
-				if( tmp->getId() == id )
-				{
-					tmp->klientGetrennt( zKlient );
-					break;
-				}
-			}
-		}
-		break;
-	case 2: // Spielt
-		for( int i = 0; i < spielAnzahl; i++ )
-		{
-			Spiel *tmp = spiele->z( i );
-			if( tmp && tmp->getId() == id )
-			{
-				tmp->klientGetrennt( zKlient );
-				break;
-			}
-		}
-		break;
-	}
-	bool gefunden = 0;
-	for( int i = 0; i < klientAnzahl; i++ )
-	{
-		if( klients->z( i ) == zKlient )
-		{
-			klientAnzahl--;
-			zKlient->getThis();
-			klients->remove( i );
-			unlock();
-			zKlient->release();
-			gefunden = 1;
-			break;
-		}
-	}
-	if( !gefunden )
-	{
-		unlock();
-		zKlient->release();
-	}
+    lock();
+    int id = 0;
+    int ak = db->getAktionForKlient( this->id, zKlient->getAccountId(), &id );
+    switch( ak )
+    {
+    case 0: // Information Über Verwendung des Klient ist verlorengegangen (überall abmelden)
+        for( int i = 0; i < spielErstelltAnzahl; i++ )
+        {
+            SpielErstellt *tmp = erstellt->z( i );
+            if( tmp )
+                tmp->klientGetrennt( zKlient );
+        }
+        for( int i = 0; i < spielAnzahl; i++ )
+        {
+            Spiel *tmp = spiele->z( i );
+            if( tmp )
+                tmp->klientGetrennt( zKlient );
+        }
+        break;
+    case 1: // Spiel Erstellt
+        for( int i = 0; i < spielErstelltAnzahl; i++ )
+        {
+            SpielErstellt *tmp = erstellt->z( i );
+            if( tmp )
+            {
+                if( tmp->getId() == id )
+                {
+                    tmp->klientGetrennt( zKlient );
+                    break;
+                }
+            }
+        }
+        break;
+    case 2: // Spielt
+        for( int i = 0; i < spielAnzahl; i++ )
+        {
+            Spiel *tmp = spiele->z( i );
+            if( tmp && tmp->getId() == id )
+            {
+                tmp->klientGetrennt( zKlient );
+                break;
+            }
+        }
+        break;
+    }
+    bool gefunden = 0;
+    for( int i = 0; i < klientAnzahl; i++ )
+    {
+        if( klients->z( i ) == zKlient )
+        {
+            klientAnzahl--;
+            zKlient->getThis();
+            klients->remove( i );
+            unlock();
+            zKlient->release();
+            gefunden = 1;
+            break;
+        }
+    }
+    if( !gefunden )
+    {
+        unlock();
+        zKlient->release();
+    }
 }
 
 void SpielServer::klientsMM( SSKlient *k )
 {
-	lock();
-	for( int i = 0; i < klientAnzahl; i++ )
-	{
-		if( klients->z( i ) == k )
-		{
-			klients->z( i )->getThis();
-			klients->z( i )->getThis();
-			klients->remove( i );
-		}
-	}
-	unlock();
-	klientAnzahl2--;
+    lock();
+    for( int i = 0; i < klientAnzahl; i++ )
+    {
+        if( klients->z( i ) == k )
+        {
+            klients->z( i )->getThis();
+            klients->z( i )->getThis();
+            klients->remove( i );
+        }
+    }
+    unlock();
+    klientAnzahl2--;
 }
 
 void SpielServer::addSpiel( Spiel *spiel )
 {
-	lock();
-	spiele->add( spiel, spielAnzahl );
-	spielAnzahl++;
-	unlock();
+    lock();
+    spiele->add( spiel, spielAnzahl );
+    spielAnzahl++;
+    unlock();
 }
 
 void SpielServer::removeSpiel( int spielId )
 {
-	lock();
-	bool gefunden = 0;
-	for( int i = 0; i < spielAnzahl; i++ )
-	{
-		if( spiele->z( i ) && spiele->z( i )->getId() == spielId )
-		{
-			spielAnzahl--;
-			Spiel *zs = spiele->get( i );
-			spiele->remove( i );
-			unlock();
-			zs->release();
-			gefunden = 1;
-			break;
-		}
-	}
-	if( !gefunden )
-		unlock();
+    lock();
+    bool gefunden = 0;
+    for( int i = 0; i < spielAnzahl; i++ )
+    {
+        if( spiele->z( i ) && spiele->z( i )->getId() == spielId )
+        {
+            spielAnzahl--;
+            Spiel *zs = spiele->get( i );
+            spiele->remove( i );
+            unlock();
+            zs->release();
+            gefunden = 1;
+            break;
+        }
+    }
+    if( !gefunden )
+        unlock();
 }
 
 void SpielServer::addGesendet( int bytes )
 {
-	gesendet += bytes;
+    gesendet += bytes;
 }
 
 void SpielServer::addEmpfangen( int bytes )
 {
-	empfangen += bytes;
+    empfangen += bytes;
 }
 
 void SpielServer::addSpielHistorieId( int id )
 {
-	lock();
-	spielHistorieId->add( id );
-	unlock();
+    lock();
+    spielHistorieId->add( id );
+    unlock();
 }
 
 bool SpielServer::hatSpielHistorieId( int id )
 {
-	bool ret = 0;
-	lock();
-	int anz = spielHistorieId->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spielHistorieId->hat( i ) && spielHistorieId->get( i ) == id )
-		{
-			ret = 1;
-			break;
-		}
-	}
-	unlock();
-	return ret;
+    bool ret = 0;
+    lock();
+    int anz = spielHistorieId->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spielHistorieId->hat( i ) && spielHistorieId->get( i ) == id )
+        {
+            ret = 1;
+            break;
+        }
+    }
+    unlock();
+    return ret;
 }
 
 void SpielServer::removeSpielHistorieId( int id )
 {
-	lock();
-	int anz = spielHistorieId->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spielHistorieId->hat( i ) && spielHistorieId->get( i ) == id )
-		{
-			spielHistorieId->remove( i );
-			break;
-		}
-	}
-	unlock();
+    lock();
+    int anz = spielHistorieId->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spielHistorieId->hat( i ) && spielHistorieId->get( i ) == id )
+        {
+            spielHistorieId->remove( i );
+            break;
+        }
+    }
+    unlock();
 }
 
 // constant
 bool SpielServer::istAn() const
 {
-	return db->serverIstNichtPausiert( id );
+    return db->serverIstNichtPausiert( id );
 }
 
 Server *SpielServer::zServer() const
 {
-	return server;
+    return server;
 }
 
 SSDatenbank *SpielServer::zDB() const
 {
-	return db;
+    return db;
 }
 
 InitDatei *SpielServer::zInit() const
@@ -624,1148 +624,1148 @@ InitDatei *SpielServer::zInit() const
 
 bool SpielServer::hatClients() const
 {
-	return klientAnzahl > 0;
+    return klientAnzahl > 0;
 }
 
 int SpielServer::getId() const
 {
-	return id;
+    return id;
 }
 
 char *SpielServer::getLetzterFehler() const
 {
-	return fehler->getText();
+    return fehler->getText();
 }
 
 char *SpielServer::getIp() const
 {
-	return ini->zWert( "ServerIp" )->getText();
+    return ini->zWert( "ServerIp" )->getText();
 }
 
 int SpielServer::getPort() const
 {
-	if( !ini->wertExistiert( "ServerPort" ) )
-		return 0;
-	return TextZuInt( ini->zWert( "ServerPort" )->getText(), 10 );
+    if( !ini->wertExistiert( "ServerPort" ) )
+        return 0;
+    return TextZuInt( ini->zWert( "ServerPort" )->getText(), 10 );
 }
 
 
 // Inhalt der SSAKlient Klasse aus SpielServer.h
 // Konstruktor 
 SSAKlient::SSAKlient( SSLSKlient *klient, SpielServer *ss )
-: Thread()
+    : Thread()
 {
-	this->klient = klient;
-	name = new Text( "" );
-	passwort = new Text( "" );
-	adminId = 0;
-	version = 0;
-	this->ss = ss;
+    this->klient = klient;
+    name = new Text( "" );
+    passwort = new Text( "" );
+    adminId = 0;
+    version = 0;
+    this->ss = ss;
 }
 
 // Destruktor 
 SSAKlient::~SSAKlient()
 {
-	klient->trenne();
-	klient->release();
-	ss->release();
-	name->release();
-	passwort->release();
+    klient->trenne();
+    klient->release();
+    ss->release();
+    name->release();
+    passwort->release();
 }
 
 // nicht constant 
 void SSAKlient::thread()
 {
-	while( 1 )
-	{
-		char c = 0;
-		if( !klient->getNachricht( &c, 1 ) )
-			break;
-		else
-		{
-			bool br = 0;
-			switch( c )
-			{
-			case 1: // Login
-				if( 1 )
-				{
-					klient->sende( "\1", 1 );
-					unsigned char nLen = 0;
-					klient->getNachricht( (char*)&nLen, 1 );
-					char *n = new char[ nLen + 1 ];
-					n[ (int)nLen ] = 0;
-					if( nLen )
-						klient->getNachricht( n, nLen );
-					unsigned char pLen = 0;
-					klient->getNachricht( (char*)&pLen, 1 );
-					char *p = new char[ pLen + 1 ];
-					p[ (int)pLen ] = 0;
-					if( pLen )
-						klient->getNachricht( p, pLen );
-					int adminId = ss->zDB()->istAdministrator( n, p );
-					if( adminId )
-					{
-						klient->sende( "\1", 1 );
-						name->setText( n );
-						passwort->setText( p );
-						this->adminId = adminId;
-					}
-					else
-						errorZuKlient( "Falsche Kombination aus Name und Passwort." );
-					delete[] n;
-					delete[] p;
-				}
-				break;
-			case 2: // Logout
-				adminId = 0;
-				name->setText( "" );
-				passwort->setText( "" );
-				klient->sende( "\1", 1 );
-				break;
-			case 3: // Trennen
-				br = 1;
-				klient->sende( "\1", 1 );
-				break;
-			case 4: // Server starten
-				if( !adminId )
-					errorZuKlient( "Du musst dich einloggen." );
-				else
-				{
-					if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSStarten ) )
-					{
-						if( !ss->serverStarten() )
-						{
-							Text *err = new Text();
-							err->append( ss->getLetzterFehler() );
-							errorZuKlient( err->getText() );
-							err->release();
-						}
-						else
-							klient->sende( "\1", 1 );
-					}
-					else
-						errorZuKlient( "Du bist nicht berechtigt den Server zu starten." );
-				}
-				break;
-			case 5: // Server beenden
-				if( !adminId )
-					errorZuKlient( "Du musst dich einloggen." );
-				else
-				{
-					if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSBeenden ) )
-					{
-						if( ss->serverBeenden() )
-							klient->sende( "\1", 1 );
-						else
-						{
-							Text *err = new Text();
-							err->append( ss->getLetzterFehler() );
-							errorZuKlient( err->getText() );
-							err->release();
-						}
-					}
-					else
-						errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-				}
-				break;
-			case 6: // Programm Schließen
-				if( !adminId )
-					errorZuKlient( "Du musst dich einloggen." );
-				else
-				{
-					bool ok = 0;
-					if( ss->isRunning() )
-					{
-						if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSBeenden ) )
-						{
-							if( ss->serverBeenden() )
-								ok = 1;
-							else
-							{
-								Text *err = new Text();
-								err->append( ss->getLetzterFehler() );
-								errorZuKlient( err->getText() );
-								err->release();
-							}
-						}
-						else
-							errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-					}
-					else
-						ok = 1;
-					if( ok && ss->hatClients() )
-					{
-						errorZuKlient( "Es sind noch Klients Online. Bitte versuche es später erneut." );
-						break;
-					}
-					if( ok )
-					{
-						klient->sende( "\1", 1 );
-						std::cout << "SS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
-						ss->close();
-						br = 1;
-					}
-				}
-				break;
-			case 7: // Progtamm abstürzen
-				if( !adminId )
-					errorZuKlient( "Du musst dich einloggen." );
-				else
-				{
-					bool ok = 0;
-					if( ss->isRunning() )
-					{
-						if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSBeenden ) )
-						{
-							ss->serverBeenden();
-							ok = 1;
-						}
-						else
-							errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
-					}
-					else
-						ok = 1;
-					if( ok )
-					{
-						klient->sende( "\1", 1 );
-						std::cout << "sS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
-						ss->close();
-						br = 1;
-					}
-				}
-				break;
-			case 8: // Status Frage
-				if( 1 )
-				{
-					char status = 0;
-					if( ss->isRunning() )
-					{
-						status = 1;
-						if( ss->istAn() )
-							status = 2;
-					}
-					klient->sende( "\1", 1 );
-					klient->sende( &status, 1 );
-				}
-				break;
-			case 9: // Server pausieren
-				if( !adminId )
-					errorZuKlient( "Du musst dich einloggen." );
-				else
-				{
-					klient->sende( "\1", 1 );
-					char pause = 0;
-					klient->getNachricht( &pause, 1 );
-					if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSPausieren ) )
-					{
-						bool ok = 0;
-						if( pause )
-							ok = ss->serverPause();
-						else
-							ok = ss->serverFortsetzen();
-						if( ok )
-							klient->sende( "\1", 1 );
-						else
-						{
-							Text *err = new Text();
-							err->append( ss->getLetzterFehler() );
-							errorZuKlient( err->getText() );
-							err->release();
-						}
-					}
-					else
-					{
-						if( pause )
-							errorZuKlient( "Du bist nicht berechtigt den Server zu pausieren." );
-						else
-							errorZuKlient( "Du bist nicht berechtigt den Server fortzusetzen." );
-					}
-				}
-				break;
-			case 0xA: // maximale Anzahl der Spiele setzen
-				if( !adminId )
-					errorZuKlient( "Du musst dich einloggen." );
-				else
-				{
-					klient->sende( "\1", 1 );
-					int maxS = 0;
-					klient->getNachricht( (char*)&maxS, 4 );
-					if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSMSChange ) )
-					{
-						if( ss->setMaxSpiele( maxS ) )
-							klient->sende( "\1", 1 );
-						else
-						{
-							Text *err = new Text();
-							err->append( ss->getLetzterFehler() );
-							errorZuKlient( err->getText() );
-							err->release();
-						}
-					}
-					else
-						errorZuKlient( "Du bist nicht berechtigt die maximale Anzahl der Clients zu verändern." );
-				}
-				break;
-			case 0xB: // Spiel Historie downloaden
-				if( adminId )
-					errorZuKlient( "Zugriff verweigert." );
-				else
-				{
-					klient->sende( "\1", 1 );
-					int spielId = 0;
-					klient->getNachricht( (char*)&spielId, 4 );
-					if( !ss->hatSpielHistorieId( spielId ) )
-					{
-						errorZuKlient( "Zugriff auf Spiel-Historie verweigert." );
-						break;
-					}
-					Text *pfad = new Text( "../spiel log/" );
-					*pfad += spielId;
-					*pfad += "/fertig";
-					if( !DateiExistiert( *pfad ) )
-					{
-						pfad->release();
-						errorZuKlient( "Die Spiel-Historie wurde nicht gefunden." );
-						break;
-					}
-					klient->sende( "\1", 1 );
-					pfad->remove( "/fertig" );
-					sendeVerzeichnisAnKlient( *pfad, pfad->getLength() + 1 );
-					pfad->release();
-					klient->sende( "\0", 1 );
-				}
-				break;
+    while( 1 )
+    {
+        char c = 0;
+        if( !klient->getNachricht( &c, 1 ) )
+            break;
+        else
+        {
+            bool br = 0;
+            switch( c )
+            {
+            case 1: // Login
+                if( 1 )
+                {
+                    klient->sende( "\1", 1 );
+                    unsigned char nLen = 0;
+                    klient->getNachricht( (char *)&nLen, 1 );
+                    char *n = new char[ nLen + 1 ];
+                    n[ (int)nLen ] = 0;
+                    if( nLen )
+                        klient->getNachricht( n, nLen );
+                    unsigned char pLen = 0;
+                    klient->getNachricht( (char *)&pLen, 1 );
+                    char *p = new char[ pLen + 1 ];
+                    p[ (int)pLen ] = 0;
+                    if( pLen )
+                        klient->getNachricht( p, pLen );
+                    int adminId = ss->zDB()->istAdministrator( n, p );
+                    if( adminId )
+                    {
+                        klient->sende( "\1", 1 );
+                        name->setText( n );
+                        passwort->setText( p );
+                        this->adminId = adminId;
+                    }
+                    else
+                        errorZuKlient( "Falsche Kombination aus Name und Passwort." );
+                    delete[] n;
+                    delete[] p;
+                }
+                break;
+            case 2: // Logout
+                adminId = 0;
+                name->setText( "" );
+                passwort->setText( "" );
+                klient->sende( "\1", 1 );
+                break;
+            case 3: // Trennen
+                br = 1;
+                klient->sende( "\1", 1 );
+                break;
+            case 4: // Server starten
+                if( !adminId )
+                    errorZuKlient( "Du musst dich einloggen." );
+                else
+                {
+                    if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSStarten ) )
+                    {
+                        if( !ss->serverStarten() )
+                        {
+                            Text *err = new Text();
+                            err->append( ss->getLetzterFehler() );
+                            errorZuKlient( err->getText() );
+                            err->release();
+                        }
+                        else
+                            klient->sende( "\1", 1 );
+                    }
+                    else
+                        errorZuKlient( "Du bist nicht berechtigt den Server zu starten." );
+                }
+                break;
+            case 5: // Server beenden
+                if( !adminId )
+                    errorZuKlient( "Du musst dich einloggen." );
+                else
+                {
+                    if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSBeenden ) )
+                    {
+                        if( ss->serverBeenden() )
+                            klient->sende( "\1", 1 );
+                        else
+                        {
+                            Text *err = new Text();
+                            err->append( ss->getLetzterFehler() );
+                            errorZuKlient( err->getText() );
+                            err->release();
+                        }
+                    }
+                    else
+                        errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
+                }
+                break;
+            case 6: // Programm Schließen
+                if( !adminId )
+                    errorZuKlient( "Du musst dich einloggen." );
+                else
+                {
+                    bool ok = 0;
+                    if( ss->isRunning() )
+                    {
+                        if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSBeenden ) )
+                        {
+                            if( ss->serverBeenden() )
+                                ok = 1;
+                            else
+                            {
+                                Text *err = new Text();
+                                err->append( ss->getLetzterFehler() );
+                                errorZuKlient( err->getText() );
+                                err->release();
+                            }
+                        }
+                        else
+                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
+                    }
+                    else
+                        ok = 1;
+                    if( ok && ss->hatClients() )
+                    {
+                        errorZuKlient( "Es sind noch Klients Online. Bitte versuche es später erneut." );
+                        break;
+                    }
+                    if( ok )
+                    {
+                        klient->sende( "\1", 1 );
+                        std::cout << "SS: Der Server wird von Benutzer " << adminId << " heruntergefahren.\n";
+                        ss->close();
+                        br = 1;
+                    }
+                }
+                break;
+            case 7: // Progtamm abstürzen
+                if( !adminId )
+                    errorZuKlient( "Du musst dich einloggen." );
+                else
+                {
+                    bool ok = 0;
+                    if( ss->isRunning() )
+                    {
+                        if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSBeenden ) )
+                        {
+                            ss->serverBeenden();
+                            ok = 1;
+                        }
+                        else
+                            errorZuKlient( "Du bist nicht berechtigt den Server zu beenden." );
+                    }
+                    else
+                        ok = 1;
+                    if( ok )
+                    {
+                        klient->sende( "\1", 1 );
+                        std::cout << "sS: Der Server wurde von Benutzer " << adminId << " terminiert.\n";
+                        ss->close();
+                        br = 1;
+                    }
+                }
+                break;
+            case 8: // Status Frage
+                if( 1 )
+                {
+                    char status = 0;
+                    if( ss->isRunning() )
+                    {
+                        status = 1;
+                        if( ss->istAn() )
+                            status = 2;
+                    }
+                    klient->sende( "\1", 1 );
+                    klient->sende( &status, 1 );
+                }
+                break;
+            case 9: // Server pausieren
+                if( !adminId )
+                    errorZuKlient( "Du musst dich einloggen." );
+                else
+                {
+                    klient->sende( "\1", 1 );
+                    char pause = 0;
+                    klient->getNachricht( &pause, 1 );
+                    if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSPausieren ) )
+                    {
+                        bool ok = 0;
+                        if( pause )
+                            ok = ss->serverPause();
+                        else
+                            ok = ss->serverFortsetzen();
+                        if( ok )
+                            klient->sende( "\1", 1 );
+                        else
+                        {
+                            Text *err = new Text();
+                            err->append( ss->getLetzterFehler() );
+                            errorZuKlient( err->getText() );
+                            err->release();
+                        }
+                    }
+                    else
+                    {
+                        if( pause )
+                            errorZuKlient( "Du bist nicht berechtigt den Server zu pausieren." );
+                        else
+                            errorZuKlient( "Du bist nicht berechtigt den Server fortzusetzen." );
+                    }
+                }
+                break;
+            case 0xA: // maximale Anzahl der Spiele setzen
+                if( !adminId )
+                    errorZuKlient( "Du musst dich einloggen." );
+                else
+                {
+                    klient->sende( "\1", 1 );
+                    int maxS = 0;
+                    klient->getNachricht( (char *)&maxS, 4 );
+                    if( ss->zDB()->adminHatRecht( adminId, Admin_Recht::SSMSChange ) )
+                    {
+                        if( ss->setMaxSpiele( maxS ) )
+                            klient->sende( "\1", 1 );
+                        else
+                        {
+                            Text *err = new Text();
+                            err->append( ss->getLetzterFehler() );
+                            errorZuKlient( err->getText() );
+                            err->release();
+                        }
+                    }
+                    else
+                        errorZuKlient( "Du bist nicht berechtigt die maximale Anzahl der Clients zu verändern." );
+                }
+                break;
+            case 0xB: // Spiel Historie downloaden
+                if( adminId )
+                    errorZuKlient( "Zugriff verweigert." );
+                else
+                {
+                    klient->sende( "\1", 1 );
+                    int spielId = 0;
+                    klient->getNachricht( (char *)&spielId, 4 );
+                    if( !ss->hatSpielHistorieId( spielId ) )
+                    {
+                        errorZuKlient( "Zugriff auf Spiel-Historie verweigert." );
+                        break;
+                    }
+                    Text *pfad = new Text( "../spiel log/" );
+                    *pfad += spielId;
+                    *pfad += "/fertig";
+                    if( !DateiExistiert( *pfad ) )
+                    {
+                        pfad->release();
+                        errorZuKlient( "Die Spiel-Historie wurde nicht gefunden." );
+                        break;
+                    }
+                    klient->sende( "\1", 1 );
+                    pfad->remove( "/fertig" );
+                    sendeVerzeichnisAnKlient( *pfad, pfad->getLength() + 1 );
+                    pfad->release();
+                    klient->sende( "\0", 1 );
+                }
+                break;
             case 0xC: // klient absturtz
                 if( 1 )
                 {
                     klient->sende( "\1", 1 );
                     int klientId = 0;
-                    klient->getNachricht( (char*)&klientId, 4 );
+                    klient->getNachricht( (char *)&klientId, 4 );
                     if( klientId && ss->absturzKlient( klientId ) )
                         klient->sende( "\1", 1 );
                     else
                         klient->sende( "\0", 1 );
                 }
                 break;
-			default:
-				errorZuKlient( "Unbekannte Nachricht!" );
-				break;
-			}
-			if( br )
-				break;
-			ss->addEmpfangen( klient->getDownloadBytes( 1 ) );
-			ss->addGesendet( klient->getUploadBytes( 1 ) );
-		}
-	}
-	ss->addEmpfangen( klient->getDownloadBytes( 1 ) );
-	ss->addGesendet( klient->getUploadBytes( 1 ) );
-	delete this;
+            default:
+                errorZuKlient( "Unbekannte Nachricht!" );
+                break;
+            }
+            if( br )
+                break;
+            ss->addEmpfangen( klient->getDownloadBytes( 1 ) );
+            ss->addGesendet( klient->getUploadBytes( 1 ) );
+        }
+    }
+    ss->addEmpfangen( klient->getDownloadBytes( 1 ) );
+    ss->addGesendet( klient->getUploadBytes( 1 ) );
+    delete this;
 }
 
 void SSAKlient::sendeVerzeichnisAnKlient( char *pfad, int gpl )
 {
-	Datei *d = new Datei();
-	d->setDatei( pfad );
-	if( d->istOrdner() )
-	{
-		int dAnz = d->getUnterdateiAnzahl();
-		RCArray< Text > *list = d->getDateiListe();
-		for( int i = 0; i < dAnz; i++ )
-		{
-			if( list->z( i ) )
-			{
-				Text *pf = new Text( pfad );
-				pf->append( "/" );
-				pf->append( list->z( i )->getText() );
-				sendeVerzeichnisAnKlient( *pf, gpl );
-				pf->release();
-			}
-		}
-		list->release();
-	}
-	else if( d->existiert() )
-	{
-		__int64 gr = d->getSize();
-		if( gr && d->zPfad()->getLength() - gpl > 0 && d->open( Datei::Style::lesen ) )
-		{
-			char pfLen = (char)( d->zPfad()->getLength() - gpl );
-			klient->sende( &pfLen, 1 );
-			klient->sende( d->zPfad()->getText() + gpl, pfLen );
-			klient->sende( (char*)&gr, 8 );
-			char *bytes = new char[ 2048 ];
-			while( gr )
-			{
-				short len = gr > 2048 ? 2048 : (short)gr;
-				d->lese( bytes, len );
-				klient->sende( bytes, len );
-				gr -= len;
-			}
-			delete[] bytes;
-			d->close();
-		}
-	}
-	d->release();
+    Datei *d = new Datei();
+    d->setDatei( pfad );
+    if( d->istOrdner() )
+    {
+        int dAnz = d->getUnterdateiAnzahl();
+        RCArray< Text > *list = d->getDateiListe();
+        for( int i = 0; i < dAnz; i++ )
+        {
+            if( list->z( i ) )
+            {
+                Text *pf = new Text( pfad );
+                pf->append( "/" );
+                pf->append( list->z( i )->getText() );
+                sendeVerzeichnisAnKlient( *pf, gpl );
+                pf->release();
+            }
+        }
+        list->release();
+    }
+    else if( d->existiert() )
+    {
+        __int64 gr = d->getSize();
+        if( gr && d->zPfad()->getLength() - gpl > 0 && d->open( Datei::Style::lesen ) )
+        {
+            char pfLen = (char)( d->zPfad()->getLength() - gpl );
+            klient->sende( &pfLen, 1 );
+            klient->sende( d->zPfad()->getText() + gpl, pfLen );
+            klient->sende( (char *)&gr, 8 );
+            char *bytes = new char[ 2048 ];
+            while( gr )
+            {
+                short len = gr > 2048 ? 2048 : (short)gr;
+                d->lese( bytes, len );
+                klient->sende( bytes, len );
+                gr -= len;
+            }
+            delete[] bytes;
+            d->close();
+        }
+    }
+    d->release();
 }
 
 void SSAKlient::errorZuKlient( const char *nachricht ) const // sendet eine Fehlernachricht zum Klient
 {
-	klient->sende( "\3", 1 );
-	char len = (char)textLength( nachricht );
-	klient->sende( &len, 1 );
-	klient->sende( nachricht, len );
+    klient->sende( "\3", 1 );
+    char len = (char)textLength( nachricht );
+    klient->sende( &len, 1 );
+    klient->sende( nachricht, len );
 }
 
 
 // Inhalt der SSKlient Klasse aus SpielServer.h
 // Konstruktor 
 SSKlient::SSKlient( SKlient *klient, SpielServer *ss )
-: SSKlientV()
-{
-	empfangen = klient;
-	unsigned char key[ 20 ] = { 253, 234, 211, 132, 121, 230, 95, 145, 201, 13, 43, 77, 153, 223, 253, 69, 234, 43, 52, 99 };
-	klient->setSendeKey( (char*)key, 20 );
-	klient->setEmpfangKey( (char*)key, 20 );
-	senden = 0;
-	this->ss = ss;
-	accountId = 0;
-	klientNummer = 0;
-	termThread = 1;
-	verbunden = 0;
-	zErstellt = 0;
-	zSpiel = 0;
-	InitializeCriticalSection( &cs );
+    : SSKlientV()
+{
+    empfangen = klient;
+    unsigned char key[ 20 ] = { 253, 234, 211, 132, 121, 230, 95, 145, 201, 13, 43, 77, 153, 223, 253, 69, 234, 43, 52, 99 };
+    klient->setSendeKey( (char *)key, 20 );
+    klient->setEmpfangKey( (char *)key, 20 );
+    senden = 0;
+    this->ss = ss;
+    accountId = 0;
+    klientNummer = 0;
+    termThread = 1;
+    verbunden = 0;
+    zErstellt = 0;
+    zSpiel = 0;
+    InitializeCriticalSection( &cs );
 }
 
 // Destruktor 
 SSKlient::~SSKlient()
 {
-	lock();
-	unlock();
-	if( verbunden )
-		trenne();
-	if( termThread )
-	{
-		if( verbunden )
-			warteAufThread( 1000 );
-		if( verbunden )
-		{
-			if( empfangen )
-				empfangen->trenne();
-			if( senden )
-				senden->trenne();
-		}
-		if( empfangen )
-			empfangen->release();
-		if( senden )
-			senden->release();
-		DeleteCriticalSection( &cs );
-		ss->klientsMM( this );
-		ss->release();
-		ende(); // Eventuelles Ende des Aktuellen Threades
-	}
-	else
-	{
-		if( verbunden )
-		{
-			if( empfangen )
-				empfangen->trenne();
-			if( senden )
-				senden->trenne();
-		}
-		if( empfangen )
-			empfangen->release();
-		if( senden )
-			senden->release();
-		DeleteCriticalSection( &cs );
-		ss->klientsMM( this );
-		ss->release();
-	}
+    lock();
+    unlock();
+    if( verbunden )
+        trenne();
+    if( termThread )
+    {
+        if( verbunden )
+            warteAufThread( 1000 );
+        if( verbunden )
+        {
+            if( empfangen )
+                empfangen->trenne();
+            if( senden )
+                senden->trenne();
+        }
+        if( empfangen )
+            empfangen->release();
+        if( senden )
+            senden->release();
+        DeleteCriticalSection( &cs );
+        ss->klientsMM( this );
+        ss->release();
+        ende(); // Eventuelles Ende des Aktuellen Threades
+    }
+    else
+    {
+        if( verbunden )
+        {
+            if( empfangen )
+                empfangen->trenne();
+            if( senden )
+                senden->trenne();
+        }
+        if( empfangen )
+            empfangen->release();
+        if( senden )
+            senden->release();
+        DeleteCriticalSection( &cs );
+        ss->klientsMM( this );
+        ss->release();
+    }
 }
 
 // nicht constant
 void SSKlient::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void SSKlient::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 void SSKlient::absturz()
 {
-	ende();
-	if( senden )
-		senden->trenne();
-	empfangen->trenne();
+    ende();
+    if( senden )
+        senden->trenne();
+    empfangen->trenne();
 }
 
 void SSKlient::setSpielErstellt( SpielErstellt *zErstellt )
 {
-	this->zErstellt = zErstellt;
+    this->zErstellt = zErstellt;
 }
 
 void SSKlient::setSpiel( Spiel *zSpiel )
 {
-	this->zSpiel = zSpiel;
+    this->zSpiel = zSpiel;
 }
 
 void SSKlient::nichtTrennen()
 {
-	verbunden = 0;
+    verbunden = 0;
 }
 
 void SSKlient::spielGefunden( int karteId )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\xB", 1 );
-	senden->sendeEncrypted( (char*)&karteId, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\xB", 1 );
+    senden->sendeEncrypted( (char *)&karteId, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::zeitVerbleibend( char sekunden )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\1", 1 );
-	senden->sendeEncrypted( &sekunden, 1 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\1", 1 );
+    senden->sendeEncrypted( &sekunden, 1 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungAbgebrochen( char *grund )
 {
-	if( !senden )
-		return;
-	char len = (char)textLength( grund );
-	lock();
-	senden->sendeEncrypted( "\2", 1 );
-	senden->sendeEncrypted( &len, 1 );
-	if( len )
-		senden->sendeEncrypted( grund, len );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    char len = (char)textLength( grund );
+    lock();
+    senden->sendeEncrypted( "\2", 1 );
+    senden->sendeEncrypted( &len, 1 );
+    if( len )
+        senden->sendeEncrypted( grund, len );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::backInWarteschlange( char st, char min, char sec )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\4", 1 );
-	senden->sendeEncrypted( &st, 1 );
-	senden->sendeEncrypted( &min, 1 );
-	senden->sendeEncrypted( &sec, 1 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\4", 1 );
+    senden->sendeEncrypted( &st, 1 );
+    senden->sendeEncrypted( &min, 1 );
+    senden->sendeEncrypted( &sec, 1 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungFortsetzen()
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\5", 1 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\5", 1 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungInitialisierung( SpielerTeamStruktur *sts )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\6", 1 );
-	senden->sendeEncrypted( (char*)&sts->spielerAnzahl, 4 );
-	senden->sendeEncrypted( (char*)&sts->teamAnzahl, 4 );
-	for( int i = 0; i < sts->spielerAnzahl; i++ )
-	{
-		int f = sts->spielerFarbe->hat( i ) ? sts->spielerFarbe->get( i ) : 0;
-		senden->sendeEncrypted( (char*)&f, 4 );
-	}
-	for( int i = 0; i < sts->teamAnzahl; i++ )
-	{
-		int f = sts->teamFarbe->hat( i ) ? sts->teamFarbe->get( i ) : 0;
-		senden->sendeEncrypted( (char*)&f, 4 );
-	}
-	for( int i = 0; i < sts->teamAnzahl; i++ )
-	{
-		Text *name = sts->teamName->z( i );
-		char len = (char)name->getLength();
-		senden->sendeEncrypted( &len, 1 );
-		if( len )
-			senden->sendeEncrypted( name->getText(), len );
-	}
-	for( int i = 0; i < sts->teamAnzahl; i++ )
-	{
-		int size = sts->teamSize->hat( i ) ? sts->teamSize->get( i ) : 0;
-		senden->sendeEncrypted( (char*)&size, 4 );
-	}
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\6", 1 );
+    senden->sendeEncrypted( (char *)&sts->spielerAnzahl, 4 );
+    senden->sendeEncrypted( (char *)&sts->teamAnzahl, 4 );
+    for( int i = 0; i < sts->spielerAnzahl; i++ )
+    {
+        int f = sts->spielerFarbe->hat( i ) ? sts->spielerFarbe->get( i ) : 0;
+        senden->sendeEncrypted( (char *)&f, 4 );
+    }
+    for( int i = 0; i < sts->teamAnzahl; i++ )
+    {
+        int f = sts->teamFarbe->hat( i ) ? sts->teamFarbe->get( i ) : 0;
+        senden->sendeEncrypted( (char *)&f, 4 );
+    }
+    for( int i = 0; i < sts->teamAnzahl; i++ )
+    {
+        Text *name = sts->teamName->z( i );
+        char len = (char)name->getLength();
+        senden->sendeEncrypted( &len, 1 );
+        if( len )
+            senden->sendeEncrypted( name->getText(), len );
+    }
+    for( int i = 0; i < sts->teamAnzahl; i++ )
+    {
+        int size = sts->teamSize->hat( i ) ? sts->teamSize->get( i ) : 0;
+        senden->sendeEncrypted( (char *)&size, 4 );
+    }
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungAddSpieler( int accountId )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\7", 1 );
-	senden->sendeEncrypted( (char*)&accountId, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\7", 1 );
+    senden->sendeEncrypted( (char *)&accountId, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungRemoveSpieler( int accountId )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\x8", 1 );
-	senden->sendeEncrypted( (char*)&accountId, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\x8", 1 );
+    senden->sendeEncrypted( (char *)&accountId, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungSpielerTeam( int accountId, int spielerNummer )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\x9", 1 );
-	senden->sendeEncrypted( (char*)&accountId, 4 );
-	senden->sendeEncrypted( (char*)&spielerNummer, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\x9", 1 );
+    senden->sendeEncrypted( (char *)&accountId, 4 );
+    senden->sendeEncrypted( (char *)&spielerNummer, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::erstellungChatNachricht( char *nachricht )
 {
-	if( !senden )
-		return;
-	char len = (char)textLength( nachricht );
-	if( !len )
-		return;
-	lock();
-	senden->sendeEncrypted( "\xA", 1 );
-	senden->sendeEncrypted( &len, 1 );
-	senden->sendeEncrypted( nachricht, len );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    char len = (char)textLength( nachricht );
+    if( !len )
+        return;
+    lock();
+    senden->sendeEncrypted( "\xA", 1 );
+    senden->sendeEncrypted( &len, 1 );
+    senden->sendeEncrypted( nachricht, len );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::spielLadenBeginn()
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\xC", 1 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\xC", 1 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::spielLadenSpielerAdd( int accId, int spielerNumer )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\xD", 1 );
-	senden->sendeEncrypted( (char*)&accId, 4 );
-	senden->sendeEncrypted( (char*)&spielerNumer, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\xD", 1 );
+    senden->sendeEncrypted( (char *)&accId, 4 );
+    senden->sendeEncrypted( (char *)&spielerNumer, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::spielLadenSetSpielerProzent( int accId, int prozent )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\xE", 1 );
-	senden->sendeEncrypted( (char*)&accId, 4 );
-	senden->sendeEncrypted( (char*)&prozent, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\xE", 1 );
+    senden->sendeEncrypted( (char *)&accId, 4 );
+    senden->sendeEncrypted( (char *)&prozent, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::spielLadenSetSpielerPing( int accId, int ping )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\xF", 1 );
-	senden->sendeEncrypted( (char*)&accId, 4 );
-	senden->sendeEncrypted( (char*)&ping, 4 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\xF", 1 );
+    senden->sendeEncrypted( (char *)&accId, 4 );
+    senden->sendeEncrypted( (char *)&ping, 4 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 double SSKlient::ping()
 {
-	if( !senden )
-		return 0;
-	ZeitMesser *zeit = new ZeitMesser();
-	char ret = 0;
-	lock();
-	zeit->messungStart();
-	senden->sendeEncrypted( "\x10", 1 );
-	senden->getNachrichtEncrypted( &ret, 1 );
-	zeit->messungEnde();
-	unlock();
-	double retVal = zeit->getSekunden();
-	zeit->release();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
-	return retVal;
+    if( !senden )
+        return 0;
+    ZeitMesser *zeit = new ZeitMesser();
+    char ret = 0;
+    lock();
+    zeit->messungStart();
+    senden->sendeEncrypted( "\x10", 1 );
+    senden->getNachrichtEncrypted( &ret, 1 );
+    zeit->messungEnde();
+    unlock();
+    double retVal = zeit->getSekunden();
+    zeit->release();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
+    return retVal;
 }
 
 void SSKlient::spielLadenFertig()
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\x11", 1 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\x11", 1 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::spielNachricht( short len, char *bytes )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\x12", 1 );
-	senden->sende( (char*)&len, 2 );
-	senden->sende( bytes, len );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\x12", 1 );
+    senden->sende( (char *)&len, 2 );
+    senden->sende( bytes, len );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::statistikNachricht( short len, char *bytes )
 {
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\x13", 1 );
-	senden->sendeEncrypted( (char*)&len, 2 );
-	senden->sendeEncrypted( bytes, len );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\x13", 1 );
+    senden->sendeEncrypted( (char *)&len, 2 );
+    senden->sendeEncrypted( bytes, len );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 bool SSKlient::keepAlive()
 {
-	if( !senden || !verbunden )
-		return 0;
-	char res = 0;
-	lock();
-	senden->sendeEncrypted( "\x14", 1 );
-	senden->getNachrichtEncrypted( &res, 1 );
-	unlock();
-	return res == 1;
+    if( !senden || !verbunden )
+        return 0;
+    char res = 0;
+    lock();
+    senden->sendeEncrypted( "\x14", 1 );
+    senden->getNachrichtEncrypted( &res, 1 );
+    unlock();
+    return res == 1;
 }
 
 void SSKlient::trenne()
 {
-	if( !verbunden )
-		return;
-	verbunden = 0;
-	if( !senden )
-		return;
-	lock();
-	senden->sendeEncrypted( "\0", 1 );
-	unlock();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    if( !verbunden )
+        return;
+    verbunden = 0;
+    if( !senden )
+        return;
+    lock();
+    senden->sendeEncrypted( "\0", 1 );
+    unlock();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::setSenden( SSKlient *klient )
 {
-	senden = klient->getKlient();
-	Text *key = ss->zDB()->getKlientKey( klientNummer );
-	if( !key )
-	{
-		senden->sendeEncrypted( "\0", 1 );
-		errorZuKlientSende( "Es konnte kein Key ermittelt werden." );
-	}
-	else
-	{
-		senden->sendeEncrypted( "\1", 1 );
-		senden->setEmpfangKey( *key, key->getLength() );
-		senden->setSendeKey( *key, key->getLength() );
-		key->release();
-	}
-	verbunden = 1;
-	if( !ss->verteileKlient( this ) )
-		ss->unregisterKlient( this );
-	klient->nichtTrennen();
-	klient->release();
-	ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-	ss->addGesendet( senden->getUploadBytes( 1 ) );
+    senden = klient->getKlient();
+    Text *key = ss->zDB()->getKlientKey( klientNummer );
+    if( !key )
+    {
+        senden->sendeEncrypted( "\0", 1 );
+        errorZuKlientSende( "Es konnte kein Key ermittelt werden." );
+    }
+    else
+    {
+        senden->sendeEncrypted( "\1", 1 );
+        senden->setEmpfangKey( *key, key->getLength() );
+        senden->setSendeKey( *key, key->getLength() );
+        key->release();
+    }
+    verbunden = 1;
+    if( !ss->verteileKlient( this ) )
+        ss->unregisterKlient( this );
+    klient->nichtTrennen();
+    klient->release();
+    ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+    ss->addGesendet( senden->getUploadBytes( 1 ) );
 }
 
 void SSKlient::thread()
 {
-	int unbekannt = 0;
-	bool del = 0;
-	while( 1 )
-	{
-		bool br = 0;
-		char message = 0;
-		if( empfangen->getNachrichtEncrypted( &message, 1 ) )
-		{
-			switch( message )
-			{
-			case 1: // Klient Identifikation
-				empfangen->getNachrichtEncrypted( (char*)&klientNummer, 4 );
-				if( !klientNummer )
-					errorZuKlientEmpfang( "Du besitzt noch keine Klient Nummer." );
-				else
-				{
-					accountId = ss->zDB()->getAccountId( klientNummer );
-					termThread = 0;
-					if( ss->registerKlient( this ) )
-						return;
-					termThread = 1; 
-					Text *key = ss->zDB()->getKlientKey( klientNummer );
-					if( !key )
-						errorZuKlientEmpfang( "Es konnte kein Key ermittelt werden." );
-					else
-					{
-						empfangen->sendeEncrypted( "\1", 1 );
-						empfangen->setEmpfangKey( *key, key->getLength() );
-						empfangen->setSendeKey( *key, key->getLength() );
-						key->release();
-					}
-				}
-				break;
-			case 2: // Main / Erhaltung Server message
-				if( 1 )
-				{
-					char befehl = 0;
-					empfangen->getNachrichtEncrypted( &befehl, 1 );
-					switch( befehl )
-					{
-					case 2: // klient absturtz
-						if( 1 )
-						{
-							int klientId = 0;
-							empfangen->getNachrichtEncrypted( (char*)&klientId, 4 );
-							if( klientId && ss->absturzKlient( klientId ) )
-								empfangen->sendeEncrypted( "\1", 1 );
-							else
-								empfangen->sendeEncrypted( "\0", 1 );
-						}
-						break;
-					default:
-						errorZuKlientEmpfang( "Befehl nicht bekannt!" );
-						break;
-					}
-				}
-				break;
-			case 3: // Verbindungsende
-				trenne();
-				empfangen->sendeEncrypted( "\1", 1 );
-				br = 1;
-				break;
-			case 4: // SpielErstellt annehmen
-				if( zErstellt )
-				{
-					if( zErstellt->klientNimmtAn( accountId ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					}
-				}
-				else
-				{
-					empfangen->sendeEncrypted( "\0", 1 );
-					errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
-				}
-				break;
-			case 5: // SpielErstellt ablehnen
-				if( zErstellt )
-				{
-					if( zErstellt->klientLehntAb( accountId ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					}
-				}
-				else
-				{
-					empfangen->sendeEncrypted( "\0", 1 );
-					errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
-				}
-				break;
-			case 6: // SpielErstellt team wechseln
-				if( zSpiel )
-				{
-					empfangen->sendeEncrypted( "\1", 1 );
-					int team = 0;
-					empfangen->getNachrichtEncrypted( (char*)&team, 4 );
-					if( zSpiel->klientWechseltTeam( accountId, team ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Das Team Ist bereits voll." );
-					}
-				}
-				else
-				{
-					empfangen->sendeEncrypted( "\0", 1 );
-					errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
-				}
-				break;
-			case 7: // SpielErstellt chat Nachricht
-				if( zSpiel )
-				{
-					empfangen->sendeEncrypted( "\1", 1 );
-					unsigned char len = 0;
-					empfangen->getNachrichtEncrypted( (char*)&len, 1 );
-					char *nachricht = new char[ len + 1 ];
-					nachricht[ (int)len ] = 0;
-					if( len )
-						empfangen->getNachrichtEncrypted( nachricht, len );
-					Text *msg = ss->zDB()->getAccountRufName( accountId );
-					msg->append( ": " );
-					msg->append( nachricht );
-					delete[] nachricht;
-					if( zSpiel->chatNachricht( msg->getText() ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					}
-					msg->release();
-				}
-				else
-				{
-					empfangen->sendeEncrypted( "\0", 1 );
-					errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
-				}
-				break;
-			case 8: // Server Message
-				if( 1 )
-				{
-					char befehl = 0;
-					empfangen->getNachrichtEncrypted( &befehl, 1 );
-					switch( befehl )
-					{
-					case 0: // Verbindung Trennen
-						empfangen->sendeEncrypted( "\1", 1 );
-						br = 1;
-						del = 1;
-						break;
-					case 1: // Spiel Erstellen Abbrechen
-						if( 1 )
-						{
-							empfangen->sendeEncrypted( "\1", 1 );
-							int spielErstelltId = 0;
-							empfangen->getNachrichtEncrypted( (char*)&spielErstelltId, 4 );
-							ss->SpielErstelltAbbruch( spielErstelltId );
-							empfangen->sendeEncrypted( "\1", 1 );
-						}
-						break;
-					default:
-						empfangen->sendeEncrypted( "\0", 1 );
-						break;
-					}
-				}
-				break;
-			case 9: // Bereit zum Laden
-				if( zSpiel && zSpiel->klientBereitZumLaden( accountId ) )
-					empfangen->sendeEncrypted( "\1", 1 );
-				else
-				{
-					empfangen->sendeEncrypted( "\0", 1 );
-					errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-				}
-				break;
-			case 0xA: // Bereit zum Spiel
-				if( zSpiel && zSpiel->klientBereitZumSpiel( accountId ) )
-					empfangen->sendeEncrypted( "\1", 1 );
-				else
-				{
-					empfangen->sendeEncrypted( "\0", 1 );
-					errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-				}
-				break;
-			case 0xB: // Spiel Nachricht
-				if( 1 )
-				{
-					unsigned short len = 0;
-					empfangen->getNachricht( (char*)&len, 2 );
-					char *bytes = new char[ len ];
-					empfangen->getNachricht( bytes, len );
-					if( !zSpiel || !zSpiel->spielNachricht( accountId, len, bytes ) )
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					delete[] bytes;
-				}
-				break;
-			case 0xC: // Spiel Laden Prozent
-				if( 1 )
-				{
-					empfangen->sendeEncrypted( "\1", 1 );
-					int prozent = 0;
-					empfangen->getNachrichtEncrypted( (char*)&prozent, 4 );
-					if( zSpiel && zSpiel->klientSpielLadenProzent( accountId, prozent ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					}
-				}
-				break;
-			case 0xD: // Statistik Nachricht
-				if( 1 )
-				{
-					empfangen->sendeEncrypted( "\1", 1 );
-					unsigned short len = 0;
-					empfangen->getNachrichtEncrypted( (char*)&len, 2 );
-					char *bytes = new char[ len ];
-					empfangen->getNachrichtEncrypted( bytes, len );
-					if( zSpiel && zSpiel->statistikNachricht( accountId, len, bytes ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					}
-					delete[] bytes;
-				}
-				break;
-			case 0xE: // Team wählen Fertig
-				if( 1 )
-				{
-					if( zSpiel && zSpiel->klientTeamAuswahlFertig( accountId ) )
-						empfangen->sendeEncrypted( "\1", 1 );
-					else
-					{
-						empfangen->sendeEncrypted( "\0", 1 );
-						errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
-					}
-				}
-				break;
-			case 0xF: // ping
-				if( 1 )
-				{
-					empfangen->sendeEncrypted( "\1", 1 );
-					keepAlive();
-				}
-				break;
-			default:
-				empfangen->sendeEncrypted( "\0", 1 );
-				errorZuKlientSende( "Unbekannte Nachricht." );
-				unbekannt += 2;
-				if( unbekannt > 10 )
-				{
-					trenne();
-					br = 1;
-				}
-				break;
-			}
-			unbekannt--;
-			if( unbekannt < 0 )
-				unbekannt = 0;
-		}
-		else
-		{
-			trenne();
-			br = 1;
-		}
-		if( br )
-			break;
-		ss->addEmpfangen( empfangen->getDownloadBytes( 1 ) );
-		ss->addGesendet( empfangen->getUploadBytes( 1 ) );
-	}
-	ss->addEmpfangen( empfangen->getDownloadBytes( 1 ) );
-	ss->addGesendet( empfangen->getUploadBytes( 1 ) );
-	if( del || !accountId )
-	{
-		termThread = 0;
-		delete this;
-	}
-	else
-	{
-		termThread = 0;
-		ss->unregisterKlient( this );
-	}
+    int unbekannt = 0;
+    bool del = 0;
+    while( 1 )
+    {
+        bool br = 0;
+        char message = 0;
+        if( empfangen->getNachrichtEncrypted( &message, 1 ) )
+        {
+            switch( message )
+            {
+            case 1: // Klient Identifikation
+                empfangen->getNachrichtEncrypted( (char *)&klientNummer, 4 );
+                if( !klientNummer )
+                    errorZuKlientEmpfang( "Du besitzt noch keine Klient Nummer." );
+                else
+                {
+                    accountId = ss->zDB()->getAccountId( klientNummer );
+                    termThread = 0;
+                    if( ss->registerKlient( this ) )
+                        return;
+                    termThread = 1;
+                    Text *key = ss->zDB()->getKlientKey( klientNummer );
+                    if( !key )
+                        errorZuKlientEmpfang( "Es konnte kein Key ermittelt werden." );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\1", 1 );
+                        empfangen->setEmpfangKey( *key, key->getLength() );
+                        empfangen->setSendeKey( *key, key->getLength() );
+                        key->release();
+                    }
+                }
+                break;
+            case 2: // Main / Erhaltung Server message
+                if( 1 )
+                {
+                    char befehl = 0;
+                    empfangen->getNachrichtEncrypted( &befehl, 1 );
+                    switch( befehl )
+                    {
+                    case 2: // klient absturtz
+                        if( 1 )
+                        {
+                            int klientId = 0;
+                            empfangen->getNachrichtEncrypted( (char *)&klientId, 4 );
+                            if( klientId && ss->absturzKlient( klientId ) )
+                                empfangen->sendeEncrypted( "\1", 1 );
+                            else
+                                empfangen->sendeEncrypted( "\0", 1 );
+                        }
+                        break;
+                    default:
+                        errorZuKlientEmpfang( "Befehl nicht bekannt!" );
+                        break;
+                    }
+                }
+                break;
+            case 3: // Verbindungsende
+                trenne();
+                empfangen->sendeEncrypted( "\1", 1 );
+                br = 1;
+                break;
+            case 4: // SpielErstellt annehmen
+                if( zErstellt )
+                {
+                    if( zErstellt->klientNimmtAn( accountId ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    }
+                }
+                else
+                {
+                    empfangen->sendeEncrypted( "\0", 1 );
+                    errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
+                }
+                break;
+            case 5: // SpielErstellt ablehnen
+                if( zErstellt )
+                {
+                    if( zErstellt->klientLehntAb( accountId ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    }
+                }
+                else
+                {
+                    empfangen->sendeEncrypted( "\0", 1 );
+                    errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
+                }
+                break;
+            case 6: // SpielErstellt team wechseln
+                if( zSpiel )
+                {
+                    empfangen->sendeEncrypted( "\1", 1 );
+                    int team = 0;
+                    empfangen->getNachrichtEncrypted( (char *)&team, 4 );
+                    if( zSpiel->klientWechseltTeam( accountId, team ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Das Team Ist bereits voll." );
+                    }
+                }
+                else
+                {
+                    empfangen->sendeEncrypted( "\0", 1 );
+                    errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
+                }
+                break;
+            case 7: // SpielErstellt chat Nachricht
+                if( zSpiel )
+                {
+                    empfangen->sendeEncrypted( "\1", 1 );
+                    unsigned char len = 0;
+                    empfangen->getNachrichtEncrypted( (char *)&len, 1 );
+                    char *nachricht = new char[ len + 1 ];
+                    nachricht[ (int)len ] = 0;
+                    if( len )
+                        empfangen->getNachrichtEncrypted( nachricht, len );
+                    Text *msg = ss->zDB()->getAccountRufName( accountId );
+                    msg->append( ": " );
+                    msg->append( nachricht );
+                    delete[] nachricht;
+                    if( zSpiel->chatNachricht( msg->getText() ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    }
+                    msg->release();
+                }
+                else
+                {
+                    empfangen->sendeEncrypted( "\0", 1 );
+                    errorZuKlientSende( "Dir wurde kein erstelltes Spiel zugeteilt." );
+                }
+                break;
+            case 8: // Server Message
+                if( 1 )
+                {
+                    char befehl = 0;
+                    empfangen->getNachrichtEncrypted( &befehl, 1 );
+                    switch( befehl )
+                    {
+                    case 0: // Verbindung Trennen
+                        empfangen->sendeEncrypted( "\1", 1 );
+                        br = 1;
+                        del = 1;
+                        break;
+                    case 1: // Spiel Erstellen Abbrechen
+                        if( 1 )
+                        {
+                            empfangen->sendeEncrypted( "\1", 1 );
+                            int spielErstelltId = 0;
+                            empfangen->getNachrichtEncrypted( (char *)&spielErstelltId, 4 );
+                            ss->SpielErstelltAbbruch( spielErstelltId );
+                            empfangen->sendeEncrypted( "\1", 1 );
+                        }
+                        break;
+                    default:
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        break;
+                    }
+                }
+                break;
+            case 9: // Bereit zum Laden
+                if( zSpiel && zSpiel->klientBereitZumLaden( accountId ) )
+                    empfangen->sendeEncrypted( "\1", 1 );
+                else
+                {
+                    empfangen->sendeEncrypted( "\0", 1 );
+                    errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                }
+                break;
+            case 0xA: // Bereit zum Spiel
+                if( zSpiel && zSpiel->klientBereitZumSpiel( accountId ) )
+                    empfangen->sendeEncrypted( "\1", 1 );
+                else
+                {
+                    empfangen->sendeEncrypted( "\0", 1 );
+                    errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                }
+                break;
+            case 0xB: // Spiel Nachricht
+                if( 1 )
+                {
+                    unsigned short len = 0;
+                    empfangen->getNachricht( (char *)&len, 2 );
+                    char *bytes = new char[ len ];
+                    empfangen->getNachricht( bytes, len );
+                    if( !zSpiel || !zSpiel->spielNachricht( accountId, len, bytes ) )
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    delete[] bytes;
+                }
+                break;
+            case 0xC: // Spiel Laden Prozent
+                if( 1 )
+                {
+                    empfangen->sendeEncrypted( "\1", 1 );
+                    int prozent = 0;
+                    empfangen->getNachrichtEncrypted( (char *)&prozent, 4 );
+                    if( zSpiel && zSpiel->klientSpielLadenProzent( accountId, prozent ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    }
+                }
+                break;
+            case 0xD: // Statistik Nachricht
+                if( 1 )
+                {
+                    empfangen->sendeEncrypted( "\1", 1 );
+                    unsigned short len = 0;
+                    empfangen->getNachrichtEncrypted( (char *)&len, 2 );
+                    char *bytes = new char[ len ];
+                    empfangen->getNachrichtEncrypted( bytes, len );
+                    if( zSpiel && zSpiel->statistikNachricht( accountId, len, bytes ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    }
+                    delete[] bytes;
+                }
+                break;
+            case 0xE: // Team wählen Fertig
+                if( 1 )
+                {
+                    if( zSpiel && zSpiel->klientTeamAuswahlFertig( accountId ) )
+                        empfangen->sendeEncrypted( "\1", 1 );
+                    else
+                    {
+                        empfangen->sendeEncrypted( "\0", 1 );
+                        errorZuKlientSende( "Es ist ein unbekannter Fehler aufgetreten." );
+                    }
+                }
+                break;
+            case 0xF: // ping
+                if( 1 )
+                {
+                    empfangen->sendeEncrypted( "\1", 1 );
+                    keepAlive();
+                }
+                break;
+            default:
+                empfangen->sendeEncrypted( "\0", 1 );
+                errorZuKlientSende( "Unbekannte Nachricht." );
+                unbekannt += 2;
+                if( unbekannt > 10 )
+                {
+                    trenne();
+                    br = 1;
+                }
+                break;
+            }
+            unbekannt--;
+            if( unbekannt < 0 )
+                unbekannt = 0;
+        }
+        else
+        {
+            trenne();
+            br = 1;
+        }
+        if( br )
+            break;
+        ss->addEmpfangen( empfangen->getDownloadBytes( 1 ) );
+        ss->addGesendet( empfangen->getUploadBytes( 1 ) );
+    }
+    ss->addEmpfangen( empfangen->getDownloadBytes( 1 ) );
+    ss->addGesendet( empfangen->getUploadBytes( 1 ) );
+    if( del || !accountId )
+    {
+        termThread = 0;
+        delete this;
+    }
+    else
+    {
+        termThread = 0;
+        ss->unregisterKlient( this );
+    }
 }
 
 void SSKlient::errorZuKlientEmpfang( const char *nachricht ) // sendet eine Fehlernachricht zum Klient
 {
-	unsigned char len = (unsigned char)textLength( nachricht );
-	if( !len )
-		return;
-	if( empfangen )
-	{
-		empfangen->sendeEncrypted( "\3", 1 );
-		empfangen->sendeEncrypted( (char *)&len, 1 );
-		empfangen->sendeEncrypted( nachricht, len );
-	}
-	ss->addEmpfangen( empfangen->getDownloadBytes( 1 ) );
-	ss->addGesendet( empfangen->getUploadBytes( 1 ) );
+    unsigned char len = (unsigned char)textLength( nachricht );
+    if( !len )
+        return;
+    if( empfangen )
+    {
+        empfangen->sendeEncrypted( "\3", 1 );
+        empfangen->sendeEncrypted( (char *)&len, 1 );
+        empfangen->sendeEncrypted( nachricht, len );
+    }
+    ss->addEmpfangen( empfangen->getDownloadBytes( 1 ) );
+    ss->addGesendet( empfangen->getUploadBytes( 1 ) );
 }
 
 void SSKlient::errorZuKlientSende( const char *nachricht )
 {
-	unsigned char len = (unsigned char)textLength( nachricht );
-	if( !len )
-		return;
-	if( senden )
-	{
-		lock();
-		senden->sendeEncrypted( "\3", 1 );
-		senden->sendeEncrypted( (char*)&len, 1 );
-		senden->sendeEncrypted( nachricht, len );
-		unlock();
-		ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
-		ss->addGesendet( senden->getUploadBytes( 1 ) );
-	}
+    unsigned char len = (unsigned char)textLength( nachricht );
+    if( !len )
+        return;
+    if( senden )
+    {
+        lock();
+        senden->sendeEncrypted( "\3", 1 );
+        senden->sendeEncrypted( (char *)&len, 1 );
+        senden->sendeEncrypted( nachricht, len );
+        unlock();
+        ss->addEmpfangen( senden->getDownloadBytes( 1 ) );
+        ss->addGesendet( senden->getUploadBytes( 1 ) );
+    }
 }
 
 // const
 int SSKlient::getAccountId() const
 {
-	return accountId;
+    return accountId;
 }
 
 int SSKlient::getKlientNummer() const
 {
-	return klientNummer;
+    return klientNummer;
 }
 
 SKlient *SSKlient::getKlient() const
 {
-	return empfangen->getThis();
+    return dynamic_cast<SKlient *>( empfangen->getThis() );
 }

SpielServer/SpielServer.vcxproj

@@ -65,7 +65,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt />
     <RemoteProjectDir>$(RemoteRootDir)/Server/$(ProjectName)/debug</RemoteProjectDir>
-    <IncludePath>..\..\..\..\Allgemein\Framework;../../../Framework/debug;..\..\..\..\Allgemein\Network\Network;../../../Network/debug;..\..\..\..\Allgemein\sql\sql;../../../sql/debug;$(IncludePath)</IncludePath>
+    <IncludePath>..\..\..\..\Allgemein\Framework;../../../Framework/debug;..\..\..\..\Allgemein\Network\Network;../../../Network/debug/Network;..\..\..\..\Allgemein\sql\sql;../../../sql/debug/sql;$(IncludePath)</IncludePath>
     <OutDir>$(RemoteRootDir)/Server/$(ProjectName)/debug/</OutDir>
     <IntDir>$(RemoteRootDir)/Server/$(ProjectName)/debug/</IntDir>
     <RemoteTargetPath>$(RemoteProjectDir)/$(TargetName)$(TargetExt)</RemoteTargetPath>
@@ -73,7 +73,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <TargetExt />
     <RemoteProjectDir>$(RemoteRootDir)/Server/$(ProjectName)/release</RemoteProjectDir>
-    <IncludePath>..\..\..\..\Allgemein\Framework;../../../Framework/release;..\..\..\..\Allgemein\Network\Network;../../../Network/release;..\..\..\..\Allgemein\sql\sql;../../../sql/release;$(IncludePath)</IncludePath>
+    <IncludePath>..\..\..\..\Allgemein\Framework;../../../Framework/release;..\..\..\..\Allgemein\Network\Network;../../../Network/release/Network;..\..\..\..\Allgemein\sql\sql;../../../sql/release/sql;$(IncludePath)</IncludePath>
     <OutDir>$(RemoteRootDir)/Server/$(ProjectName)/release/</OutDir>
     <IntDir>$(RemoteRootDir)/Server/$(ProjectName)/release/</IntDir>
     <RemoteTargetPath>$(RemoteProjectDir)/$(TargetName)$(TargetExt)</RemoteTargetPath>
@@ -104,15 +104,17 @@
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Link>
       <AdditionalLibraryDirectories>$(RemoteRootDir)/sql/debug;$(RemoteRootDir)/Network/debug;$(RemoteRootDir)/Framework/debug;/usr/lib/;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <LibraryDependencies>dbgFramework;dbgNetwork;dbgSQL;pq;pthread;dl</LibraryDependencies>
+      <LibraryDependencies>dbgFramework;dbgNetwork;dbgSQL;pq;pthread;dl;ssl</LibraryDependencies>
       <AdditionalOptions>-Wl,-rpath,../lib %(AdditionalOptions)</AdditionalOptions>
+      <OutputFile>$(RemoteProjectDir)/$(TargetName)$(TargetExt)</OutputFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Link>
       <AdditionalLibraryDirectories>$(RemoteRootDir)/sql/release;$(RemoteRootDir)/Network/release;$(RemoteRootDir)/Framework/release;/usr/lib/;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <LibraryDependencies>Framework;Network;SQL;pq;pthread;dl</LibraryDependencies>
+      <LibraryDependencies>Framework;Network;SQL;pq;pthread;dl;ssl</LibraryDependencies>
       <AdditionalOptions>-Wl,-rpath,../lib %(AdditionalOptions)</AdditionalOptions>
+      <OutputFile>$(RemoteProjectDir)/$(TargetName)$(TargetExt)</OutputFile>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

SpielServer/Statistik.h

@@ -1,23 +1,17 @@
 #ifndef Statistik_H
 #define Statistik_H
 
-class StatistikV
+class StatistikV : public virtual ReferenceCounter
 {
 private:
 
 public:
-	virtual ~StatistikV()
-	{
-	}
-	// nicht constant
-	virtual void klientOffline( int accountId ) = 0;
-	virtual void statistikAnfrage( int accountId, short len, char *bytes ) = 0;
-	virtual void run() = 0;
-	// constant
-
-	// Reference Counting
-	virtual StatistikV *getThis() = 0;
-	virtual StatistikV *release() = 0;
+    virtual ~StatistikV()
+    {	}
+    // nicht constant
+    virtual void klientOffline( int accountId ) = 0;
+    virtual void statistikAnfrage( int accountId, short len, char *bytes ) = 0;
+    virtual void run() = 0;
 };
 
 #endif

SpielServer/Strukturen.cpp

@@ -2,34 +2,20 @@
 
 // Inhalt der SpielerTeamStruktur Struktur aus Strukturen.h
 SpielerTeamStruktur::SpielerTeamStruktur()
+    : ReferenceCounter()
 {
-	spielerAnzahl = 0;
-	teamAnzahl = 0;
-	spielerFarbe = new Array< int >();
-	teamFarbe = new Array< int >();
-	teamName = new RCArray< Text >();
-	teamSize = new Array< int >();
-	ref = 1;
+    spielerAnzahl = 0;
+    teamAnzahl = 0;
+    spielerFarbe = new Array< int >();
+    teamFarbe = new Array< int >();
+    teamName = new RCArray< Text >();
+    teamSize = new Array< int >();
 }
 
 SpielerTeamStruktur::~SpielerTeamStruktur()
 {
-	spielerFarbe->release();
-	teamFarbe->release();
-	teamName->release();
-	teamSize->release();
-}
-
-SpielerTeamStruktur *SpielerTeamStruktur::getThis()
-{
-	ref++;
-	return this;
-}
-
-SpielerTeamStruktur *SpielerTeamStruktur::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    spielerFarbe->release();
+    teamFarbe->release();
+    teamName->release();
+    teamSize->release();
 }

SpielServer/Strukturen.h

@@ -7,19 +7,16 @@
 
 using namespace Framework;
 
-struct SpielerTeamStruktur
+struct SpielerTeamStruktur : public virtual ReferenceCounter
 {
-	SpielerTeamStruktur();
-	~SpielerTeamStruktur();
-	int spielerAnzahl;
-	int teamAnzahl;
-	Array< int > *spielerFarbe;
-	Array< int > *teamFarbe;
-	RCArray< Text > *teamName;
-	Array< int > *teamSize;
-	int ref;
-	SpielerTeamStruktur *getThis();
-	SpielerTeamStruktur *release();
+    SpielerTeamStruktur();
+    ~SpielerTeamStruktur();
+    int spielerAnzahl;
+    int teamAnzahl;
+    Array< int > *spielerFarbe;
+    Array< int > *teamFarbe;
+    RCArray< Text > *teamName;
+    Array< int > *teamSize;
 };
 
 #endif

SpielServer/start.cpp

@@ -7,31 +7,31 @@
 
 int main()
 {
-	struct rlimit core_limits;
-	core_limits.rlim_cur = core_limits.rlim_max = RLIM_INFINITY;
-	setrlimit(RLIMIT_CORE, &core_limits);
+    struct rlimit core_limits;
+    core_limits.rlim_cur = core_limits.rlim_max = RLIM_INFINITY;
+    setrlimit( RLIMIT_CORE, &core_limits );
     //chdir( "/ksg/Server/spiel" );
     Framework::initFramework();
-	Zeit *z = getZeit();
-	Text *pfad = new Text( "../log/spiel/" );
-	pfad->append( z->getZeit( "y-m-d h-i-s.log" ) );
-	z->release();
-	DateiPfadErstellen( pfad->getThis() );
-	std::ofstream file;
-	file.open( pfad->getText() );
-	std::streambuf* sbuf = std::cout.rdbuf();
-	std::cout.rdbuf( file.rdbuf() );
-	pfad->release();
+    Zeit *z = getZeit();
+    Text *pfad = new Text( "../log/spiel/" );
+    pfad->append( z->getZeit( "y-m-d h-i-s.log" ) );
+    z->release();
+    DateiPfadErstellen( pfad->getText() );
+    std::ofstream file;
+    file.open( pfad->getText() );
+    std::streambuf *sbuf = std::cout.rdbuf();
+    std::cout.rdbuf( file.rdbuf() );
+    pfad->release();
 
-	std::cout << "SS: Startet...\n";
-	std::cout << "SS: Lese init Datei ../data/ssInit.ini ...\n";
-	InitDatei *dat = new InitDatei( "../data/ssInit.ini" );
-	if( !dat->laden() )
-	{
-		std::cout << "SS: error: Datei konnte nicht gelesen werden. Das Programm wird geschlossen.\n";
-		dat->release();
-		exit( 1 );
-	}
+    std::cout << "SS: Startet...\n";
+    std::cout << "SS: Lese init Datei ../data/ssInit.ini ...\n";
+    InitDatei *dat = new InitDatei( "../data/ssInit.ini" );
+    if( !dat->laden() )
+    {
+        std::cout << "SS: error: Datei konnte nicht gelesen werden. Das Programm wird geschlossen.\n";
+        dat->release();
+        exit( 1 );
+    }
     const char *wichtig[] = { "ServerId", "DBBenutzer", "DBPasswort", "DBName", "DBIP", "DBPort", "Aktiv", "SpielePfad", "TempMapPfad", "SSLCert", "SSLKey", "SSLPasswort" };
     for( const char *w : wichtig )
     {
@@ -43,18 +43,18 @@ int main()
         }
     }
 
-	SpielServer *sServer = new SpielServer( dat );
+    SpielServer *sServer = new SpielServer( dat );
 
-	std::cout << "SS: Der Admin Server läuft. Startforgang beendet.\n";
-	sServer->runn();
+    std::cout << "SS: Der Admin Server läuft. Startforgang beendet.\n";
+    sServer->runn();
 
-	sServer->ende();
-	sServer->release();
+    sServer->ende();
+    sServer->release();
     DateiRemove( dat->zWert( "TempMapPfad" )->getText() );
-	dat->release();
-	std::cout << "SS: Der Server ist heruntergefahren.\n";
-	file.close();
+    dat->release();
+    std::cout << "SS: Der Server ist heruntergefahren.\n";
+    file.close();
     std::cout.rdbuf( sbuf );
     Framework::releaseFramework();
-	return 0;
+    return 0;
 }