framework changes

SpielServer/Datenbank.cpp

@@ -6,1090 +6,1090 @@
 
 // Inhalt der SSDatenbank Klasse aus Datenbank.h
 // Konstruktor
-SSDatenbank::SSDatenbank( InitDatei *zIni )
-    : ReferenceCounter()
+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 ) );
-    if( !datenbank->istOk() )
-    {
-        std::cout << "SS: Die Verbindung zur Datenbank konnte nicht hergestellt werden.\nDas Programm wird beendet.";
-        exit( 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();
-    datenbank->befehl( befehl );
-    Result res = datenbank->getResult();
-    unlock();
-    if( res.zeilenAnzahl == 1 )
-    {
-        zIni->addWert( "ServerPort", res.values[ 0 ] );
-        zIni->addWert( "AdminServerPort", res.values[ 1 ] );
-        zIni->addWert( "ServerIp", res.values[ 2 ] );
-    }
-    res.destroy();
+	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 = dynamic_cast<InitDatei*>(zIni->getThis());
+	Text befehl = "SELECT port, admin_port, ip FROM server WHERE id = ";
+	befehl += zIni->zWert("ServerId")->getText();
+	lock();
+	datenbank->befehl(befehl);
+	Result res = datenbank->getResult();
+	unlock();
+	if (res.zeilenAnzahl == 1)
+	{
+		zIni->addWert("ServerPort", res.values[0]);
+		zIni->addWert("AdminServerPort", res.values[1]);
+		zIni->addWert("ServerIp", res.values[2]);
+	}
+	res.destroy();
 }
 
 // Destruktor
 SSDatenbank::~SSDatenbank()
 {
-    datenbank->release();
-    DeleteCriticalSection( &cs );
-    ini->release();
+	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 )
+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 )
+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(n);
+	befehl->append("' AND passwort = md5( '");
+	Text p(passwort);
+	p.ersetzen("'", "''");
+	befehl->append(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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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->add( TextZuInt( res.values[ i ].getText(), 10 ) );
-    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->add(TextZuInt(res.values[i].getText(), 10));
+	res.destroy();
+	return ret;
 }
 
-int SSDatenbank::getKarteVonErstelltemSpiel( int spielErstelltId )
+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 )
+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 )
+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() ) )
-                    {
-                        while( !inWarteschlange->hat( j ) )
-                            inWarteschlange->add( 0 );
-                        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 );
-                        while( !zeit->hat( j ) )
-                            zeit->add( 0 );
-                        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 ) )
-                        {
-                            while( !inWarteschlange->hat( j ) )
-                                inWarteschlange->add( 0 );
-                            inWarteschlange->set( 1, k );
-                            while( !zeit->hat( j ) )
-                                zeit->add( 0 );
-                            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;
+	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()))
+					{
+						while (!inWarteschlange->hat(j))
+							inWarteschlange->add(0);
+						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);
+						while (!zeit->hat(j))
+							zeit->add(0);
+						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))
+						{
+							while (!inWarteschlange->hat(j))
+								inWarteschlange->add(0);
+							inWarteschlange->set(1, k);
+							while (!zeit->hat(j))
+								zeit->add(0);
+							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 )
+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 )
+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 )
+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 )
+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->add( TextZuInt( res.values[ i ].getText(), 10 ) );
-    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->add(TextZuInt(res.values[i].getText(), 10));
+	res.destroy();
+	return ret;
 }
 
-int SSDatenbank::getAktionForKlient( int serverId, int accountId, int *id )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+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 )
+bool SSDatenbank::getKartenServer(int karteId, int* port, Text* ip)
 {
-    Text befehl = "SELECT a.port, a.ip FROM server a, karte b ";
-    befehl += "WHERE a.id = b.server_karten_id AND a.server_status_id = 3 AND b.id = ";
-    befehl += karteId;
-    lock();
-    if( !datenbank->befehl( befehl ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    *port = res.values[ 0 ];
-    ip->setText( res.values[ 1 ] );
-    res.destroy();
-    return 1;
+	Text befehl = "SELECT a.port, a.ip FROM server a, karte b ";
+	befehl += "WHERE a.id = b.server_karten_id AND a.server_status_id = 3 AND b.id = ";
+	befehl += karteId;
+	lock();
+	if (!datenbank->befehl(befehl))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	*port = (int)res.values[0];
+	ip->setText(res.values[1]);
+	res.destroy();
+	return 1;
 }
 
-Text *SSDatenbank::getSpielPfad( int karteId )
+Text* SSDatenbank::getSpielPfad(int karteId)
 {
-    Text befehl = "SELECT a.id FROM spiel_art a, karte b WHERE b.spiel_art_id = a.id AND b.id = ";
-    befehl += karteId;
-    lock();
-    if( !datenbank->befehl( befehl ) )
-    {
-        unlock();
-        return 0;
-    }
-    Result res = datenbank->getResult();
-    unlock();
-    if( !res.zeilenAnzahl )
-    {
-        res.destroy();
-        return 0;
-    }
-    int id = res.values[ 0 ];
-    res.destroy();
-    Text *ret = new Text( ini->zWert( "SpielePfad" )->getText() );
-    ret->append( "/" );
-    ret->append( id );
-    return ret;
+	Text befehl = "SELECT a.id FROM spiel_art a, karte b WHERE b.spiel_art_id = a.id AND b.id = ";
+	befehl += karteId;
+	lock();
+	if (!datenbank->befehl(befehl))
+	{
+		unlock();
+		return 0;
+	}
+	Result res = datenbank->getResult();
+	unlock();
+	if (!res.zeilenAnzahl)
+	{
+		res.destroy();
+		return 0;
+	}
+	int id = (int)res.values[0];
+	res.destroy();
+	Text* ret = new Text(ini->zWert("SpielePfad")->getText());
+	ret->append("/");
+	ret->append(id);
+	return ret;
 }
 
 // constant
-Text *SSDatenbank::getLetzterFehler() const
+Text* SSDatenbank::getLetzterFehler() const
 {
-    return datenbank->getLetzterFehler();
+	return datenbank->getLetzterFehler();
 }

SpielServer/HistorieSender.cpp

@@ -8,8 +8,8 @@
 
 // Inhalt der HistorieSender Klasse aus HistorieSender.h
 // Konstruktor
-HistorieSender::HistorieSender( SpielServer *zSS )
-    : Thread()
+HistorieSender::HistorieSender(SpielServer* zSS)
+	: Thread()
 {
 	this->zSS = zSS;
 	beenden = 0;
@@ -17,8 +17,7 @@ HistorieSender::HistorieSender( SpielServer *zSS )
 
 // Destruktor
 HistorieSender::~HistorieSender()
-{
-}
+{}
 
 // nicht constant
 void HistorieSender::setEnde()
@@ -28,65 +27,65 @@ void HistorieSender::setEnde()
 
 void HistorieSender::thread()
 {
-	Datei *d = new Datei();
-	d->setDatei( "../spiel log" );
-	while( !beenden )
+	Datei* d = new Datei();
+	d->setDatei("../spiel log");
+	while (!beenden)
 	{
-		Sleep( 10000 );
+		Sleep(10000);
 		int anz = d->getUnterdateiAnzahl();
-		RCArray< Text > *list = d->getDateiListe();
+		RCArray< Text >* list = d->getDateiListe();
 		int min = 0;
-		for( int i = 0; i < anz; i++ )
+		for (int i = 0; i < anz; i++)
 		{
-			if( !list->z( i ) )
+			if (!list->z(i))
 				continue;
-			Text pf( d->zPfad()->getText() );
+			Text pf(d->zPfad()->getText());
 			pf += "/";
-			pf += list->z( i )->getText();
+			pf += list->z(i)->getText();
 			pf += "/fertig";
-			if( !DateiExistiert( pf ) )
+			if (!DateiExistiert(pf))
 				continue;
-			if( !min || min >( int )*list->z( i ) )
-				min = *list->z( i );
+			if (!min || min > (int)*list->z(i))
+				min = (int)*list->z(i);
 		}
 		list->release();
-		if( min )
+		if (min)
 		{
 			short port = 0;
-			Text *ip = new Text();
-			if( zSS->zDB()->suchHistorieServer( &port, ip ) )
+			Text* ip = new Text();
+			if (zSS->zDB()->suchHistorieServer(&port, ip))
 			{
-				Klient *k = new Klient();
-				unsigned char key[ 20 ] = { 207, 30, 72, 46, 30, 50, 56, 213, 82, 107, 14, 201, 149, 58, 110, 138, 228, 241, 52, 54 };
-				k->setSendeKey( (char*)key, 20 );
-				k->setEmpfangKey( (char*)key, 20 );
-				if( k->verbinde( port, *ip ) )
+				Klient* k = new Klient();
+				unsigned char key[20] = { 207, 30, 72, 46, 30, 50, 56, 213, 82, 107, 14, 201, 149, 58, 110, 138, 228, 241, 52, 54 };
+				k->setSendeKey((char*)key, 20);
+				k->setEmpfangKey((char*)key, 20);
+				if (k->verbinde(port, *ip))
 				{
-					zSS->addSpielHistorieId( min );
+					zSS->addSpielHistorieId(min);
 					unsigned char ret = 0;
-					k->sendeEncrypted( "\5", 1 );
-					k->getNachrichtEncrypted( (char*)&ret, 1 );
-					if( ret == 1 )
+					k->sendeEncrypted("\5", 1);
+					k->getNachrichtEncrypted((char*)&ret, 1);
+					if (ret == 1)
 					{
 						int server = zSS->getId();
-						k->sendeEncrypted( (char*)&server, 4 );
-						k->sendeEncrypted( (char*)&min, 4 );
-						k->getNachrichtEncrypted( (char*)&ret, 1 );
-						if( ret == 1 )
-							DateiRemove( Text( "../spiel log/" ) += min );
+						k->sendeEncrypted((char*)&server, 4);
+						k->sendeEncrypted((char*)&min, 4);
+						k->getNachrichtEncrypted((char*)&ret, 1);
+						if (ret == 1)
+							DateiRemove(Text("../spiel log/") += min);
 					}
-					if( ret == 3 )
+					if (ret == 3)
 					{
-						k->getNachrichtEncrypted( (char*)&ret, 1 );
-						char *err = new char[ ret ];
-						k->getNachrichtEncrypted( err, ret );
+						k->getNachrichtEncrypted((char*)&ret, 1);
+						char* err = new char[ret];
+						k->getNachrichtEncrypted(err, ret);
 						delete[] err;
 					}
-					k->sendeEncrypted( "\3", 1 );
-					k->getNachrichtEncrypted( (char*)&ret, 1 );
+					k->sendeEncrypted("\3", 1);
+					k->getNachrichtEncrypted((char*)&ret, 1);
 					k->trenne();
 					k->release();
-					zSS->removeSpielHistorieId( min );
+					zSS->removeSpielHistorieId(min);
 				}
 			}
 			ip->release();

SpielServer/KartenLeser.cpp

@@ -10,184 +10,184 @@
 
 // Inhalt der KartenLeser Klasse aus KartenLeser.h
 // Konstruktor 
-KartenLeser::KartenLeser( int sNum, int karteId, SpielServer *ss )
-    : ReferenceCounter()
+KartenLeser::KartenLeser(int sNum, int karteId, SpielServer* ss)
+	: ReferenceCounter()
 {
-    this->ss = ss;
-    pfad = new Text( "" );
-    this->sNum = sNum;
-    setKarteId( karteId );
+	this->ss = ss;
+	pfad = new Text("");
+	this->sNum = sNum;
+	setKarteId(karteId);
 }
 
 // Destruktor
 KartenLeser::~KartenLeser()
 {
-    ss->release();
-    pfad->release();
+	ss->release();
+	pfad->release();
 }
 
 // nicht constant
-bool KartenLeser::setKarteId( int id )
+bool KartenLeser::setKarteId(int id)
 {
-    bool retVal = 1;
-    Text pf = ss->zInit()->zWert( "TempMapPfad" )->getText();
-    pf += "/";
-    pf += sNum;
-    if( !DateiExistiert( pf ) )
-    { // Karte Herunterladen
-        Text ip;
-        int port;
-        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 );
-        if( !klient->verbinde( (unsigned short)port, ip ) )
-        {
-            klient = (Klient *)klient->release();
-            return 0;
-        }
-        klient->sendeEncrypted( "\x7", 1 );
-        char ret = 0;
-        klient->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            klient->sendeEncrypted( (char *)&id, 4 );
-            klient->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 2 )
-            { // update
-                retVal = 0;
-            }
-            else if( ret == 1 )
-            {
-                int anz = 0;
-                klient->getNachrichtEncrypted( (char *)&anz, 4 );
-                for( int i = 0; i < anz; i++ )
-                {
-                    unsigned char len = 0;
-                    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 );
-                    char *buffer = new char[ 2048 ];
-                    Text pfad = pf.getText();
-                    pfad += "/";
-                    pfad += pfa;
-                    delete[] pfa;
-                    Datei d;
-                    d.setDatei( pfad );
-                    d.erstellen();
-                    d.open( Datei::Style::schreiben );
-                    while( size )
-                    {
-                        int l = size >= 2048 ? 2048 : (int)size;
-                        klient->getNachricht( buffer, l );
-                        d.schreibe( buffer, l );
-                        size -= l;
-                    }
-                    d.close();
-                    delete[] buffer;
-                }
-            }
-        }
-        if( ret == 3 )
-        {
-            retVal = 0;
-            unsigned char byte = 0;
-            klient->getNachrichtEncrypted( (char *)&byte, 1 );
-            char *f = new char[ byte + 1 ];
-            f[ (int)byte ] = 0;
-            klient->getNachrichtEncrypted( f, byte );
-            delete[] f;
-        }
-        klient->sendeEncrypted( "\3", 1 );
-        klient->getNachrichtEncrypted( &ret, 1 );
-        klient->trenne();
-        klient->release();
-    }
-    karteId = id;
-    pfad->setText( (char *)pf );
-    return retVal;
+	bool retVal = 1;
+	Text pf = ss->zInit()->zWert("TempMapPfad")->getText();
+	pf += "/";
+	pf += sNum;
+	if (!DateiExistiert(pf))
+	{ // Karte Herunterladen
+		Text ip;
+		int port;
+		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);
+		if (!klient->verbinde((unsigned short)port, ip))
+		{
+			klient = (Klient*)klient->release();
+			return 0;
+		}
+		klient->sendeEncrypted("\x7", 1);
+		char ret = 0;
+		klient->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			klient->sendeEncrypted((char*)&id, 4);
+			klient->getNachrichtEncrypted(&ret, 1);
+			if (ret == 2)
+			{ // update
+				retVal = 0;
+			}
+			else if (ret == 1)
+			{
+				int anz = 0;
+				klient->getNachrichtEncrypted((char*)&anz, 4);
+				for (int i = 0; i < anz; i++)
+				{
+					unsigned char len = 0;
+					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);
+					char* buffer = new char[2048];
+					Text pfad = pf.getText();
+					pfad += "/";
+					pfad += pfa;
+					delete[] pfa;
+					Datei d;
+					d.setDatei(pfad);
+					d.erstellen();
+					d.open(Datei::Style::schreiben);
+					while (size)
+					{
+						int l = size >= 2048 ? 2048 : (int)size;
+						klient->getNachricht(buffer, l);
+						d.schreibe(buffer, l);
+						size -= l;
+					}
+					d.close();
+					delete[] buffer;
+				}
+			}
+		}
+		if (ret == 3)
+		{
+			retVal = 0;
+			unsigned char byte = 0;
+			klient->getNachrichtEncrypted((char*)&byte, 1);
+			char* f = new char[byte + 1];
+			f[(int)byte] = 0;
+			klient->getNachrichtEncrypted(f, byte);
+			delete[] f;
+		}
+		klient->sendeEncrypted("\3", 1);
+		klient->getNachrichtEncrypted(&ret, 1);
+		klient->trenne();
+		klient->release();
+	}
+	karteId = id;
+	pfad->setText(pf);
+	return retVal;
 }
 
-bool KartenLeser::ladeSpielerTeamStruktur( SpielerTeamStruktur *sts )
+bool KartenLeser::ladeSpielerTeamStruktur(SpielerTeamStruktur* sts)
 {
-    if( !pfad->getLength() )
-        return 0;
-    Text *pf = new Text( pfad->getText() );
-    pf->append( "/sts.ltgd" );
-    Datei *datei = new Datei();
-    datei->setDatei( pf );
-    if( !datei->existiert() || datei->istOrdner() )
-    {
-        datei->release();
-        return 0;
-    }
-    datei->open( Datei::Style::lesen );
-    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 );
-        sts->spielerFarbe->add( farbe );
-    }
-    if( sts->teamFarbe )
-        sts->teamFarbe->release();
-    sts->teamFarbe = new Array< int >();
-    for( int i = 0; i < sts->teamAnzahl; i++ )
-    {
-        int farbe = 0;
-        datei->lese( (char *)&farbe, 4 );
-        sts->teamFarbe->add( farbe );
-    }
-    if( sts->teamName )
-        sts->teamName->release();
-    sts->teamName = new RCArray< Text >();
-    for( int i = 0; i < sts->teamAnzahl; i++ )
-    {
-        unsigned char len = 0;
-        datei->lese( (char *)&len, 1 );
-        char *txt = new char[ len + 1 ];
-        txt[ (int)len ] = 0;
-        datei->lese( txt, len );
-        Text *name = new Text( txt );
-        delete[] txt;
-        sts->teamName->add( name );
-    }
-    if( sts->teamSize )
-        sts->teamSize->release();
-    sts->teamSize = new Array< int >();
-    for( int i = 0; i < sts->teamAnzahl; i++ )
-    {
-        int size = 0;
-        datei->lese( (char *)&size, 4 );
-        sts->teamSize->add( size );
-    }
-    datei->close();
-    datei->release();
-    return 1;
+	if (!pfad->getLength())
+		return 0;
+	Text* pf = new Text(pfad->getText());
+	pf->append("/sts.ltgd");
+	Datei* datei = new Datei();
+	datei->setDatei(pf);
+	if (!datei->existiert() || datei->istOrdner())
+	{
+		datei->release();
+		return 0;
+	}
+	datei->open(Datei::Style::lesen);
+	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);
+		sts->spielerFarbe->add(farbe);
+	}
+	if (sts->teamFarbe)
+		sts->teamFarbe->release();
+	sts->teamFarbe = new Array< int >();
+	for (int i = 0; i < sts->teamAnzahl; i++)
+	{
+		int farbe = 0;
+		datei->lese((char*)&farbe, 4);
+		sts->teamFarbe->add(farbe);
+	}
+	if (sts->teamName)
+		sts->teamName->release();
+	sts->teamName = new RCArray< Text >();
+	for (int i = 0; i < sts->teamAnzahl; i++)
+	{
+		unsigned char len = 0;
+		datei->lese((char*)&len, 1);
+		char* txt = new char[len + 1];
+		txt[(int)len] = 0;
+		datei->lese(txt, len);
+		Text* name = new Text(txt);
+		delete[] txt;
+		sts->teamName->add(name);
+	}
+	if (sts->teamSize)
+		sts->teamSize->release();
+	sts->teamSize = new Array< int >();
+	for (int i = 0; i < sts->teamAnzahl; i++)
+	{
+		int size = 0;
+		datei->lese((char*)&size, 4);
+		sts->teamSize->add(size);
+	}
+	datei->close();
+	datei->release();
+	return 1;
 }
 
 // constant
 int KartenLeser::getKarteId() const
 {
-    return karteId;
+	return karteId;
 }
 
-Text *KartenLeser::getPfad() const
+Text* KartenLeser::getPfad() const
 {
-    return pfad ? dynamic_cast<Text *>( pfad->getThis() ) : 0;
+	return pfad ? dynamic_cast<Text*>(pfad->getThis()) : 0;
 }
 
-Text *KartenLeser::zPfad() const
+Text* KartenLeser::zPfad() const
 {
-    return pfad;
+	return pfad;
 }

SpielServer/SSDatenbankV.h

@@ -10,18 +10,18 @@ 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;
-    virtual Text *getSpielPfad( int karteId ) = 0;
+	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;
+	virtual Text* getSpielPfad(int karteId) = 0;
 };
 
 #endif

SpielServer/SSKlientV.h

@@ -13,23 +13,23 @@ class SSKlientV : public Thread
 private:
 
 public:
-    // Konstructor
-    SSKlientV()
-        : Thread()
-    {}
-    virtual ~SSKlientV()
-    {}
-    // nicht constant 
-    virtual void nichtTrennen() = 0;
-    virtual double ping() = 0;
-    virtual void spielNachricht( short len, char *bytes ) = 0;
-    virtual void statistikNachricht( short len, char *bytes ) = 0;
-    virtual void trenne() = 0;
-    virtual void thread() = 0;
-    virtual void errorZuKlientEmpfang( const char *nachricht ) = 0; // sendet eine Fehlernachricht zum Klient
-    virtual void errorZuKlientSende( const char *nachricht ) = 0;
-    // const
-    virtual int getAccountId() const = 0;
+	// Konstructor
+	SSKlientV()
+		: Thread()
+	{}
+	virtual ~SSKlientV()
+	{}
+	// nicht constant 
+	virtual void nichtTrennen() = 0;
+	virtual double ping() = 0;
+	virtual void spielNachricht(short len, const char* bytes) = 0;
+	virtual void statistikNachricht(short len, const char* bytes) = 0;
+	virtual void trenne() = 0;
+	virtual void thread() = 0;
+	virtual void errorZuKlientEmpfang(const char* nachricht) = 0; // sendet eine Fehlernachricht zum Klient
+	virtual void errorZuKlientSende(const char* nachricht) = 0;
+	// const
+	virtual int getAccountId() const = 0;
 };
 
 #endif

SpielServer/Spiel.cpp

@@ -16,669 +16,669 @@
 #define FreeLibrary              dlclose
 #endif
 
-typedef SpielKlasse *( *DllStart )( );
+typedef SpielKlasse* (*DllStart)();
 
 // Inhalt der Spiel Klasse aus Spiel.h
 // Konstruktor
-Spiel::Spiel( int id, SpielServer *ss )
-    : Thread()
+Spiel::Spiel(int id, SpielServer* ss)
+	: Thread()
 {
-    this->ss = ss;
-    this->id = id;
-    klients = new RCArray< SSKlient >();
-    sts = new SpielerTeamStruktur();
-    accounts = new Array< int >();
-    spielerNummern = new Array< int >();
-    status = new Array< int >();
-    prozent = new Array< int >();
-    teamAuswahlFertig = new Array< bool >();
-    spiel = 0;
-    state = 0;
-    spielerAnzahl = 0;
-    karte = 0;
-    spielDll = 0;
-    statistik = 0;
+	this->ss = ss;
+	this->id = id;
+	klients = new RCArray< SSKlient >();
+	sts = new SpielerTeamStruktur();
+	accounts = new Array< int >();
+	spielerNummern = new Array< int >();
+	status = new Array< int >();
+	prozent = new Array< int >();
+	teamAuswahlFertig = new Array< bool >();
+	spiel = 0;
+	state = 0;
+	spielerAnzahl = 0;
+	karte = 0;
+	spielDll = 0;
+	statistik = 0;
 }
 
 // Destruktor
 Spiel::~Spiel()
 {
-    klients->release();
-    sts->release();
-    accounts->release();
-    spielerNummern->release();
-    status->release();
-    prozent->release();
-    teamAuswahlFertig->release();
-    if( spiel )
-        spiel->release();
-    if( statistik )
-        statistik->release();
-    if( spielDll )
-        FreeLibrary( spielDll );
-    ss->release();
+	klients->release();
+	sts->release();
+	accounts->release();
+	spielerNummern->release();
+	status->release();
+	prozent->release();
+	teamAuswahlFertig->release();
+	if (spiel)
+		spiel->release();
+	if (statistik)
+		statistik->release();
+	if (spielDll)
+		FreeLibrary(spielDll);
+	ss->release();
 }
 
 int Spiel::findFreeTeam()
 {
-    int free = 0;
-    int teamIndex = 0;
-    int teamSize = sts->teamSize->get( teamIndex );
-    double max = 0;
-    Array< int > teams;
-    for( int i = 0; i < sts->spielerAnzahl; i++ ) // suche nach teams die prozentual am wenigsten voll sind
-    {
-        bool used = 0;
-        for( int j = 0; j < spielerAnzahl; j++ )
-        {
-            if( spielerNummern->hat( j ) && spielerNummern->get( j ) == i + 1 )
-                used = 1;
-        }
-        if( !used )
-            free++;
-        teamSize--;
-        if( !teamSize )
-        {
-            double teamVal = (double)free / sts->teamSize->get( teamIndex );
-            if( teamVal > max )
-            {
-                teams.leeren();
-                max = teamVal;
-            }
-            if( teamVal >= max )
-                teams.add( teamIndex );
-            free = 0;
-            if( !sts->teamSize->hat( ++teamIndex ) )
-                break;
-            else
-                teamSize = sts->teamSize->get( teamIndex );
-        }
-    } // suche aus den teams eines zufällig aus
-    double randomVal = rand() / ( (double)RAND_MAX + 1 );
-    double diff = 1.0 / teams.getEintragAnzahl();
-    teamIndex = -1;
-    while( randomVal >= 0 )
-    {
-        randomVal -= diff;
-        teamIndex++;
-    }
-    if( teams.hat( teamIndex ) )
-        return teams.get( teamIndex );
-    else
-        return teams.get( 0 );
+	int free = 0;
+	int teamIndex = 0;
+	int teamSize = sts->teamSize->get(teamIndex);
+	double max = 0;
+	Array< int > teams;
+	for (int i = 0; i < sts->spielerAnzahl; i++) // suche nach teams die prozentual am wenigsten voll sind
+	{
+		bool used = 0;
+		for (int j = 0; j < spielerAnzahl; j++)
+		{
+			if (spielerNummern->hat(j) && spielerNummern->get(j) == i + 1)
+				used = 1;
+		}
+		if (!used)
+			free++;
+		teamSize--;
+		if (!teamSize)
+		{
+			double teamVal = (double)free / sts->teamSize->get(teamIndex);
+			if (teamVal > max)
+			{
+				teams.leeren();
+				max = teamVal;
+			}
+			if (teamVal >= max)
+				teams.add(teamIndex);
+			free = 0;
+			if (!sts->teamSize->hat(++teamIndex))
+				break;
+			else
+				teamSize = sts->teamSize->get(teamIndex);
+		}
+	} // suche aus den teams eines zufällig aus
+	double randomVal = rand() / ((double)RAND_MAX + 1);
+	double diff = 1.0 / teams.getEintragAnzahl();
+	teamIndex = -1;
+	while (randomVal >= 0)
+	{
+		randomVal -= diff;
+		teamIndex++;
+	}
+	if (teams.hat(teamIndex))
+		return teams.get(teamIndex);
+	else
+		return teams.get(0);
 }
 
 void Spiel::teamAusgleich()
 {
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        int sNum = spielerNummern->hat( i ) ? spielerNummern->get( i ) : 0;
-        if( !sNum )
-        {
-            int team = findFreeTeam();
-            for( int j = 0; j < team; j++ )
-                sNum += sts->teamSize->get( j );
-            while( true )
-            {
-                sNum++;
-                bool gefunden = 0;
-                for( int k = 0; k < spielerAnzahl; k++ )
-                {
-                    if( spielerNummern->hat( k ) && spielerNummern->get( k ) == sNum )
-                    {
-                        gefunden = 1;
-                        break;
-                    }
-                }
-                if( !gefunden )
-                    break;
-            }
-            while( !spielerNummern->hat( i ) )
-                spielerNummern->add( 0 );
-            spielerNummern->set( sNum, i );
-        }
-    }
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		int sNum = spielerNummern->hat(i) ? spielerNummern->get(i) : 0;
+		if (!sNum)
+		{
+			int team = findFreeTeam();
+			for (int j = 0; j < team; j++)
+				sNum += sts->teamSize->get(j);
+			while (true)
+			{
+				sNum++;
+				bool gefunden = 0;
+				for (int k = 0; k < spielerAnzahl; k++)
+				{
+					if (spielerNummern->hat(k) && spielerNummern->get(k) == sNum)
+					{
+						gefunden = 1;
+						break;
+					}
+				}
+				if (!gefunden)
+					break;
+			}
+			while (!spielerNummern->hat(i))
+				spielerNummern->add(0);
+			spielerNummern->set(sNum, i);
+		}
+	}
 }
 
 // nicht constant
-void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
+void Spiel::setAccounts(int anzahl, Array< int >* zAccounts)
 {
-    accounts->leeren();
-    for( int i = 0; i < anzahl; i++ )
-        accounts->add( zAccounts->hat( i ) ? zAccounts->get( i ) : 0 );
-    spielerAnzahl = anzahl;
+	accounts->leeren();
+	for (int i = 0; i < anzahl; i++)
+		accounts->add(zAccounts->hat(i) ? zAccounts->get(i) : 0);
+	spielerAnzahl = anzahl;
 }
 
-void Spiel::setKlients( int anzahl, RCArray< SSKlient > *zKlients )
+void Spiel::setKlients(int anzahl, RCArray< SSKlient >* zKlients)
 {
-    klients->leeren();
-    for( int i = 0; i < anzahl; i++ )
-        klients->add( zKlients->get( i ) );
+	klients->leeren();
+	for (int i = 0; i < anzahl; i++)
+		klients->add(zKlients->get(i));
 }
 
-void Spiel::setKarteId( int karteId )
+void Spiel::setKarteId(int karteId)
 {
-    karte = karteId;
-    KartenLeser *reader = new KartenLeser( id, karte, dynamic_cast<SpielServer *>( getThis() ) );
-    reader->ladeSpielerTeamStruktur( sts );
-    reader->release();
-    start();
+	karte = karteId;
+	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;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accId )
-        {
-            if( state == 1 )
-            {
-                klient->erstellungInitialisierung( sts );
-                for( int j = 0; j < spielerAnzahl; j++ )
-                {
-                    if( accounts->hat( j ) && accounts->get( j ) != accId )
-                    {
-                        SSKlient *tmp = klients->z( j );
-                        tmp->erstellungAddSpieler( accId );
-                        klient->erstellungAddSpieler( accounts->get( j ) );
-                        if( spielerNummern->hat( j ) )
-                            klient->erstellungSpielerTeam( accounts->get( j ), spielerNummern->get( j ) );
-                    }
-                }
-            }
-            if( state == 5 && spiel )
-                spiel->klientOnline( klient->getAccountId(), klient );
-            while( !klients->hat( i ) )
-                klients->add( 0 );
-            klients->set( klient, i );
-            while( !status->hat( i ) )
-                status->add( 0 );
-            status->set( 1, i );
-            klient->setSpiel( this );
-            ret = 1;
-            break;
-        }
-    }
-    if( !ret )
-        klient->release();
-    return ret;
+	int accId = klient->getAccountId();
+	bool ret = 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accId)
+		{
+			if (state == 1)
+			{
+				klient->erstellungInitialisierung(sts);
+				for (int j = 0; j < spielerAnzahl; j++)
+				{
+					if (accounts->hat(j) && accounts->get(j) != accId)
+					{
+						SSKlient* tmp = klients->z(j);
+						tmp->erstellungAddSpieler(accId);
+						klient->erstellungAddSpieler(accounts->get(j));
+						if (spielerNummern->hat(j))
+							klient->erstellungSpielerTeam(accounts->get(j), spielerNummern->get(j));
+					}
+				}
+			}
+			if (state == 5 && spiel)
+				spiel->klientOnline(klient->getAccountId(), klient);
+			while (!klients->hat(i))
+				klients->add(0);
+			klients->set(klient, i);
+			while (!status->hat(i))
+				status->add(0);
+			status->set(1, i);
+			klient->setSpiel(this);
+			ret = 1;
+			break;
+		}
+	}
+	if (!ret)
+		klient->release();
+	return ret;
 }
 
-bool Spiel::klientWechseltTeam( int accountId, int team )
+bool Spiel::klientWechseltTeam(int accountId, int team)
 {
-    if( state != 1 )
-        return 0;
-    if( team == 0 )
-    {
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            if( accounts->hat( i ) && accounts->get( i ) == accountId )
-            {
-                while( !spielerNummern->hat( i ) )
-                    spielerNummern->add( 0 );
-                spielerNummern->set( 0, i );
-            }
-            SSKlient *tmp = klients->z( i );
-            if( tmp )
-                tmp->erstellungSpielerTeam( accountId, 0 );
-        }
-        return 1;
-    }
-    int von = 1;
-    for( int i = 0; i < team - 1; i++ )
-    {
-        if( sts->teamSize->hat( i ) )
-            von += sts->teamSize->get( i );
-    }
-    int bis = von + ( sts->teamSize->hat( team - 1 ) ? sts->teamSize->get( team - 1 ) : 0 );
-    for( int i = von; i < bis; i++ )
-    {
-        bool verwendet = 0;
-        for( int j = 0; j < spielerAnzahl; j++ )
-        {
-            if( spielerNummern->hat( j ) && spielerNummern->get( j ) == i )
-            {
-                verwendet = 1;
-                break;
-            }
-        }
-        if( !verwendet )
-        {
-            for( int j = 0; j < spielerAnzahl; j++ )
-            {
-                if( accounts->hat( j ) && accounts->get( j ) == accountId )
-                {
-                    while( !spielerNummern->hat( j ) )
-                        spielerNummern->add( 0 );
-                    spielerNummern->set( i, j );
-                }
-                SSKlient *tmp = klients->z( j );
-                if( tmp )
-                    tmp->erstellungSpielerTeam( accountId, i );
-            }
-            return 1;
-        }
-    }
-    return 0;
+	if (state != 1)
+		return 0;
+	if (team == 0)
+	{
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			if (accounts->hat(i) && accounts->get(i) == accountId)
+			{
+				while (!spielerNummern->hat(i))
+					spielerNummern->add(0);
+				spielerNummern->set(0, i);
+			}
+			SSKlient* tmp = klients->z(i);
+			if (tmp)
+				tmp->erstellungSpielerTeam(accountId, 0);
+		}
+		return 1;
+	}
+	int von = 1;
+	for (int i = 0; i < team - 1; i++)
+	{
+		if (sts->teamSize->hat(i))
+			von += sts->teamSize->get(i);
+	}
+	int bis = von + (sts->teamSize->hat(team - 1) ? sts->teamSize->get(team - 1) : 0);
+	for (int i = von; i < bis; i++)
+	{
+		bool verwendet = 0;
+		for (int j = 0; j < spielerAnzahl; j++)
+		{
+			if (spielerNummern->hat(j) && spielerNummern->get(j) == i)
+			{
+				verwendet = 1;
+				break;
+			}
+		}
+		if (!verwendet)
+		{
+			for (int j = 0; j < spielerAnzahl; j++)
+			{
+				if (accounts->hat(j) && accounts->get(j) == accountId)
+				{
+					while (!spielerNummern->hat(j))
+						spielerNummern->add(0);
+					spielerNummern->set(i, j);
+				}
+				SSKlient* tmp = klients->z(j);
+				if (tmp)
+					tmp->erstellungSpielerTeam(accountId, i);
+			}
+			return 1;
+		}
+	}
+	return 0;
 }
 
-bool Spiel::chatNachricht( char *nachricht )
+bool Spiel::chatNachricht(const char* nachricht)
 {
-    if( state != 1 )
-        return 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-            tmp->erstellungChatNachricht( nachricht );
-    }
-    return 1;
+	if (state != 1)
+		return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+			tmp->erstellungChatNachricht(nachricht);
+	}
+	return 1;
 }
 
-bool Spiel::klientGetrennt( SSKlient *zKlient )
+bool Spiel::klientGetrennt(SSKlient* zKlient)
 {
-    int accId = zKlient->getAccountId();
-    bool ret = 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accId )
-        {
-            if( status->hat( i ) && status->get( i ) != 0 )
-            {
-                if( state == 1 )
-                {
-                    for( int j = 0; j < spielerAnzahl; j++ )
-                    {
-                        if( accounts->hat( j ) && accounts->get( j ) != accId )
-                        {
-                            SSKlient *tmp = klients->z( j );
-                            tmp->erstellungRemoveSpieler( accId );
-                        }
-                    }
-                }
-                if( state == 5 && spiel )
-                    spiel->klientOffline( zKlient->getAccountId() );
-                if( state == 6 )
-                {
-                    if( statistik )
-                        statistik->klientOffline( zKlient->getAccountId() );
-                }
-                zKlient->setSpielErstellt( 0 );
-                while( !spielerNummern->hat( i ) )
-                    spielerNummern->add( 0 );
-                spielerNummern->set( 0, i );
-                while( !status->hat( i ) )
-                    status->add( 0 );
-                status->set( 0, i );
-                while( !klients->hat( i ) )
-                    klients->add( 0 );
-                klients->set( 0, i );
-                ret = 1;
-            }
-            break;
-        }
-    }
-    return ret;
+	int accId = zKlient->getAccountId();
+	bool ret = 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accId)
+		{
+			if (status->hat(i) && status->get(i) != 0)
+			{
+				if (state == 1)
+				{
+					for (int j = 0; j < spielerAnzahl; j++)
+					{
+						if (accounts->hat(j) && accounts->get(j) != accId)
+						{
+							SSKlient* tmp = klients->z(j);
+							tmp->erstellungRemoveSpieler(accId);
+						}
+					}
+				}
+				if (state == 5 && spiel)
+					spiel->klientOffline(zKlient->getAccountId());
+				if (state == 6)
+				{
+					if (statistik)
+						statistik->klientOffline(zKlient->getAccountId());
+				}
+				zKlient->setSpielErstellt(0);
+				while (!spielerNummern->hat(i))
+					spielerNummern->add(0);
+				spielerNummern->set(0, i);
+				while (!status->hat(i))
+					status->add(0);
+				status->set(0, i);
+				while (!klients->hat(i))
+					klients->add(0);
+				klients->set(0, i);
+				ret = 1;
+			}
+			break;
+		}
+	}
+	return ret;
 }
 
-bool Spiel::klientTeamAuswahlFertig( int accountId )
+bool Spiel::klientTeamAuswahlFertig(int accountId)
 {
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-        {
-            while( !teamAuswahlFertig->hat( i ) )
-                teamAuswahlFertig->add( 0 );
-            teamAuswahlFertig->set( 1, i );
-            return 1;
-        }
-    }
-    return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+		{
+			while (!teamAuswahlFertig->hat(i))
+				teamAuswahlFertig->add(0);
+			teamAuswahlFertig->set(1, i);
+			return 1;
+		}
+	}
+	return 0;
 }
 
-bool Spiel::klientBereitZumLaden( int accountId )
+bool Spiel::klientBereitZumLaden(int accountId)
 {
-    if( state != 2 )
-        return 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-        {
-            while( !status->hat( i ) )
-                status->add( 0 );
-            status->set( 2, i );
-            return 1;
-        }
-    }
-    return 0;
+	if (state != 2)
+		return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+		{
+			while (!status->hat(i))
+				status->add(0);
+			status->set(2, i);
+			return 1;
+		}
+	}
+	return 0;
 }
 
-bool Spiel::klientSpielLadenProzent( int accountId, int prozent )
+bool Spiel::klientSpielLadenProzent(int accountId, int prozent)
 {
-    if( state != 3 && state != 2 )
-        return 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-        {
-            while( !this->prozent->hat( i ) )
-                this->prozent->add( 0 );
-            this->prozent->set( prozent, i );
-            return 1;
-        }
-    }
-    return 0;
+	if (state != 3 && state != 2)
+		return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+		{
+			while (!this->prozent->hat(i))
+				this->prozent->add(0);
+			this->prozent->set(prozent, i);
+			return 1;
+		}
+	}
+	return 0;
 }
 
-bool Spiel::klientBereitZumSpiel( int accountId )
+bool Spiel::klientBereitZumSpiel(int accountId)
 {
-    if( state != 4 )
-        return 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-        {
-            while( !status->hat( i ) )
-                status->add( 0 );
-            status->set( 3, i );
-            return 1;
-        }
-    }
-    return 0;
+	if (state != 4)
+		return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+		{
+			while (!status->hat(i))
+				status->add(0);
+			status->set(3, i);
+			return 1;
+		}
+	}
+	return 0;
 }
 
-bool Spiel::spielNachricht( int accountId, int len, char *bytes )
+bool Spiel::spielNachricht(int accountId, int len, char* bytes)
 {
-    if( state != 5 )
-        return 0;
-    if( spiel )
-    {
-        spiel->nachricht( accountId, len, bytes );
-        return 1;
-    }
-    return 0;
+	if (state != 5)
+		return 0;
+	if (spiel)
+	{
+		spiel->nachricht(accountId, len, bytes);
+		return 1;
+	}
+	return 0;
 }
 
-bool Spiel::statistikNachricht( int accountId, int len, char *bytes )
+bool Spiel::statistikNachricht(int accountId, int len, char* bytes)
 {
-    if( state != 6 )
-        return 0;
-    if( statistik )
-    {
-        statistik->statistikAnfrage( accountId, (short)len, bytes );
-        return 1;
-    }
-    return 0;
+	if (state != 6)
+		return 0;
+	if (statistik)
+	{
+		statistik->statistikAnfrage(accountId, (short)len, bytes);
+		return 1;
+	}
+	return 0;
 }
 
 void Spiel::thread()
 {
-    // Klients aktualisieren
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-        {
-            tmp->setSpielErstellt( 0 );
-            tmp->setSpiel( this );
-        }
-    }
-    // Vortsetzung senden
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-            tmp->erstellungInitialisierung( sts );
-    }
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-            tmp->erstellungFortsetzen();
-    }
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-        {
-            for( int j = 0; j < spielerAnzahl; j++ )
-            {
-                if( accounts->hat( j ) )
-                    tmp->erstellungAddSpieler( accounts->get( j ) );
-            }
-        }
-    }
-    // warten bis alle ein Team gewählt haben
-    double time = 0;
-    state = 1;
-    ZeitMesser *zeit = new ZeitMesser();
-    while( time < 40 )
-    {
-        zeit->messungStart();
-        Sleep( 100 );
-        char verbleibend = (char)( 40 - (char)time );
-        bool weiter = 1;
-        for( int i = 0; i < spielerAnzahl; i++ )
-            weiter &= teamAuswahlFertig->hat( i ) && teamAuswahlFertig->get( i );
-        if( verbleibend < 0 || weiter )
-        {
-            verbleibend = 0;
-            time = 40;
-        }
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            SSKlient *tmp = klients->z( i );
-            if( tmp )
-                tmp->zeitVerbleibend( verbleibend );
-        }
-        zeit->messungEnde();
-        time += zeit->getSekunden();
-    } // Spielernummern Aufteilen
-    zeit->release();
-    state = 2;
-    teamAusgleich();
-    Array< int > *teams = new Array< int >();
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        int sNum = spielerNummern->hat( i ) ? spielerNummern->get( i ) : 0;
-        int tg = 1;
-        for( int j = 0; j < sts->teamAnzahl; j++ )
-        {
-            tg += sts->teamSize->hat( j ) ? sts->teamSize->get( j ) : 0;
-            if( sNum < tg )
-            {
-                while( !teams->hat( i ) )
-                    teams->add( 0 );
-                teams->set( j, i );
-                break;
-            }
-        }
-    }
-    ss->zDB()->spielSetTeams( id, spielerAnzahl, accounts, teams );
-    ss->zDB()->spielSetSpielerNummern( id, spielerAnzahl, accounts, spielerNummern );
-    teams->release();
-    // Fortsetzung senden
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-            tmp->spielLadenBeginn();
-    }
-    // Auf bereitschaft warten
-    while( 1 )
-    {
-        Sleep( 100 );
-        bool br = 1;
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            if( klients->z( i ) )
-                br = br && status->hat( i ) && status->get( i ) == 2;
-        }
-        if( br )
-            break;
-    } // Spieler hinzufügen
-    for( int i = 0; i < spielerAnzahl; i++ )
-        spielerNummern->set( ( spielerNummern->hat( i ) ? spielerNummern->get( i ) : 0 ) - 1, i );
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-        {
-            for( int j = 0; j < spielerAnzahl; j++ )
-                tmp->spielLadenSpielerAdd( accounts->hat( j ) ? accounts->get( j ) : 0, spielerNummern->hat( j ) ? spielerNummern->get( j ) : 0 );
-        }
-    }
-    state = 3;
-    // Warten auf laden
-    while( 1 )
-    {
-        Sleep( 1000 );
-        bool br = 1;
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            SSKlient *tmp = klients->z( i );
-            if( tmp )
-            {
-                int ping = (int)( tmp->ping() * 1000 + 0.5 );
-                for( int j = 0; j < spielerAnzahl; j++ )
-                {
-                    SSKlient *k = klients->z( j );
-                    if( k )
-                    {
-                        k->spielLadenSetSpielerPing( accounts->hat( i ) ? accounts->get( i ) : 0, ping );
-                        k->spielLadenSetSpielerProzent( accounts->hat( i ) ? accounts->get( i ) : 0, prozent->hat( i ) ? prozent->get( i ) : 0 );
-                    }
-                }
-                br = br && prozent->hat( i ) && prozent->get( i ) == 100;
-            }
-        }
-        if( br )
-            break;
-    }
-    state = 4;
-    // Sende Fortsetzung
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-            tmp->spielLadenFertig();
-    }
-    // Spiel Initialisieren
-    Text *pfad = new Text( ss->zInit()->zWert( "SpielePfad" )->getText() );
-    pfad->append( "/" );
-    pfad->append( ss->zDB()->getSpielArtId( karte ) );
-    pfad->append( "/bin/game" );
+	// Klients aktualisieren
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+		{
+			tmp->setSpielErstellt(0);
+			tmp->setSpiel(this);
+		}
+	}
+	// Vortsetzung senden
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+			tmp->erstellungInitialisierung(sts);
+	}
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+			tmp->erstellungFortsetzen();
+	}
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+		{
+			for (int j = 0; j < spielerAnzahl; j++)
+			{
+				if (accounts->hat(j))
+					tmp->erstellungAddSpieler(accounts->get(j));
+			}
+		}
+	}
+	// warten bis alle ein Team gewählt haben
+	double time = 0;
+	state = 1;
+	ZeitMesser* zeit = new ZeitMesser();
+	while (time < 40)
+	{
+		zeit->messungStart();
+		Sleep(100);
+		char verbleibend = (char)(40 - (char)time);
+		bool weiter = 1;
+		for (int i = 0; i < spielerAnzahl; i++)
+			weiter &= teamAuswahlFertig->hat(i) && teamAuswahlFertig->get(i);
+		if (verbleibend < 0 || weiter)
+		{
+			verbleibend = 0;
+			time = 40;
+		}
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			SSKlient* tmp = klients->z(i);
+			if (tmp)
+				tmp->zeitVerbleibend(verbleibend);
+		}
+		zeit->messungEnde();
+		time += zeit->getSekunden();
+	} // Spielernummern Aufteilen
+	zeit->release();
+	state = 2;
+	teamAusgleich();
+	Array< int >* teams = new Array< int >();
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		int sNum = spielerNummern->hat(i) ? spielerNummern->get(i) : 0;
+		int tg = 1;
+		for (int j = 0; j < sts->teamAnzahl; j++)
+		{
+			tg += sts->teamSize->hat(j) ? sts->teamSize->get(j) : 0;
+			if (sNum < tg)
+			{
+				while (!teams->hat(i))
+					teams->add(0);
+				teams->set(j, i);
+				break;
+			}
+		}
+	}
+	ss->zDB()->spielSetTeams(id, spielerAnzahl, accounts, teams);
+	ss->zDB()->spielSetSpielerNummern(id, spielerAnzahl, accounts, spielerNummern);
+	teams->release();
+	// Fortsetzung senden
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+			tmp->spielLadenBeginn();
+	}
+	// Auf bereitschaft warten
+	while (1)
+	{
+		Sleep(100);
+		bool br = 1;
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			if (klients->z(i))
+				br = br && status->hat(i) && status->get(i) == 2;
+		}
+		if (br)
+			break;
+	} // Spieler hinzufügen
+	for (int i = 0; i < spielerAnzahl; i++)
+		spielerNummern->set((spielerNummern->hat(i) ? spielerNummern->get(i) : 0) - 1, i);
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+		{
+			for (int j = 0; j < spielerAnzahl; j++)
+				tmp->spielLadenSpielerAdd(accounts->hat(j) ? accounts->get(j) : 0, spielerNummern->hat(j) ? spielerNummern->get(j) : 0);
+		}
+	}
+	state = 3;
+	// Warten auf laden
+	while (1)
+	{
+		Sleep(1000);
+		bool br = 1;
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			SSKlient* tmp = klients->z(i);
+			if (tmp)
+			{
+				int ping = (int)(tmp->ping() * 1000 + 0.5);
+				for (int j = 0; j < spielerAnzahl; j++)
+				{
+					SSKlient* k = klients->z(j);
+					if (k)
+					{
+						k->spielLadenSetSpielerPing(accounts->hat(i) ? accounts->get(i) : 0, ping);
+						k->spielLadenSetSpielerProzent(accounts->hat(i) ? accounts->get(i) : 0, prozent->hat(i) ? prozent->get(i) : 0);
+					}
+				}
+				br = br && prozent->hat(i) && prozent->get(i) == 100;
+			}
+		}
+		if (br)
+			break;
+	}
+	state = 4;
+	// Sende Fortsetzung
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+			tmp->spielLadenFertig();
+	}
+	// Spiel Initialisieren
+	Text* pfad = new Text(ss->zInit()->zWert("SpielePfad")->getText());
+	pfad->append("/");
+	pfad->append(ss->zDB()->getSpielArtId(karte));
+	pfad->append("/bin/game");
 #ifdef WIN32
-    pfad->append( ".dll" );
+	pfad->append(".dll");
 #else
-    pfad->append( ".so" );
+	pfad->append(".so");
 #endif
-    spielDll = LoadLibrary( pfad->getText() );
-    if( !spielDll )
-    {
-        char *err = dlerror();
-        Text tmp = ss->zInit()->zWert( "TempMapPfad" )->getText();
-        tmp += "/";
-        tmp += id;
-        DateiRemove( tmp );
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            SSKlient *tmp = klients->z( i );
-            if( tmp )
-            {
-                tmp->setSpiel( 0 );
-                tmp->errorZuKlientSende( Text( "Fehler beim laden des Spiels: " ).operator+( err ) );
-            }
-        }
-        ss->zDB()->setSpielStatusBeendet( id, 4 );
-        ss->removeSpiel( id ); // delete this
-        return;
-    }
-    pfad->release();
-    DllStart getSpielKlasse = (DllStart)GetProcAddress( spielDll, "getSpielKlasse" );
-    if( !getSpielKlasse )
-    {
-        FreeLibrary( spielDll );
-        spielDll = 0;
-        Text tmp = ss->zInit()->zWert( "TempMapPfad" )->getText();
-        tmp += "/";
-        tmp += id;
-        DateiRemove( tmp );
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            SSKlient *tmp = klients->z( i );
-            if( tmp )
-            {
-                tmp->setSpiel( 0 );
-                tmp->errorZuKlientSende( "Fehler beim laden des Spiels. Der Server kann das Spiel nicht finden." );
-            }
-        }
-        ss->zDB()->setSpielStatusBeendet( id, 4 );
-        ss->removeSpiel( id ); // delete this
-        return;
-    }
-    spiel = getSpielKlasse();
-    spiel->setPSQLK( dynamic_cast<SSDatenbankV *>( ss->zDB()->getThis() ) );
-    spiel->setSpielId( id );
-    spiel->setKarteId( karte );
-    Text tmp = ss->zInit()->zWert( "TempMapPfad" )->getText();
-    tmp += "/";
-    tmp += id;
-    spiel->setTempPfad( tmp );
-    spiel->setAccounts( spielerAnzahl, accounts );
-    spiel->setKlients( spielerAnzahl, ( RCArray< SSKlientV > * )klients );
-    spiel->setSpielerNummern( spielerAnzahl, spielerNummern );
-    // auf klients warten
-    while( 1 )
-    {
-        Sleep( 100 );
-        bool br = 1;
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            if( klients->z( i ) )
-                br = br && status->hat( i ) && status->get( i ) == 3;
-        }
-        if( br )
-            break;
-    }
-    // Spiel starten
-    state = 5;
-    ss->zDB()->setSpielStatusIsRunning( id );
-    spiel->run();
-    // Spiel ist zuende
-    state = 6;
-    statistik = spiel->getStatistik();
-    spiel = (SpielKlasse *)spiel->release();
-    statistik->run();
-    // Statistik ist zuende
-    state = 7;
-    statistik = (StatistikV *)statistik->release();
-    FreeLibrary( spielDll );
-    spielDll = 0;
-    DateiRemove( tmp );
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        SSKlient *tmp = klients->z( i );
-        if( tmp )
-            tmp->setSpiel( 0 );
-    }
-    ss->removeSpiel( id ); // delete this
+	spielDll = LoadLibrary(pfad->getText());
+	if (!spielDll)
+	{
+		char* err = dlerror();
+		Text tmp = ss->zInit()->zWert("TempMapPfad")->getText();
+		tmp += "/";
+		tmp += id;
+		DateiRemove(tmp);
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			SSKlient* tmp = klients->z(i);
+			if (tmp)
+			{
+				tmp->setSpiel(0);
+				tmp->errorZuKlientSende(Text("Fehler beim laden des Spiels: ").operator+(err));
+			}
+		}
+		ss->zDB()->setSpielStatusBeendet(id, 4);
+		ss->removeSpiel(id); // delete this
+		return;
+	}
+	pfad->release();
+	DllStart getSpielKlasse = (DllStart)GetProcAddress(spielDll, "getSpielKlasse");
+	if (!getSpielKlasse)
+	{
+		FreeLibrary(spielDll);
+		spielDll = 0;
+		Text tmp = ss->zInit()->zWert("TempMapPfad")->getText();
+		tmp += "/";
+		tmp += id;
+		DateiRemove(tmp);
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			SSKlient* tmp = klients->z(i);
+			if (tmp)
+			{
+				tmp->setSpiel(0);
+				tmp->errorZuKlientSende("Fehler beim laden des Spiels. Der Server kann das Spiel nicht finden.");
+			}
+		}
+		ss->zDB()->setSpielStatusBeendet(id, 4);
+		ss->removeSpiel(id); // delete this
+		return;
+	}
+	spiel = getSpielKlasse();
+	spiel->setPSQLK(dynamic_cast<SSDatenbankV*>(ss->zDB()->getThis()));
+	spiel->setSpielId(id);
+	spiel->setKarteId(karte);
+	Text tmp = ss->zInit()->zWert("TempMapPfad")->getText();
+	tmp += "/";
+	tmp += id;
+	spiel->setTempPfad(tmp);
+	spiel->setAccounts(spielerAnzahl, accounts);
+	spiel->setKlients(spielerAnzahl, (RCArray< SSKlientV > *)klients);
+	spiel->setSpielerNummern(spielerAnzahl, spielerNummern);
+	// auf klients warten
+	while (1)
+	{
+		Sleep(100);
+		bool br = 1;
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			if (klients->z(i))
+				br = br && status->hat(i) && status->get(i) == 3;
+		}
+		if (br)
+			break;
+	}
+	// Spiel starten
+	state = 5;
+	ss->zDB()->setSpielStatusIsRunning(id);
+	spiel->run();
+	// Spiel ist zuende
+	state = 6;
+	statistik = spiel->getStatistik();
+	spiel = (SpielKlasse*)spiel->release();
+	statistik->run();
+	// Statistik ist zuende
+	state = 7;
+	statistik = (StatistikV*)statistik->release();
+	FreeLibrary(spielDll);
+	spielDll = 0;
+	DateiRemove(tmp);
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		SSKlient* tmp = klients->z(i);
+		if (tmp)
+			tmp->setSpiel(0);
+	}
+	ss->removeSpiel(id); // delete this
 }
 
 // constant
 int Spiel::getId() const
 {
-    return id;
+	return id;
 }
 
-int Spiel::getSpielerNummer( int accountId ) const
+int Spiel::getSpielerNummer(int accountId) const
 {
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-            return spielerNummern->hat( i ) ? spielerNummern->get( i ) : 0;
-    }
-    return 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+			return spielerNummern->hat(i) ? spielerNummern->get(i) : 0;
+	}
+	return 0;
 }

SpielServer/Spiel.h

@@ -21,48 +21,48 @@ using namespace Network;
 class Spiel : public Thread
 {
 private:
-	SpielServer *ss;
+	SpielServer* ss;
 	int id;
-	RCArray< SSKlient > *klients;
-	SpielerTeamStruktur *sts;
-	Array< int > *accounts;
-	Array< int > *spielerNummern;
-	Array< int > *status;
-	Array< int > *prozent;
-	Array< bool > *teamAuswahlFertig;
-	SpielKlasse *spiel;
-	StatistikV *statistik;
+	RCArray< SSKlient >* klients;
+	SpielerTeamStruktur* sts;
+	Array< int >* accounts;
+	Array< int >* spielerNummern;
+	Array< int >* status;
+	Array< int >* prozent;
+	Array< bool >* teamAuswahlFertig;
+	SpielKlasse* spiel;
+	StatistikV* statistik;
 	int state;
 	int spielerAnzahl;
 	int karte;
 	HINSTANCE spielDll;
 
-    int findFreeTeam();
-    void teamAusgleich();
+	int findFreeTeam();
+	void teamAusgleich();
 
 public:
 	// Konstruktor
-	Spiel( int id, SpielServer *ss );
+	Spiel(int id, SpielServer* ss);
 	// Destruktor
 	virtual ~Spiel();
 	// nicht constant
-	void setAccounts( int anzahl, Array< int > *zAccounts );
-	void setKlients( int anzahl, RCArray< SSKlient > *zKlients );
-	void setKarteId( int karteId );
-	bool klientVerbunden( SSKlient *klient );
-	bool klientWechseltTeam( int accountId, int team );
-	bool chatNachricht( char *nachricht );
-	bool klientGetrennt( SSKlient *zKlient );
-	bool klientTeamAuswahlFertig( int accountId );
-	bool klientBereitZumLaden( int accountId );
-	bool klientSpielLadenProzent( int accountId, int prozent );
-	bool klientBereitZumSpiel( int accountId );
-	bool spielNachricht( int accountId, int len, char *bytes );
-	bool statistikNachricht( int accountId, int len, char *bytes );
+	void setAccounts(int anzahl, Array< int >* zAccounts);
+	void setKlients(int anzahl, RCArray< SSKlient >* zKlients);
+	void setKarteId(int karteId);
+	bool klientVerbunden(SSKlient* klient);
+	bool klientWechseltTeam(int accountId, int team);
+	bool chatNachricht(const char* nachricht);
+	bool klientGetrennt(SSKlient* zKlient);
+	bool klientTeamAuswahlFertig(int accountId);
+	bool klientBereitZumLaden(int accountId);
+	bool klientSpielLadenProzent(int accountId, int prozent);
+	bool klientBereitZumSpiel(int accountId);
+	bool spielNachricht(int accountId, int len, char* bytes);
+	bool statistikNachricht(int accountId, int len, char* bytes);
 	virtual void thread();
 	// constant
 	int getId() const;
-	int getSpielerNummer( int accountId ) const;
+	int getSpielerNummer(int accountId) const;
 };
 
 #endif

SpielServer/SpielErstellt.cpp

@@ -11,389 +11,389 @@
 
 // Inhalt der SpielErstellt Kasse aus SpielErstellt.h
 // Konstruktor
-SpielErstellt::SpielErstellt( int id, SpielServer *ss )
-    : Thread()
+SpielErstellt::SpielErstellt(int id, SpielServer* ss)
+	: Thread()
 {
-    this->ss = ss;
-    this->id = id;
-    karte = ss->zDB()->getKarteVonErstelltemSpiel( id );
-    spielArt = ss->zDB()->getSpielArtId( karte );
-    accounts = new Array< int >();
-    spielerAnzahl = ss->zDB()->getSpielErstelltSpieler( id, accounts );
-    klients = new RCArray< SSKlient >();
-    status = new Array< int >();
-    verbunden = 0;
-    state = 0;
-    abbr = 0;
-    spielId = 0;
+	this->ss = ss;
+	this->id = id;
+	karte = ss->zDB()->getKarteVonErstelltemSpiel(id);
+	spielArt = ss->zDB()->getSpielArtId(karte);
+	accounts = new Array< int >();
+	spielerAnzahl = ss->zDB()->getSpielErstelltSpieler(id, accounts);
+	klients = new RCArray< SSKlient >();
+	status = new Array< int >();
+	verbunden = 0;
+	state = 0;
+	abbr = 0;
+	spielId = 0;
 }
 
 // Destruktor
 SpielErstellt::~SpielErstellt()
 {
-    ss->release();
-    accounts->release();
-    klients->release();
-    status->release();
+	ss->release();
+	accounts->release();
+	klients->release();
+	status->release();
 }
 
 // nicht constant
 void SpielErstellt::abbruch()
 {
-    abbr = 1;
+	abbr = 1;
 }
 
 void SpielErstellt::sendeVerbindungsBefehl()
 {
-    unsigned short sPort = (unsigned short)ss->getPort();
-    char *sIp = ss->getIp();
-    unsigned char *sIp4 = new unsigned char[ 4 ];
-    Text *tmpT = new Text( sIp );
-    Text *ip1 = tmpT->getTeilText( 0, tmpT->positionVon( '.' ) );
-    Text *ip2 = tmpT->getTeilText( tmpT->positionVon( '.' ) + 1, tmpT->positionVon( '.', 1 ) );
-    Text *ip3 = tmpT->getTeilText( tmpT->positionVon( '.', 1 ) + 1, tmpT->positionVon( '.', 2 ) );
-    Text *ip4 = tmpT->getTeilText( tmpT->positionVon( '.', 2 ) + 1 );
-    sIp4[ 0 ] = (unsigned char)TextZuInt( ip1->getText(), 10 );
-    sIp4[ 1 ] = (unsigned char)TextZuInt( ip2->getText(), 10 );
-    sIp4[ 2 ] = (unsigned char)TextZuInt( ip3->getText(), 10 );
-    sIp4[ 3 ] = (unsigned char)TextZuInt( ip4->getText(), 10 );
-    ip1->release();
-    ip2->release();
-    ip3->release();
-    ip4->release();
-    tmpT->release();
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        int accId = accounts->hat( i ) ? accounts->get( i ) : 0;
-        int port = 0;
-        Text *ip = new Text( "" );
-        if( ss->zDB()->getChatServerPortIp( accId, &port, ip ) )
-        {
-            char ret = 0;
-            Klient *klient = new Klient();
-            unsigned char key[ 20 ] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
-            klient->setSendeKey( (char *)key, 20 );
-            klient->setEmpfangKey( (char *)key, 20 );
-            klient->verbinde( (unsigned short)port, ip->getText() );
-            klient->sendeEncrypted( "\5\x1D", 2 );
-            klient->getNachrichtEncrypted( &ret, 1 );
-            if( ret != 3 )
-            {
-                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 );
-                char *err = new char[ len ];
-                klient->getNachrichtEncrypted( err, len );
-                delete[] err;
-            }
-            klient->sendeEncrypted( "\3", 1 );
-            klient->getNachrichtEncrypted( &ret, 1 );
-            ss->addEmpfangen( klient->getDownloadBytes( 1 ) );
-            ss->addGesendet( klient->getUploadBytes( 1 ) );
-            klient->trenne();
-            klient->release();
-        }
-        ip->release();
-    }
-    delete[] sIp4;
-    start();
+	unsigned short sPort = (unsigned short)ss->getPort();
+	const char* sIp = ss->getIp();
+	unsigned char* sIp4 = new unsigned char[4];
+	Text* tmpT = new Text(sIp);
+	Text* ip1 = tmpT->getTeilText(0, tmpT->positionVon('.'));
+	Text* ip2 = tmpT->getTeilText(tmpT->positionVon('.') + 1, tmpT->positionVon('.', 1));
+	Text* ip3 = tmpT->getTeilText(tmpT->positionVon('.', 1) + 1, tmpT->positionVon('.', 2));
+	Text* ip4 = tmpT->getTeilText(tmpT->positionVon('.', 2) + 1);
+	sIp4[0] = (unsigned char)TextZuInt(ip1->getText(), 10);
+	sIp4[1] = (unsigned char)TextZuInt(ip2->getText(), 10);
+	sIp4[2] = (unsigned char)TextZuInt(ip3->getText(), 10);
+	sIp4[3] = (unsigned char)TextZuInt(ip4->getText(), 10);
+	ip1->release();
+	ip2->release();
+	ip3->release();
+	ip4->release();
+	tmpT->release();
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		int accId = accounts->hat(i) ? accounts->get(i) : 0;
+		int port = 0;
+		Text* ip = new Text("");
+		if (ss->zDB()->getChatServerPortIp(accId, &port, ip))
+		{
+			char ret = 0;
+			Klient* klient = new Klient();
+			unsigned char key[20] = { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 };
+			klient->setSendeKey((char*)key, 20);
+			klient->setEmpfangKey((char*)key, 20);
+			klient->verbinde((unsigned short)port, ip->getText());
+			klient->sendeEncrypted("\5\x1D", 2);
+			klient->getNachrichtEncrypted(&ret, 1);
+			if (ret != 3)
+			{
+				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);
+				char* err = new char[len];
+				klient->getNachrichtEncrypted(err, len);
+				delete[] err;
+			}
+			klient->sendeEncrypted("\3", 1);
+			klient->getNachrichtEncrypted(&ret, 1);
+			ss->addEmpfangen(klient->getDownloadBytes(1));
+			ss->addGesendet(klient->getUploadBytes(1));
+			klient->trenne();
+			klient->release();
+		}
+		ip->release();
+	}
+	delete[] sIp4;
+	start();
 }
 
-bool SpielErstellt::klientVerbunden( SSKlient *klient )
+bool SpielErstellt::klientVerbunden(SSKlient* klient)
 {
-    if( verbunden == spielerAnzahl )
-    {
-        klient->release();
-        return 0;
-    }
-    int accId = klient->getAccountId();
-    bool ret = 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accId )
-        {
-            if( state == 1 )
-                klient->spielGefunden( karte );
-            while( !klients->hat( i ) )
-                klients->add( 0 );
-            klients->set( klient, i );
-            while( !status->hat( i ) )
-                status->add( 0 );
-            status->set( 1, i );
-            verbunden++;
-            klient->setSpielErstellt( this );
-            ret = 1;
-            break;
-        }
-    }
-    if( !ret )
-        klient->release();
-    return ret;
+	if (verbunden == spielerAnzahl)
+	{
+		klient->release();
+		return 0;
+	}
+	int accId = klient->getAccountId();
+	bool ret = 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accId)
+		{
+			if (state == 1)
+				klient->spielGefunden(karte);
+			while (!klients->hat(i))
+				klients->add(0);
+			klients->set(klient, i);
+			while (!status->hat(i))
+				status->add(0);
+			status->set(1, i);
+			verbunden++;
+			klient->setSpielErstellt(this);
+			ret = 1;
+			break;
+		}
+	}
+	if (!ret)
+		klient->release();
+	return ret;
 }
 
-bool SpielErstellt::klientNimmtAn( int accountId )
+bool SpielErstellt::klientNimmtAn(int accountId)
 {
-    if( !verbunden || state != 1 )
-        return 0;
-    bool ret = 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-        {
-            while( !status->hat( i ) )
-                status->add( 0 );
-            status->set( 2, i );
-            ret = 1;
-            break;
-        }
-    }
-    return ret;
+	if (!verbunden || state != 1)
+		return 0;
+	bool ret = 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+		{
+			while (!status->hat(i))
+				status->add(0);
+			status->set(2, i);
+			ret = 1;
+			break;
+		}
+	}
+	return ret;
 }
 
-bool SpielErstellt::klientLehntAb( int accountId )
+bool SpielErstellt::klientLehntAb(int accountId)
 {
-    if( !verbunden || state != 1 )
-        return 0;
-    bool ret = 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accountId )
-        {
-            while( !status->hat( i ) )
-                status->add( 0 );
-            status->set( 3, i );
-            ret = 1;
-            break;
-        }
-    }
-    return ret;
+	if (!verbunden || state != 1)
+		return 0;
+	bool ret = 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accountId)
+		{
+			while (!status->hat(i))
+				status->add(0);
+			status->set(3, i);
+			ret = 1;
+			break;
+		}
+	}
+	return ret;
 }
 
-bool SpielErstellt::klientGetrennt( SSKlient *zKlient )
+bool SpielErstellt::klientGetrennt(SSKlient* zKlient)
 {
-    if( !verbunden )
-        return 0;
-    int accId = zKlient->getAccountId();
-    bool ret = 0;
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        if( accounts->hat( i ) && accounts->get( i ) == accId )
-        {
-            if( status->hat( i ) && status->get( i ) != 0 )
-            {
-                zKlient->setSpielErstellt( 0 );
-                while( !status->hat( i ) )
-                    status->add( 0 );
-                status->set( 0, i );
-                verbunden--;
-                while( !klients->hat( i ) )
-                    klients->add( 0 );
-                klients->set( 0, i );
-                ret = 1;
-            }
-            break;
-        }
-    }
-    return ret;
+	if (!verbunden)
+		return 0;
+	int accId = zKlient->getAccountId();
+	bool ret = 0;
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		if (accounts->hat(i) && accounts->get(i) == accId)
+		{
+			if (status->hat(i) && status->get(i) != 0)
+			{
+				zKlient->setSpielErstellt(0);
+				while (!status->hat(i))
+					status->add(0);
+				status->set(0, i);
+				verbunden--;
+				while (!klients->hat(i))
+					klients->add(0);
+				klients->set(0, i);
+				ret = 1;
+			}
+			break;
+		}
+	}
+	return ret;
 }
 
 void SpielErstellt::thread()
 {
-    state = 1;
-    double time = 0;
-    ZeitMesser *zeit = new ZeitMesser();
-    int nachrichtSenden = 1;
-    while( time < 10 )
-    { // warten auf annahme von allen Spielern
-        if( abbr )
-            break;
-        zeit->messungStart();
-        Sleep( 100 );
-        bool br = 0;
-        bool st2 = 1;
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            if( status->hat( i ) && status->get( i ) == 3 )
-            {
-                br = 1;
-                for( int j = 0; j < spielerAnzahl; j++ )
-                {
-                    if( j != i )
-                    {
-                        while( !status->hat( j ) )
-                            status->add( 0 );
-                        status->set( 2, j );
-                    }
-                    
-                }
-                break;
-            }
-            if( st2 )
-                st2 = status->hat( i ) && status->get( i ) == 2;
-        }
-        if( st2 )
-            br = 1;
-        if( br )
-        {
-            zeit->messungEnde();
-            break;
-        }
-        char verbleibend = (char)( 10 - (char)time );
-        if( verbleibend < 0 )
-            verbleibend = 0;
-        if( time > nachrichtSenden )
-        {
-            for( int i = 0; i < spielerAnzahl; i++ )
-            {
-                if( status->hat( i ) && status->get( i ) != 0 )
-                {
-                    SSKlient *tmp = klients->z( i );
-                    if( tmp )
-                        tmp->zeitVerbleibend( verbleibend );
-                }
-            }
-            nachrichtSenden++;
-        }
-        zeit->messungEnde();
-        time += zeit->getSekunden();
-    } // prüfen ob alle Spieler bereit sind
-    state = 2;
-    bool abbruch = verbunden != spielerAnzahl;
-    const char *err = "Ein Spieler konnte nicht erreicht werden.";
-    if( !abbruch )
-    {
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            if( !status->hat( i ) || status->get( i ) != 2 )
-            {
-                abbruch = 1;
-                err = "Ein Spieler ist noch nicht bereit.";
-                break;
-            }
-        }
-    }
-    if( abbr )
-    {
-        err = "Das Spiel wurde Wegen abwesenheit eines Spielers Abgebrochen.";
-        abbruch = 1;
-        for( int j = 0; j < spielerAnzahl; j++ )
-        {
-            while( !status->hat( j ) )
-                status->add( 0 );
-            status->set( 2, j );
-        }
-    }
-    if( abbruch )
-    { // Es sind nicht alle bereit Vorgang abbrechen
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            if( status->hat( i ) && status->get( i ) != 0 )
-            {
-                SSKlient *tmp = klients->z( i );
-                if( tmp )
-                    tmp->erstellungAbgebrochen( (char *)err );
-            }
-        }
-        Array< bool > *inWarteschlange = new Array< bool >();
-        RCArray< Zeit > *wZeit = new RCArray< Zeit >();
-        if( ss->zDB()->spielErstelltAbbruch( id, spielerAnzahl, accounts, status, inWarteschlange, wZeit ) ) // zurück in Warteschlange
-        {
-            for( int i = 0; i < spielerAnzahl; i++ )
-            {
-                if( inWarteschlange->hat( i ) && inWarteschlange->get( i ) )
-                {
-                    SSKlient *tmp = klients->z( i );
-                    if( tmp )
-                    {
-                        Zeit *zTmp = wZeit->z( i );
-                        if( zTmp )
-                            tmp->backInWarteschlange( (char)zTmp->zUhrzeit()->getStunde(), (char)zTmp->zUhrzeit()->getMinute(), (char)zTmp->zUhrzeit()->getSekunde() );
-                    }
-                }
-            }
-        }
-        inWarteschlange->release();
-        wZeit->release();
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            SSKlient *tmp = klients->z( i );
-            if( tmp )
-                tmp->trenne();
-        }
-        zeit->release();
-        ss->removeSpielErstellt( id ); // delete this
-        return;
-    }
-    // alle Spieler sind bereit Vorgang fortsetzen
-    spielId = ss->zDB()->spielErstelltFortsetzen( id );
-    Spiel *weiter = new Spiel( spielId, dynamic_cast<SpielServer *>( getThis() ) );
-    ss->addSpiel( weiter );
-    weiter->setAccounts( spielerAnzahl, accounts );
-    weiter->setKlients( spielerAnzahl, klients );
-    weiter->setKarteId( karte );
-    ss->removeSpielErstellt( id ); // delete this
-    zeit->release();
+	state = 1;
+	double time = 0;
+	ZeitMesser* zeit = new ZeitMesser();
+	int nachrichtSenden = 1;
+	while (time < 10)
+	{ // warten auf annahme von allen Spielern
+		if (abbr)
+			break;
+		zeit->messungStart();
+		Sleep(100);
+		bool br = 0;
+		bool st2 = 1;
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			if (status->hat(i) && status->get(i) == 3)
+			{
+				br = 1;
+				for (int j = 0; j < spielerAnzahl; j++)
+				{
+					if (j != i)
+					{
+						while (!status->hat(j))
+							status->add(0);
+						status->set(2, j);
+					}
+
+				}
+				break;
+			}
+			if (st2)
+				st2 = status->hat(i) && status->get(i) == 2;
+		}
+		if (st2)
+			br = 1;
+		if (br)
+		{
+			zeit->messungEnde();
+			break;
+		}
+		char verbleibend = (char)(10 - (char)time);
+		if (verbleibend < 0)
+			verbleibend = 0;
+		if (time > nachrichtSenden)
+		{
+			for (int i = 0; i < spielerAnzahl; i++)
+			{
+				if (status->hat(i) && status->get(i) != 0)
+				{
+					SSKlient* tmp = klients->z(i);
+					if (tmp)
+						tmp->zeitVerbleibend(verbleibend);
+				}
+			}
+			nachrichtSenden++;
+		}
+		zeit->messungEnde();
+		time += zeit->getSekunden();
+	} // prüfen ob alle Spieler bereit sind
+	state = 2;
+	bool abbruch = verbunden != spielerAnzahl;
+	const char* err = "Ein Spieler konnte nicht erreicht werden.";
+	if (!abbruch)
+	{
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			if (!status->hat(i) || status->get(i) != 2)
+			{
+				abbruch = 1;
+				err = "Ein Spieler ist noch nicht bereit.";
+				break;
+			}
+		}
+	}
+	if (abbr)
+	{
+		err = "Das Spiel wurde Wegen abwesenheit eines Spielers Abgebrochen.";
+		abbruch = 1;
+		for (int j = 0; j < spielerAnzahl; j++)
+		{
+			while (!status->hat(j))
+				status->add(0);
+			status->set(2, j);
+		}
+	}
+	if (abbruch)
+	{ // Es sind nicht alle bereit Vorgang abbrechen
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			if (status->hat(i) && status->get(i) != 0)
+			{
+				SSKlient* tmp = klients->z(i);
+				if (tmp)
+					tmp->erstellungAbgebrochen((char*)err);
+			}
+		}
+		Array< bool >* inWarteschlange = new Array< bool >();
+		RCArray< Zeit >* wZeit = new RCArray< Zeit >();
+		if (ss->zDB()->spielErstelltAbbruch(id, spielerAnzahl, accounts, status, inWarteschlange, wZeit)) // zurück in Warteschlange
+		{
+			for (int i = 0; i < spielerAnzahl; i++)
+			{
+				if (inWarteschlange->hat(i) && inWarteschlange->get(i))
+				{
+					SSKlient* tmp = klients->z(i);
+					if (tmp)
+					{
+						Zeit* zTmp = wZeit->z(i);
+						if (zTmp)
+							tmp->backInWarteschlange((char)zTmp->zUhrzeit()->getStunde(), (char)zTmp->zUhrzeit()->getMinute(), (char)zTmp->zUhrzeit()->getSekunde());
+					}
+				}
+			}
+		}
+		inWarteschlange->release();
+		wZeit->release();
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			SSKlient* tmp = klients->z(i);
+			if (tmp)
+				tmp->trenne();
+		}
+		zeit->release();
+		ss->removeSpielErstellt(id); // delete this
+		return;
+	}
+	// alle Spieler sind bereit Vorgang fortsetzen
+	spielId = ss->zDB()->spielErstelltFortsetzen(id);
+	Spiel* weiter = new Spiel(spielId, dynamic_cast<SpielServer*>(getThis()));
+	ss->addSpiel(weiter);
+	weiter->setAccounts(spielerAnzahl, accounts);
+	weiter->setKlients(spielerAnzahl, klients);
+	weiter->setKarteId(karte);
+	ss->removeSpielErstellt(id); // delete this
+	zeit->release();
 }
 
 // constant
 int SpielErstellt::getId() const
 {
-    return id;
+	return id;
 }
 
 // Inhalt der SpielFinden Klasse aus SpielErstellt.h
 // Konstruktor
-SpielFinden::SpielFinden( SpielServer *ss )
-    : Thread()
+SpielFinden::SpielFinden(SpielServer* ss)
+	: Thread()
 {
-    this->ss = ss;
-    end = 0;
-    spielServerId = 0;
+	this->ss = ss;
+	end = 0;
+	spielServerId = 0;
 }
 
 // Destruktor
 SpielFinden::~SpielFinden()
 {
-    end = 1;
-    warteAufThread( 2000 );
+	end = 1;
+	warteAufThread(2000);
 }
 
 // nicht constant
 void SpielFinden::setEnde()
 {
-    end = 1;
+	end = 1;
 }
 
-void SpielFinden::setSpielServerId( int id )
+void SpielFinden::setSpielServerId(int id)
 {
-    spielServerId = id;
+	spielServerId = id;
 }
 
 void SpielFinden::thread()
 {
-    end = 0;
-    while( !end )
-    {
-        for( int i = 0; i < 10 && !end; i++ )
-            Sleep( 1000 );
-        if( end )
-            break;
-        int ret = ss->zDB()->erstelleSpiel( spielServerId );
-        if( !ret )
-        { // erfolg
-            int id = ss->zDB()->getSpielErstelltId( spielServerId );
-            SpielErstellt *erstellt = new SpielErstellt( id, dynamic_cast<SpielServer *>( getThis() ) );
-            ss->addSpielErstellt( erstellt );
-            erstellt->sendeVerbindungsBefehl();
-            ss->zDB()->deleteSpielErstelltNext( spielServerId );
-        }
-    }
-    run = 0;
-    end = 0;
+	end = 0;
+	while (!end)
+	{
+		for (int i = 0; i < 10 && !end; i++)
+			Sleep(1000);
+		if (end)
+			break;
+		int ret = ss->zDB()->erstelleSpiel(spielServerId);
+		if (!ret)
+		{ // erfolg
+			int id = ss->zDB()->getSpielErstelltId(spielServerId);
+			SpielErstellt* erstellt = new SpielErstellt(id, dynamic_cast<SpielServer*>(getThis()));
+			ss->addSpielErstellt(erstellt);
+			erstellt->sendeVerbindungsBefehl();
+			ss->zDB()->deleteSpielErstelltNext(spielServerId);
+		}
+	}
+	run = 0;
+	end = 0;
 }

SpielServer/SpielKlasse.h

@@ -15,22 +15,22 @@ class SpielKlasse : public virtual ReferenceCounter
 private:
 
 public:
-    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;
+	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(const 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;
 };
 
 #endif

SpielServer/SpielServer.cpp

@@ -11,1745 +11,1745 @@
 
 // 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 = 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 );
-    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 >();
-    historieS = new HistorieSender( this );
-    historieS->start();
+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 = dynamic_cast<InitDatei*>(zIni->getThis());
+	id = (int)*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);
+	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 >();
+	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 = (SSLSKlient*)klient->release();
-            Sleep( 1000 );
-            return;
-        }
-        if( !klient )
-            continue;
-        SSAKlient* slHandle = new SSAKlient( klient, dynamic_cast<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, dynamic_cast<SpielServer*>(getThis()) );
-        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()));
+		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 < klients->getEintragAnzahl(); i++ )
-        klients->z( i )->absturz();
-    if( klients )
-        klients = (RCArray<SSKlient>*) klients->release();
-    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 < klients->getEintragAnzahl(); i++)
+		klients->z(i)->absturz();
+	if (klients)
+		klients = (RCArray<SSKlient>*) klients->release();
+	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;
-}
-
-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;
-}
-
-void SpielServer::addSpielErstellt( SpielErstellt* erstellt )
-{
-    lock();
-    this->erstellt->add( erstellt );
-    unlock();
-}
-
-void SpielServer::SpielErstelltAbbruch( int spielErstelltId )
-{
-    lock();
-    for( int i = 0; i < erstellt->getEintragAnzahl(); 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 < erstellt->getEintragAnzahl(); i++ )
-    {
-        if( erstellt->z( i )->getId() == id )
-        {
-            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 < klients->getEintragAnzahl(); 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->add( klient );
-    unlock();
-    return 0;
-}
-
-bool SpielServer::absturzKlient( int klientId )
-{
-    lock();
-    SSKlient* zKlient = 0;
-    for( int i = 0; i < klients->getEintragAnzahl(); 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 < erstellt->getEintragAnzahl(); i++ )
-        {
-            SpielErstellt* tmp = erstellt->z( i );
-            if( tmp )
-                tmp->klientGetrennt( zKlient );
-        }
-        for( int i = 0; i < spiele->getEintragAnzahl(); i++ )
-        {
-            Spiel* tmp = spiele->z( i );
-            if( tmp )
-                tmp->klientGetrennt( zKlient );
-        }
-        break;
-    case 1: // Spiel Erstellt
-        for( int i = 0; i < erstellt->getEintragAnzahl(); 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 < spiele->getEintragAnzahl(); i++ )
-        {
-            Spiel* tmp = spiele->z( i );
-            if( tmp && tmp->getId() == id )
-            {
-                tmp->klientGetrennt( zKlient );
-                break;
-            }
-        }
-        break;
-    }
-    bool gefunden = 0;
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i ) == zKlient )
-        {
-            zKlient->absturz();
-            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 < erstellt->getEintragAnzahl(); 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 < spiele->getEintragAnzahl(); 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 < erstellt->getEintragAnzahl(); i++ )
-        {
-            SpielErstellt* tmp = erstellt->z( i );
-            if( tmp )
-                tmp->klientGetrennt( zKlient );
-        }
-        for( int i = 0; i < spiele->getEintragAnzahl(); i++ )
-        {
-            Spiel* tmp = spiele->z( i );
-            if( tmp )
-                tmp->klientGetrennt( zKlient );
-        }
-        break;
-    case 1: // Spiel Erstellt
-        for( int i = 0; i < erstellt->getEintragAnzahl(); 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 < spiele->getEintragAnzahl(); i++ )
-        {
-            Spiel* tmp = spiele->z( i );
-            if( tmp && tmp->getId() == id )
-            {
-                tmp->klientGetrennt( zKlient );
-                break;
-            }
-        }
-        break;
-    }
-    bool gefunden = 0;
-    for( int i = 0; i < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i ) == zKlient )
-        {
-            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 < klients->getEintragAnzahl(); i++ )
-    {
-        if( klients->z( i ) == k )
-        {
-            klients->z( i )->getThis();
-            klients->z( i )->getThis();
-            klients->remove( i );
-        }
-    }
-    unlock();
-}
-
-void SpielServer::addSpiel( Spiel* spiel )
-{
-    lock();
-    spiele->add( spiel );
-    unlock();
-}
-
-void SpielServer::removeSpiel( int spielId )
-{
-    lock();
-    bool gefunden = 0;
-    for( int i = 0; i < spiele->getEintragAnzahl(); i++ )
-    {
-        if( spiele->z( i ) && spiele->z( i )->getId() == spielId )
-        {
-            Spiel* zs = spiele->get( i );
-            spiele->remove( i );
-            unlock();
-            zs->release();
-            gefunden = 1;
-            break;
-        }
-    }
-    if( !gefunden )
-        unlock();
-}
-
-void SpielServer::addGesendet( int bytes )
-{
-    gesendet += bytes;
-}
-
-void SpielServer::addEmpfangen( int bytes )
-{
-    empfangen += bytes;
-}
-
-void SpielServer::addSpielHistorieId( int id )
-{
-    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;
-}
-
-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();
+	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;
+}
+
+void SpielServer::addSpielErstellt(SpielErstellt* erstellt)
+{
+	lock();
+	this->erstellt->add(erstellt);
+	unlock();
+}
+
+void SpielServer::SpielErstelltAbbruch(int spielErstelltId)
+{
+	lock();
+	for (int i = 0; i < erstellt->getEintragAnzahl(); 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 < erstellt->getEintragAnzahl(); i++)
+	{
+		if (erstellt->z(i)->getId() == id)
+		{
+			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 < klients->getEintragAnzahl(); 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->add(klient);
+	unlock();
+	return 0;
+}
+
+bool SpielServer::absturzKlient(int klientId)
+{
+	lock();
+	SSKlient* zKlient = 0;
+	for (int i = 0; i < klients->getEintragAnzahl(); 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 < erstellt->getEintragAnzahl(); i++)
+		{
+			SpielErstellt* tmp = erstellt->z(i);
+			if (tmp)
+				tmp->klientGetrennt(zKlient);
+		}
+		for (int i = 0; i < spiele->getEintragAnzahl(); i++)
+		{
+			Spiel* tmp = spiele->z(i);
+			if (tmp)
+				tmp->klientGetrennt(zKlient);
+		}
+		break;
+	case 1: // Spiel Erstellt
+		for (int i = 0; i < erstellt->getEintragAnzahl(); 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 < spiele->getEintragAnzahl(); i++)
+		{
+			Spiel* tmp = spiele->z(i);
+			if (tmp && tmp->getId() == id)
+			{
+				tmp->klientGetrennt(zKlient);
+				break;
+			}
+		}
+		break;
+	}
+	bool gefunden = 0;
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i) == zKlient)
+		{
+			zKlient->absturz();
+			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 < erstellt->getEintragAnzahl(); 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 < spiele->getEintragAnzahl(); 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 < erstellt->getEintragAnzahl(); i++)
+		{
+			SpielErstellt* tmp = erstellt->z(i);
+			if (tmp)
+				tmp->klientGetrennt(zKlient);
+		}
+		for (int i = 0; i < spiele->getEintragAnzahl(); i++)
+		{
+			Spiel* tmp = spiele->z(i);
+			if (tmp)
+				tmp->klientGetrennt(zKlient);
+		}
+		break;
+	case 1: // Spiel Erstellt
+		for (int i = 0; i < erstellt->getEintragAnzahl(); 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 < spiele->getEintragAnzahl(); i++)
+		{
+			Spiel* tmp = spiele->z(i);
+			if (tmp && tmp->getId() == id)
+			{
+				tmp->klientGetrennt(zKlient);
+				break;
+			}
+		}
+		break;
+	}
+	bool gefunden = 0;
+	for (int i = 0; i < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i) == zKlient)
+		{
+			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 < klients->getEintragAnzahl(); i++)
+	{
+		if (klients->z(i) == k)
+		{
+			klients->z(i)->getThis();
+			klients->z(i)->getThis();
+			klients->remove(i);
+		}
+	}
+	unlock();
+}
+
+void SpielServer::addSpiel(Spiel* spiel)
+{
+	lock();
+	spiele->add(spiel);
+	unlock();
+}
+
+void SpielServer::removeSpiel(int spielId)
+{
+	lock();
+	bool gefunden = 0;
+	for (int i = 0; i < spiele->getEintragAnzahl(); i++)
+	{
+		if (spiele->z(i) && spiele->z(i)->getId() == spielId)
+		{
+			Spiel* zs = spiele->get(i);
+			spiele->remove(i);
+			unlock();
+			zs->release();
+			gefunden = 1;
+			break;
+		}
+	}
+	if (!gefunden)
+		unlock();
+}
+
+void SpielServer::addGesendet(int bytes)
+{
+	gesendet += bytes;
+}
+
+void SpielServer::addEmpfangen(int bytes)
+{
+	empfangen += bytes;
+}
+
+void SpielServer::addSpielHistorieId(int id)
+{
+	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;
+}
+
+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();
 }
 
 // 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
 {
-    return ini;
+	return ini;
 }
 
 bool SpielServer::hatClients() const
 {
-    return klients->hat( 0 );
+	return klients->hat(0);
 }
 
 int SpielServer::getId() const
 {
-    return id;
+	return id;
 }
 
-char* SpielServer::getLetzterFehler() const
+const char* SpielServer::getLetzterFehler() const
 {
-    return fehler->getText();
+	return fehler->getText();
 }
 
-char* SpielServer::getIp() const
+const 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()
+SSAKlient::SSAKlient(SSLSKlient* klient, SpielServer* ss)
+	: 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;
-            case 0xC: // klient absturtz
-                if( 1 )
-                {
-                    klient->sende( "\1", 1 );
-                    int klientId = 0;
-                    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;
-}
-
-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();
-}
-
-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 );
+	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);
+					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;
+}
+
+void SSAKlient::sendeVerzeichnisAnKlient(const 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();
+}
+
+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);
 }
 
 
 // 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 );
+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);
 }
 
 // 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 )
+void SSKlient::setSpielErstellt(SpielErstellt* zErstellt)
 {
-    this->zErstellt = zErstellt;
+	this->zErstellt = zErstellt;
 }
 
-void SSKlient::setSpiel( Spiel* zSpiel )
+void SSKlient::setSpiel(Spiel* zSpiel)
 {
-    this->zSpiel = zSpiel;
+	this->zSpiel = zSpiel;
 }
 
 void SSKlient::nichtTrennen()
 {
-    verbunden = 0;
+	verbunden = 0;
 }
 
-void SSKlient::spielGefunden( int karteId )
+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 )
+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 )
+void SSKlient::erstellungAbgebrochen(const 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 )
+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 ) );
-}
-
-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 ) );
-}
-
-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 ) );
-}
-
-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 ) );
-}
-
-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 ) );
-}
-
-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;
+	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));
+}
+
+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));
+}
+
+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));
+}
+
+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));
+}
+
+void SSKlient::erstellungChatNachricht(const 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));
 }
 
 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 )
+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 )
+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 )
+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 )
+void SSKlient::spielNachricht(short len, const 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 )
+void SSKlient::statistikNachricht(short len, const 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 ) );
-}
-
-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 ) );
+	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));
 }
 
 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 );
-    }
-}
-
-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 ) );
-}
-
-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 ) );
-    }
+	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));
+}
+
+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));
+	}
 }
 
 // const
 int SSKlient::getAccountId() const
 {
-    return accountId;
+	return accountId;
 }
 
 int SSKlient::getKlientNummer() const
 {
-    return klientNummer;
+	return klientNummer;
 }
 
 SKlient* SSKlient::getKlient() const
 {
-    return dynamic_cast<SKlient*>(empfangen->getThis());
+	return dynamic_cast<SKlient*>(empfangen->getThis());
 }

SpielServer/SpielServer.h

@@ -27,18 +27,18 @@ class SSKlient;
 class SpielServer : public Thread
 {
 private:
-	HistorieSender *historieS;
-	Server *server;
-	SSLServer *aServer;
-	InitDatei *ini;
-	SSDatenbank *db;
+	HistorieSender* historieS;
+	Server* server;
+	SSLServer* aServer;
+	InitDatei* ini;
+	SSDatenbank* db;
 	CRITICAL_SECTION cs;
-	SpielFinden *startSpielThread;
-	RCArray< SpielErstellt > *erstellt;
-	RCArray< Spiel > *spiele;
-	RCArray< SSKlient > *klients;
-	Array< int > *spielHistorieId;
-	Text *fehler;
+	SpielFinden* startSpielThread;
+	RCArray< SpielErstellt >* erstellt;
+	RCArray< Spiel >* spiele;
+	RCArray< SSKlient >* klients;
+	Array< int >* spielHistorieId;
+	Text* fehler;
 	int id;
 	bool nichtPausiert;
 	int empfangen;
@@ -47,7 +47,7 @@ private:
 
 public:
 	// Konstruktor 
-	SpielServer( InitDatei *zIni );
+	SpielServer(InitDatei* zIni);
 	// Destruktor 
 	virtual ~SpielServer();
 	// nicht constant
@@ -60,109 +60,109 @@ public:
 	bool serverPause();
 	bool serverFortsetzen();
 	bool serverBeenden();
-	bool setMaxSpiele( int ms );
-	void addSpielErstellt( SpielErstellt *erstellt );
-	void SpielErstelltAbbruch( int spielErstelltId );
-	void removeSpielErstellt( int id );
-	bool registerKlient( SSKlient *klient );
-	bool absturzKlient( int klientId );
-	bool verteileKlient( SSKlient *klient );
-	void unregisterKlient( SSKlient *zKlient );
-	void klientsMM( SSKlient *k );
-	void addSpiel( Spiel *spiel );
-	void removeSpiel( int spielId );
-	void addGesendet( int bytes );
-	void addEmpfangen( int bytes );
-	void addSpielHistorieId( int id );
-	bool hatSpielHistorieId( int id );
-	void removeSpielHistorieId( int id );
+	bool setMaxSpiele(int ms);
+	void addSpielErstellt(SpielErstellt* erstellt);
+	void SpielErstelltAbbruch(int spielErstelltId);
+	void removeSpielErstellt(int id);
+	bool registerKlient(SSKlient* klient);
+	bool absturzKlient(int klientId);
+	bool verteileKlient(SSKlient* klient);
+	void unregisterKlient(SSKlient* zKlient);
+	void klientsMM(SSKlient* k);
+	void addSpiel(Spiel* spiel);
+	void removeSpiel(int spielId);
+	void addGesendet(int bytes);
+	void addEmpfangen(int bytes);
+	void addSpielHistorieId(int id);
+	bool hatSpielHistorieId(int id);
+	void removeSpielHistorieId(int id);
 	// conatant 
 	bool istAn() const;
-	Server *zServer() const;
-	SSDatenbank *zDB() const;
-    InitDatei *zInit() const;
+	Server* zServer() const;
+	SSDatenbank* zDB() const;
+	InitDatei* zInit() const;
 	bool hatClients() const;
 	int getId() const;
-	char *getLetzterFehler() const;
-	char *getIp() const;
+	const char* getLetzterFehler() const;
+	const char* getIp() const;
 	int getPort() const;
 };
 
 class SSAKlient : public Thread
 {
 private:
-	SSLSKlient *klient;
-	Text *name;
-	Text *passwort;
+	SSLSKlient* klient;
+	Text* name;
+	Text* passwort;
 	int adminId;
-	SpielServer *ss;
+	SpielServer* ss;
 	int version;
 
 public:
 	// Konstruktor 
-	SSAKlient( SSLSKlient *klient, SpielServer *ss );
+	SSAKlient(SSLSKlient* klient, SpielServer* ss);
 	// Destruktor 
 	virtual ~SSAKlient();
 	// nicht constant
 	void thread();
-	void sendeVerzeichnisAnKlient( char *pfad, int );
-	void errorZuKlient( const char *nachricht ) const; // sendet eine Fehlernachricht zum AKlient
+	void sendeVerzeichnisAnKlient(const char* pfad, int);
+	void errorZuKlient(const char* nachricht) const; // sendet eine Fehlernachricht zum AKlient
 };
 
 class SSKlient : public SSKlientV
 {
 private:
-	SKlient     *empfangen;
-	SKlient     *senden;
+	SKlient* empfangen;
+	SKlient* senden;
 	unsigned int klientNummer;
-	SpielServer *ss;
+	SpielServer* ss;
 	int accountId;
 	bool termThread;
 	bool verbunden;
-	SpielErstellt *zErstellt;
-	Spiel *zSpiel;
+	SpielErstellt* zErstellt;
+	Spiel* zSpiel;
 	CRITICAL_SECTION cs;
 
 public:
 	// Konstruktor 
-	SSKlient( SKlient *klient, SpielServer *ss );
+	SSKlient(SKlient* klient, SpielServer* ss);
 	// Destruktor 
-	virtual ~SSKlient();
+	virtual ~SSKlient() override;
 	// nicht constant 
 	void lock();
 	void unlock();
 	void absturz();
-	void setSpielErstellt( SpielErstellt *zErstellt );
-	void setSpiel( Spiel *zSpiel );
-	virtual void nichtTrennen();
-	void spielGefunden( int karteId );
-	void zeitVerbleibend( char sekunden );
-	void erstellungAbgebrochen( char *grund );
-	void backInWarteschlange( char st, char min, char sec );
+	void setSpielErstellt(SpielErstellt* zErstellt);
+	void setSpiel(Spiel* zSpiel);
+	virtual void nichtTrennen() override;
+	void spielGefunden(int karteId);
+	void zeitVerbleibend(char sekunden);
+	void erstellungAbgebrochen(const char* grund);
+	void backInWarteschlange(char st, char min, char sec);
 	void erstellungFortsetzen();
-	void erstellungInitialisierung( SpielerTeamStruktur *sts );
-	void erstellungAddSpieler( int accountId );
-	void erstellungRemoveSpieler( int accountId );
-	void erstellungSpielerTeam( int accountId, int spielerNummer );
-	void erstellungChatNachricht( char *nachricht );
+	void erstellungInitialisierung(SpielerTeamStruktur* sts);
+	void erstellungAddSpieler(int accountId);
+	void erstellungRemoveSpieler(int accountId);
+	void erstellungSpielerTeam(int accountId, int spielerNummer);
+	void erstellungChatNachricht(const char* nachricht);
 	void spielLadenBeginn();
-	void spielLadenSpielerAdd( int accId, int spielerNumer );
-	void spielLadenSetSpielerProzent( int accId, int prozent );
-	void spielLadenSetSpielerPing( int accId, int ping );
-	virtual double ping();
+	void spielLadenSpielerAdd(int accId, int spielerNumer);
+	void spielLadenSetSpielerProzent(int accId, int prozent);
+	void spielLadenSetSpielerPing(int accId, int ping);
+	virtual double ping() override;
 	void spielLadenFertig();
-	virtual void spielNachricht( short len, char *bytes );
-	virtual void statistikNachricht( short len, char *bytes );
+	virtual void spielNachricht(short len, const char* bytes) override;
+	virtual void statistikNachricht(short len, const char* bytes) override;
 	bool keepAlive();
-	virtual void trenne();
-	void setSenden( SSKlient *klient );
-	virtual void thread();
-	virtual void errorZuKlientEmpfang( const char *nachricht ); // sendet eine Fehlernachricht zum Klient
-	virtual void errorZuKlientSende( const char *nachricht );
+	virtual void trenne() override;
+	void setSenden(SSKlient* klient);
+	virtual void thread() override;
+	virtual void errorZuKlientEmpfang(const char* nachricht) override; // sendet eine Fehlernachricht zum Klient
+	virtual void errorZuKlientSende(const char* nachricht) override;
 	// const
-	virtual int getAccountId() const;
+	virtual int getAccountId() const override;
 	int getKlientNummer() const;
-	SKlient *getKlient() const;
+	SKlient* getKlient() const;
 };
 
 #endif

SpielServer/Strukturen.cpp

@@ -2,20 +2,20 @@
 
 // Inhalt der SpielerTeamStruktur Struktur aus Strukturen.h
 SpielerTeamStruktur::SpielerTeamStruktur()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    spielerAnzahl = 0;
-    teamAnzahl = 0;
-    spielerFarbe = new Array< int >();
-    teamFarbe = new Array< int >();
-    teamName = new RCArray< Text >();
-    teamSize = new Array< int >();
+	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();
+	spielerFarbe->release();
+	teamFarbe->release();
+	teamName->release();
+	teamSize->release();
 }

SpielServer/start.cpp

@@ -7,54 +7,54 @@
 
 int main()
 {
-    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->getText() );
-    std::ofstream file;
-    file.open( pfad->getText() );
-    std::streambuf *sbuf = std::cout.rdbuf();
-    std::cout.rdbuf( file.rdbuf() );
-    pfad->release();
+	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->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 );
-    }
-    const char *wichtig[] = { "ServerId", "DBBenutzer", "DBPasswort", "DBName", "DBIP", "DBPort", "Aktiv", "SpielePfad", "TempMapPfad", "SSLCert", "SSLKey", "SSLPasswort" };
-    for( const char *w : wichtig )
-    {
-        if( !dat->wertExistiert( w ) )
-        {
-            std::cout << "SS: error: Der Wert '" << w << "' wurde nicht gefunden. 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)
+	{
+		if (!dat->wertExistiert(w))
+		{
+			std::cout << "SS: error: Der Wert '" << w << "' wurde nicht gefunden. Das Programm wird geschlossen.\n";
+			dat->release();
+			exit(1);
+		}
+	}
 
-    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();
-    DateiRemove( dat->zWert( "TempMapPfad" )->getText() );
-    dat->release();
-    std::cout << "SS: Der Server ist heruntergefahren.\n";
-    file.close();
-    std::cout.rdbuf( sbuf );
-    Framework::releaseFramework();
-    return 0;
+	sServer->ende();
+	sServer->release();
+	DateiRemove(dat->zWert("TempMapPfad")->getText());
+	dat->release();
+	std::cout << "SS: Der Server ist heruntergefahren.\n";
+	file.close();
+	std::cout.rdbuf(sbuf);
+	Framework::releaseFramework();
+	return 0;
 }